t3code-cli 0.12.0 → 0.13.0

package/src/connection/prepared.ts

@@ -0,0 +1,83 @@
+import { resolveRemoteWebSocketConnectionUrl } from "@t3tools/client-runtime/authorization";
+import {
+  BearerConnectionTarget,
+  type ConnectionAttemptError,
+  mapRemoteEnvironmentError,
+  type PreparedConnection,
+} from "@t3tools/client-runtime/connection";
+import { fetchRemoteEnvironmentDescriptor } from "@t3tools/client-runtime/environment";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+
+import { toWebSocketEndpointUrl } from "../config/url/url.ts";
+import { T3CodeConnectionError } from "./error.ts";
+import { T3CodeConnectionProvider } from "./service.ts";
+import type { T3CodeConnection } from "./type.ts";
+
+export class T3PreparedConnectionProvider extends Context.Service<
+  T3PreparedConnectionProvider,
+  {
+    readonly get: Effect.Effect<PreparedConnection, ConnectionAttemptError | T3CodeConnectionError>;
+  }
+>()("t3cli/T3PreparedConnectionProvider") {}
+
+const makePreparedConnection = Effect.fn("makePreparedConnection")(function* (
+  connection: T3CodeConnection,
+) {
+  const httpBaseUrl = connection.origin.url;
+  const wsBaseUrl = yield* toWebSocketEndpointUrl(httpBaseUrl, "/ws").pipe(
+    Effect.mapError(
+      (error) =>
+        new T3CodeConnectionError({
+          message: "failed to resolve websocket endpoint",
+          cause: error,
+        }),
+    ),
+  );
+  const descriptor = yield* fetchRemoteEnvironmentDescriptor({ httpBaseUrl }).pipe(
+    Effect.mapError(mapRemoteEnvironmentError),
+  );
+  const socketUrl = yield* resolveRemoteWebSocketConnectionUrl({
+    httpBaseUrl,
+    wsBaseUrl,
+    bearerToken: connection.auth.token,
+  }).pipe(Effect.mapError(mapRemoteEnvironmentError));
+
+  return {
+    environmentId: descriptor.environmentId,
+    label: descriptor.label,
+    httpBaseUrl,
+    socketUrl,
+    httpAuthorization: {
+      _tag: "Bearer",
+      token: connection.auth.token,
+    },
+    target: new BearerConnectionTarget({
+      environmentId: descriptor.environmentId,
+      label: descriptor.label,
+      connectionId: descriptor.environmentId,
+    }),
+  } satisfies PreparedConnection;
+});
+
+const makeT3PreparedConnectionProvider = Effect.fn("makeT3PreparedConnectionProvider")(
+  function* () {
+    const connectionProvider = yield* T3CodeConnectionProvider;
+    const httpClient = yield* HttpClient.HttpClient;
+    const get = connectionProvider.get.pipe(
+      Effect.flatMap((connection) =>
+        makePreparedConnection(connection).pipe(
+          Effect.provideService(HttpClient.HttpClient, httpClient),
+        ),
+      ),
+    );
+    return T3PreparedConnectionProvider.of({ get });
+  },
+);
+
+export const T3PreparedConnectionProviderLive = Layer.effect(
+  T3PreparedConnectionProvider,
+  makeT3PreparedConnectionProvider(),
+);

package/src/orchestration/layer.ts

@@ -25,7 +25,8 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
         client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
       )
       .pipe(
-        Stream.map((item: OrchestrationShellStreamItem) =>
+        Stream.filter((item: OrchestrationShellStreamItem) => item.kind !== "synchronized"),
+        Stream.map((item) =>
           item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
         ),
       );

package/src/rpc/error.ts

@@ -1,21 +1,19 @@
-import * as Schema from "effect/Schema";
+import {
+  ConnectionBlockedError,
+  ConnectionTransientError,
+} from "@t3tools/client-runtime/connection";
 import {
   EnvironmentAuthorizationError,
   KeybindingsConfigError,
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
+  TerminalError,
 } from "@t3tools/contracts";
-import { HttpClientError } from "effect/unstable/http";
+import * as Schema from "effect/Schema";
 import { RpcClientError } from "effect/unstable/rpc";
 
-import { AuthTransportError } from "../auth/error.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
-import { UrlError } from "../config/url/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,
@@ -24,15 +22,10 @@ const RpcErrorCauseSchema = Schema.Union([
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
-  AuthTransportError,
+  TerminalError,
+  ConnectionBlockedError,
+  ConnectionTransientError,
   T3CodeConnectionError,
-  HttpClientError.HttpClientErrorSchema,
-  UrlError,
-  Schema.instanceOf(Schema.SchemaError),
 ]);
 
 export type RpcKnownCause = Schema.Schema.Type<typeof RpcErrorCauseSchema>;

package/src/rpc/index.ts

@@ -1,5 +1,6 @@
-export { RpcError } from "./error.ts";
+export { RpcError, type OrchestrationError } from "./error.ts";
 export { makeT3RpcLayer, T3RpcLive } from "./layer.ts";
 export { T3RpcOperations, T3RpcOperationsLive, makeT3RpcOperations } from "./operation.ts";
+export type { T3RpcOperationsService } from "./operation.ts";
 export { T3Rpc } from "./service.ts";
-export type { WsClient } from "./service.ts";
+export type { T3RpcService, WsClient } from "./service.ts";

package/src/rpc/layer.ts

@@ -3,22 +3,22 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as SynchronizedRef from "effect/SynchronizedRef";
-import { HttpClientRequest } from "effect/unstable/http";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-import * as Socket from "effect/unstable/socket/Socket";
 
-import { T3AuthTransport } from "../auth/transport.ts";
-import { T3CodeConnectionProvider } from "../connection/service.ts";
-import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url/url.ts";
-import { CliWsRpcGroup } from "./ws-group.ts";
+import { T3PreparedConnectionProvider } from "../connection/prepared.ts";
 import { RpcError } from "./error.ts";
+import { T3RpcSessionFactory } from "./session.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
 
-const makeClient = RpcClient.make(CliWsRpcGroup);
-const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(Schedule.take(4));
+const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(
+  Schedule.take(4),
+  Schedule.collectWhile((metadata: Schedule.Metadata) =>
+    Predicate.isTagged(metadata.input, "ConnectionTransientError"),
+  ),
+);
 
 type Connection = {
   readonly scope: Scope.Closeable;
@@ -26,23 +26,19 @@ type Connection = {
 };
 
 export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
-  const connectionProvider = yield* T3CodeConnectionProvider;
-  const authTransport = yield* T3AuthTransport;
-  const webSocketConstructor = yield* Socket.WebSocketConstructor;
+  const preparedConnectionProvider = yield* T3PreparedConnectionProvider;
+  const sessions = yield* T3RpcSessionFactory;
   const parentScope = yield* Scope.Scope;
   const connection = yield* SynchronizedRef.make(Option.none<Connection>());
   const openConnection = Effect.fn("T3RpcLive.openConnection")(function* () {
     const scope = yield* Scope.fork(parentScope);
     return yield* Effect.gen(function* () {
-      const url = yield* makeWsUrl({ authTransport, connectionProvider });
-      const protocol = yield* Layer.buildWithScope(
-        makeProtocolLayer(url, webSocketConstructor),
-        scope,
-      );
-      const client = yield* makeClient.pipe(
-        Effect.provide(protocol),
-        Effect.provideService(Scope.Scope, scope),
-      );
+      const prepared = yield* preparedConnectionProvider.get;
+      const session = yield* sessions
+        .connect(prepared)
+        .pipe(Effect.provideService(Scope.Scope, scope));
+      yield* session.ready;
+      const client: WsClient = session.client;
       return { scope, client } satisfies Connection;
     }).pipe(
       Effect.retry(connectionRetrySchedule),
@@ -74,36 +70,6 @@ export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
   };
 });
 
-const makeWsUrl = Effect.fn("makeWsUrl")(function* (input: {
-  readonly authTransport: T3AuthTransport["Service"];
-  readonly connectionProvider: T3CodeConnectionProvider["Service"];
-}) {
-  const connection = yield* input.connectionProvider.get;
-  const origin = yield* normalizeHttpBaseUrl(connection.origin.url);
-  const wsTicket = yield* input.authTransport.issueWebSocketTicket({
-    url: origin,
-    token: connection.auth.token,
-  });
-  const wsUrl = yield* toWebSocketEndpointUrl(origin, "/ws");
-  const request = HttpClientRequest.get(wsUrl).pipe(
-    HttpClientRequest.setUrlParam("wsTicket", wsTicket.ticket),
-  );
-  return Option.getOrThrow(HttpClientRequest.toUrl(request)).toString();
-});
-
-function makeProtocolLayer(
-  url: string,
-  webSocketConstructor: Socket.WebSocketConstructor["Service"],
-) {
-  const socketLayer = Socket.layerWebSocket(url).pipe(
-    Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor)),
-  );
-  return RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(
-    Layer.provide(socketLayer),
-    Layer.provide(RpcSerialization.layerJson),
-  );
-}
-
 export const T3RpcLive = Layer.effectContext(
   makeT3RpcLayer().pipe(Effect.map((rpc) => Context.make(T3Rpc, rpc))),
 );

package/src/rpc/operation.ts

@@ -1,3 +1,11 @@
+import type {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerSettingsError,
+  TerminalError,
+} from "@t3tools/contracts";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -8,9 +16,15 @@ import { RpcClientError } from "effect/unstable/rpc";
 
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
-import type { CliRpcRequestError } from "./ws-group.ts";
 
-export type CliRpcOperationError = CliRpcRequestError | RpcClientError.RpcClientError;
+export type CliRpcOperationError =
+  | EnvironmentAuthorizationError
+  | KeybindingsConfigError
+  | OrchestrationDispatchCommandError
+  | OrchestrationGetSnapshotError
+  | RpcClientError.RpcClientError
+  | ServerSettingsError
+  | TerminalError;
 
 export const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
   Schedule.take(4),

package/src/rpc/service.ts

@@ -1,8 +1,9 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type { RpcClient, RpcClientError } from "effect/unstable/rpc";
-import type { CliWsRpcGroup } from "./ws-group.ts";
+
 import type { RpcError } from "./error.ts";
+import type { CliWsRpcGroup } from "./ws-group.ts";
 
 export type WsClient = RpcClient.FromGroup<typeof CliWsRpcGroup, RpcClientError.RpcClientError>;
 

package/src/rpc/session.ts

@@ -0,0 +1,168 @@
+import {
+  ConnectionBlockedError,
+  type ConnectionAttemptError,
+  ConnectionTransientError,
+  type PreparedConnection,
+} from "@t3tools/client-runtime/connection";
+import { WS_METHODS } from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
+import type * as Scope from "effect/Scope";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import type { WsClient as CliWsClient } from "./service.ts";
+import type { CliServerConfig } from "./ws-group.ts";
+import { CliWsRpcGroup } from "./ws-group.ts";
+
+interface T3RpcSession {
+  readonly client: CliWsClient;
+  readonly initialConfig: Effect.Effect<CliServerConfig, ConnectionAttemptError>;
+  readonly ready: Effect.Effect<void, ConnectionAttemptError>;
+  readonly probe: Effect.Effect<void, ConnectionAttemptError>;
+  readonly closed: Effect.Effect<never, ConnectionTransientError>;
+}
+
+export class T3RpcSessionFactory extends Context.Service<
+  T3RpcSessionFactory,
+  {
+    readonly connect: (
+      connection: PreparedConnection,
+    ) => Effect.Effect<T3RpcSession, ConnectionAttemptError, Scope.Scope>;
+  }
+>()("t3cli/T3RpcSessionFactory") {}
+
+type SessionRpcError =
+  | Effect.Error<ReturnType<CliWsClient[typeof WS_METHODS.serverGetConfig]>>
+  | Effect.Error<ReturnType<CliWsClient[typeof WS_METHODS.serverProbe]>>;
+
+const makeClient = RpcClient.make(CliWsRpcGroup);
+
+const makeT3RpcSessionFactory = Effect.fn("makeT3RpcSessionFactory")(function* () {
+  const webSocketConstructor = yield* Socket.WebSocketConstructor;
+
+  const connect: T3RpcSessionFactory["Service"]["connect"] = Effect.fnUntraced(function* (
+    connection: PreparedConnection,
+  ) {
+    yield* Effect.annotateCurrentSpan({
+      "connection.environment.id": connection.environmentId,
+    });
+
+    const connected = yield* Deferred.make<void>();
+    const disconnected = yield* Deferred.make<never, ConnectionTransientError>();
+    const hooks = RpcClient.ConnectionHooks.of({
+      onConnect: Deferred.succeed(connected, undefined).pipe(Effect.asVoid),
+      onDisconnect: Deferred.isDone(connected).pipe(
+        Effect.flatMap((wasConnected) =>
+          Deferred.fail(
+            disconnected,
+            new ConnectionTransientError({
+              reason: "transport",
+              detail: wasConnected
+                ? `${connection.label} disconnected.`
+                : `${connection.label} could not establish a WebSocket connection.`,
+            }),
+          ),
+        ),
+        Effect.asVoid,
+      ),
+    });
+    const socketLayer = Socket.layerWebSocket(connection.socketUrl, {
+      openTimeout: "15 seconds",
+    }).pipe(Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor)));
+    const protocolLayer = Layer.effect(
+      RpcClient.Protocol,
+      RpcClient.makeProtocolSocket({
+        retryTransientErrors: false,
+        retryPolicy: Schedule.recurs(0),
+      }),
+    ).pipe(
+      Layer.provide(
+        Layer.mergeAll(
+          socketLayer,
+          RpcSerialization.layerJson,
+          Layer.succeed(RpcClient.ConnectionHooks, hooks),
+        ),
+      ),
+    );
+    const protocolContext = yield* Layer.build(protocolLayer).pipe(
+      Effect.withSpan("environment.websocket.connect"),
+    );
+    const client = yield* makeClient.pipe(Effect.provide(protocolContext));
+    const initialConfig = yield* Effect.cached(
+      client[WS_METHODS.serverGetConfig]({}).pipe(
+        catchSessionRpcErrors,
+        Effect.withSpan("environment.initialSync"),
+      ),
+    );
+    const probe = initialConfig.pipe(
+      Effect.flatMap((config) =>
+        Effect.gen(function* () {
+          if (config.environment.capabilities.connectionProbe) {
+            return yield* client[WS_METHODS.serverProbe]({});
+          }
+          return yield* client[WS_METHODS.serverGetConfig]({});
+        }).pipe(catchSessionRpcErrors),
+      ),
+      Effect.asVoid,
+      Effect.withSpan("clientRuntime.connection.rpcSession.probe"),
+    );
+
+    return {
+      client,
+      initialConfig,
+      ready: Deferred.await(connected).pipe(
+        Effect.andThen(initialConfig),
+        Effect.asVoid,
+        Effect.raceFirst(Deferred.await(disconnected)),
+      ),
+      probe,
+      closed: Deferred.await(disconnected),
+    } satisfies T3RpcSession;
+  });
+
+  return T3RpcSessionFactory.of({ connect });
+});
+
+export const T3RpcSessionFactoryLive = Layer.effect(T3RpcSessionFactory, makeT3RpcSessionFactory());
+
+function catchSessionRpcErrors<A, R>(
+  effect: Effect.Effect<A, SessionRpcError, R>,
+): Effect.Effect<A, ConnectionAttemptError, R> {
+  return effect.pipe(
+    Effect.catchTags({
+      EnvironmentAuthorizationError: (error) =>
+        Effect.fail(
+          new ConnectionBlockedError({
+            reason: "permission",
+            detail: error.message,
+          }),
+        ),
+      KeybindingsConfigParseError: (error) =>
+        Effect.fail(
+          new ConnectionTransientError({
+            reason: "remote-unavailable",
+            detail: error.message,
+          }),
+        ),
+      ServerSettingsError: (error) =>
+        Effect.fail(
+          new ConnectionTransientError({
+            reason: "remote-unavailable",
+            detail: error.message,
+          }),
+        ),
+      RpcClientError: (error) =>
+        Effect.fail(
+          new ConnectionTransientError({
+            reason: "transport",
+            detail: error.message,
+          }),
+        ),
+    }),
+  );
+}

package/src/rpc/ws-group.ts

@@ -1,16 +1,14 @@
 import {
   EnvironmentAuthorizationError,
   KeybindingsConfigError,
-  OrchestrationDispatchCommandError,
-  OrchestrationGetSnapshotError,
-  ServerConfig,
   ServerProviders,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
   WS_METHODS,
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+  WsServerProbeRpc,
   WsSubscribeTerminalEventsRpc,
   WsSubscribeTerminalMetadataRpc,
   WsTerminalAttachRpc,
@@ -18,20 +16,18 @@ import {
   WsTerminalOpenRpc,
   WsTerminalResizeRpc,
   WsTerminalWriteRpc,
-  WsOrchestrationDispatchCommandRpc,
-  WsOrchestrationGetArchivedShellSnapshotRpc,
-  WsOrchestrationSubscribeShellRpc,
-  WsOrchestrationSubscribeThreadRpc,
 } from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 
-export const FallbackServerConfig = Schema.Struct({
+export const CliServerConfig = Schema.Struct({
+  environment: Schema.Struct({
+    capabilities: Schema.Struct({
+      connectionProbe: Schema.Boolean,
+    }),
+  }),
   providers: ServerProviders,
 });
-export type FallbackServerConfig = typeof FallbackServerConfig.Type;
-
-export const CliServerConfig = Schema.Union([ServerConfig, FallbackServerConfig]);
 export type CliServerConfig = typeof CliServerConfig.Type;
 
 export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
@@ -52,16 +48,6 @@ export const CliWsRpcGroup = RpcGroup.make(
   WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
+  WsServerProbeRpc,
   WsServerGetConfigRpc,
 );
-
-export type CliRpcRequestError =
-  | EnvironmentAuthorizationError
-  | KeybindingsConfigError
-  | OrchestrationDispatchCommandError
-  | OrchestrationGetSnapshotError
-  | TerminalCwdError
-  | TerminalHistoryError
-  | TerminalNotRunningError
-  | TerminalSessionLookupError
-  | ServerSettingsError;

package/src/runtime/layer.ts

@@ -14,10 +14,12 @@ import * as Config from "../config/config.ts";
 import * as Credential from "../config/credential/service.ts";
 import * as Selection from "../config/selection/service.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
+import { T3PreparedConnectionProviderLive } from "../connection/prepared.ts";
 import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../connection/service.ts";
 import { T3OrchestrationLive } from "../orchestration/layer.ts";
 import { T3RpcLive } from "../rpc/layer.ts";
 import { T3RpcOperationsLive } from "../rpc/operation.ts";
+import { T3RpcSessionFactoryLive } from "../rpc/session.ts";
 import { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
 import { NodeCliPathLayer } from "../cli-path/layer.ts";
 
@@ -63,9 +65,10 @@ const T3ConfigConnectionProviderLayer = Layer.effect(
 const T3RpcLayer = T3RpcLive.pipe(
   Layer.provide(
     Layer.mergeAll(
-      T3ConfigConnectionProviderLayer,
-      T3AuthTransportLayer,
-      NodeSocket.layerWebSocketConstructor,
+      T3PreparedConnectionProviderLive.pipe(
+        Layer.provide(Layer.mergeAll(T3ConfigConnectionProviderLayer, NodeHttpClient.layerUndici)),
+      ),
+      T3RpcSessionFactoryLive.pipe(Layer.provide(NodeSocket.layerWebSocketConstructor)),
     ),
   ),
 );