[codex] Refactor client-runtime Effect services

apps/mobile/src/connection/catalog-store.ts

@@ -18,7 +18,7 @@ export const LEGACY_CONNECTIONS_KEY = "t3code.connections";
 function catalogError(operation: string, cause: unknown) {
   return new ConnectionTransientError({
     reason: "remote-unavailable",
-    message: `Could not ${operation} the local connection catalog: ${String(cause)}`,
+    detail: `Could not ${operation} the local connection catalog: ${String(cause)}`,
   });
 }
 

apps/mobile/src/connection/platform.ts

@@ -10,8 +10,8 @@ import {
 import {
   ConnectionBlockedError,
   ConnectionTransientError,
-  ConnectionWakeups,
   Connectivity,
+  Wakeups,
 } from "@t3tools/client-runtime/connection";
 import { managedRelayAccountChanges, managedRelaySessionAtom } from "@t3tools/client-runtime/relay";
 import { AuthStandardClientScopes } from "@t3tools/contracts";
@@ -41,53 +41,47 @@ function networkStatus(state: Network.NetworkState): "unknown" | "offline" | "on
   return "unknown";
 }
 
-const connectivityLayer = Layer.succeed(
-  Connectivity,
-  Connectivity.of({
-    status: Effect.tryPromise({
-      try: () => Network.getNetworkStateAsync(),
-      catch: () => undefined,
-    }).pipe(
-      Effect.match({
-        onFailure: () => "unknown" as const,
-        onSuccess: networkStatus,
-      }),
-    ),
-    changes: Stream.callback((queue) =>
+const connectivityLayer = Connectivity.layer({
+  status: Effect.tryPromise({
+    try: () => Network.getNetworkStateAsync(),
+    catch: () => undefined,
+  }).pipe(
+    Effect.match({
+      onFailure: () => "unknown" as const,
+      onSuccess: networkStatus,
+    }),
+  ),
+  changes: Stream.callback((queue) =>
+    Effect.acquireRelease(
+      Effect.sync(() =>
+        Network.addNetworkStateListener((state) => {
+          Queue.offerUnsafe(queue, networkStatus(state));
+        }),
+      ),
+      (subscription) => Effect.sync(() => subscription.remove()),
+    ).pipe(Effect.asVoid),
+  ),
+});
+
+const wakeupsLayer = Wakeups.layer({
+  changes: Stream.merge(
+    Stream.callback<"application-active">((queue) =>
       Effect.acquireRelease(
         Effect.sync(() =>
-          Network.addNetworkStateListener((state) => {
-            Queue.offerUnsafe(queue, networkStatus(state));
+          AppState.addEventListener("change", (state) => {
+            if (state === "active") {
+              Queue.offerUnsafe(queue, "application-active");
+            }
           }),
         ),
         (subscription) => Effect.sync(() => subscription.remove()),
       ).pipe(Effect.asVoid),
     ),
-  }),
-);
-
-const wakeupsLayer = Layer.succeed(
-  ConnectionWakeups,
-  ConnectionWakeups.of({
-    changes: Stream.merge(
-      Stream.callback<"application-active">((queue) =>
-        Effect.acquireRelease(
-          Effect.sync(() =>
-            AppState.addEventListener("change", (state) => {
-              if (state === "active") {
-                Queue.offerUnsafe(queue, "application-active");
-              }
-            }),
-          ),
-          (subscription) => Effect.sync(() => subscription.remove()),
-        ).pipe(Effect.asVoid),
-      ),
-      managedRelayAccountChanges(appAtomRegistry).pipe(
-        Stream.map(() => "credentials-changed" as const),
-      ),
+    managedRelayAccountChanges(appAtomRegistry).pipe(
+      Stream.map(() => "credentials-changed" as const),
     ),
-  }),
-);
+  ),
+});
 
 const capabilitiesLayer = Layer.succeedContext(
   Context.make(
@@ -98,22 +92,22 @@ const capabilitiesLayer = Layer.succeedContext(
         if (session === null) {
           return yield* new ConnectionBlockedError({
             reason: "authentication",
-            message: "Sign in to T3 Cloud to connect this environment.",
+            detail: "Sign in to T3 Cloud to connect this environment.",
           });
         }
         const token = yield* session.readClerkToken().pipe(
           Effect.mapError(
             (error) =>
               new ConnectionTransientError({
                 reason: "network",
-                message: error.message,
+                detail: error.message,
               }),
           ),
         );
         if (token === null) {
           return yield* new ConnectionBlockedError({
             reason: "authentication",
-            message: "The T3 Cloud session is unavailable.",
+            detail: "The T3 Cloud session is unavailable.",
           });
         }
         return token;
@@ -132,7 +126,7 @@ const capabilitiesLayer = Layer.succeedContext(
           catch: (cause) =>
             new ConnectionTransientError({
               reason: "remote-unavailable",
-              message: `Could not load the mobile device identity: ${String(cause)}`,
+              detail: `Could not load the mobile device identity: ${String(cause)}`,
             }),
         }).pipe(Effect.map(Option.some)),
       }),
@@ -151,14 +145,14 @@ const capabilitiesLayer = Layer.succeedContext(
           Effect.fail(
             new ConnectionBlockedError({
               reason: "unsupported",
-              message: "SSH environments are only available in the desktop app.",
+              detail: "SSH environments are only available in the desktop app.",
             }),
           ),
         prepare: () =>
           Effect.fail(
             new ConnectionBlockedError({
               reason: "unsupported",
-              message: "SSH environments are only available in the desktop app.",
+              detail: "SSH environments are only available in the desktop app.",
             }),
           ),
         disconnect: () => Effect.void,
@@ -195,7 +189,19 @@ const environmentOwnedDataCleanupLayer = Layer.succeed(
   }),
 );
 
-export const connectionPlatformLayer = Layer.mergeAll(
+type ConnectionPlatformLayerSource =
+  | typeof connectionStorageLayer
+  | typeof connectivityLayer
+  | typeof wakeupsLayer
+  | typeof capabilitiesLayer
+  | typeof platformConnectionSourceLayer
+  | typeof environmentOwnedDataCleanupLayer;
+
+export const connectionPlatformLayer: Layer.Layer<
+  Layer.Success<ConnectionPlatformLayerSource>,
+  Layer.Error<ConnectionPlatformLayerSource>,
+  Layer.Services<ConnectionPlatformLayerSource>
+> = Layer.mergeAll(
   connectionStorageLayer,
   connectivityLayer,
   wakeupsLayer,

apps/mobile/src/connection/runtime.ts

@@ -1,16 +1,28 @@
-import { connectionLayer as clientConnectionLayer } from "@t3tools/client-runtime/connection";
+import { Connection } from "@t3tools/client-runtime/connection";
 import * as Layer from "effect/Layer";
 import { Atom } from "effect/unstable/reactivity";
 
 import { runtimeContextLayer } from "../lib/runtime";
 import { connectionPlatformLayer } from "./platform";
 
-const providedConnectionPlatformLayer = connectionPlatformLayer.pipe(
-  Layer.provide(runtimeContextLayer),
-);
+const providedConnectionPlatformLayer: Layer.Layer<
+  Layer.Success<typeof connectionPlatformLayer>,
+  Layer.Error<typeof connectionPlatformLayer>
+> = connectionPlatformLayer.pipe(Layer.provide(runtimeContextLayer));
+
+type ConnectionLayerSource =
+  | typeof Connection.layer
+  | typeof runtimeContextLayer
+  | typeof providedConnectionPlatformLayer;
 
-export const connectionLayer = clientConnectionLayer.pipe(
+export const connectionLayer: Layer.Layer<
+  Layer.Success<ConnectionLayerSource>,
+  Layer.Error<ConnectionLayerSource>
+> = Connection.layer.pipe(
   Layer.provideMerge(Layer.mergeAll(runtimeContextLayer, providedConnectionPlatformLayer)),
 );
 
-export const connectionAtomRuntime = Atom.runtime(connectionLayer);
+export const connectionAtomRuntime: Atom.AtomRuntime<
+  Layer.Success<typeof connectionLayer>,
+  Layer.Error<typeof connectionLayer>
+> = Atom.runtime(connectionLayer);

apps/mobile/src/connection/storage.ts

@@ -8,11 +8,11 @@ import {
   removeCatalogValue,
   replaceCatalogValue,
 } from "@t3tools/client-runtime/platform";
-import { RemoteDpopAccessTokenStore } from "@t3tools/client-runtime/authorization";
+import { TokenStore } from "@t3tools/client-runtime/authorization";
 import {
-  ConnectionCredentialStore,
-  ConnectionProfileStore,
   ConnectionTransientError,
+  CredentialStore,
+  ProfileStore,
 } from "@t3tools/client-runtime/connection";
 import {
   EnvironmentId,
@@ -58,7 +58,7 @@ const LegacyStoredShellSnapshot = Schema.Struct({
 function catalogError(operation: string, cause: unknown) {
   return new ConnectionTransientError({
     reason: "remote-unavailable",
-    message: `Could not ${operation} the local connection catalog: ${String(cause)}`,
+    detail: `Could not ${operation} the local connection catalog: ${String(cause)}`,
   });
 }
 
@@ -197,7 +197,7 @@ export const connectionStorageLayer = Layer.effectContext(
           .update((document) => removeConnectionFromCatalog(document, target))
           .pipe(Effect.mapError((error) => targetPersistenceError("remove-connection", error))),
     });
-    const profileStore = ConnectionProfileStore.of({
+    const profileStore = ProfileStore.make({
       get: (connectionId) =>
         catalog.read.pipe(
           Effect.map((document) =>
@@ -221,7 +221,7 @@ export const connectionStorageLayer = Layer.effectContext(
           ),
         })),
     });
-    const credentialStore = ConnectionCredentialStore.of({
+    const credentialStore = CredentialStore.make({
       get: (connectionId) =>
         catalog.read.pipe(
           Effect.map((document) =>
@@ -248,7 +248,7 @@ export const connectionStorageLayer = Layer.effectContext(
           ),
         })),
     });
-    const remoteTokenStore = RemoteDpopAccessTokenStore.of({
+    const remoteTokenStore = TokenStore.make({
       get: (environmentId) =>
         catalog.read.pipe(
           Effect.map((document) =>
@@ -423,9 +423,9 @@ export const connectionStorageLayer = Layer.effectContext(
 
     return Context.make(ConnectionTargetStore, targetStore).pipe(
       Context.add(ConnectionRegistrationStore, registrationStore),
-      Context.add(ConnectionProfileStore, profileStore),
-      Context.add(ConnectionCredentialStore, credentialStore),
-      Context.add(RemoteDpopAccessTokenStore, remoteTokenStore),
+      Context.add(ProfileStore.ConnectionProfileStore, profileStore),
+      Context.add(CredentialStore.ConnectionCredentialStore, credentialStore),
+      Context.add(TokenStore.RemoteDpopAccessTokenStore, remoteTokenStore),
       Context.add(EnvironmentCacheStore, cacheStore),
     );
   }),

apps/web/src/cloud/linkEnvironment.test.ts

@@ -15,9 +15,7 @@ import { HttpClient } from "effect/unstable/http";
 import { afterEach, beforeEach, vi } from "vite-plus/test";
 import {
   AVAILABLE_CONNECTION_STATE,
-  type EnvironmentRegistryService,
   EnvironmentSupervisor,
-  type EnvironmentSupervisorService,
   type PreparedConnection,
   PrimaryConnectionTarget,
 } from "@t3tools/client-runtime/connection";
@@ -114,13 +112,13 @@ function registryLayer(options?: {
         connect: Effect.void,
         disconnect: Effect.void,
         retryNow: Effect.void,
-      } satisfies EnvironmentSupervisorService);
+      } satisfies EnvironmentSupervisor["Service"]);
       const registry = {
         run: <A, E, R>(_environmentId: EnvironmentId, effect: Effect.Effect<A, E, R>) =>
           Effect.provideService(effect, EnvironmentSupervisor, supervisor),
         runStream: <A, E, R>(_environmentId: EnvironmentId, stream: Stream.Stream<A, E, R>) =>
           Stream.provideService(stream, EnvironmentSupervisor, supervisor),
-      } as unknown as EnvironmentRegistryService;
+      } as unknown as EnvironmentRegistry["Service"];
       return EnvironmentRegistry.of(registry);
     }),
   );