t3code-cli 0.11.0 → 0.13.0

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";
+} 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/index.ts

@@ -1,6 +1,8 @@
 export {
   AppLayer,
   AuthAppLayer,
+  BaseAppLayer,
+  BaseAuthAppLayer,
   T3AuthLayer,
   T3AuthPairingLayer,
   T3AuthTransportLayer,
@@ -9,4 +11,3 @@ export {
   T3LocalAuthTokenLayer,
   T3OrchestrationLayer,
 } from "./layer.ts";
-export { NodeEnvironmentLive } from "../environment/layer.ts";

package/src/runtime/layer.test-utils.ts

@@ -0,0 +1,32 @@
+import * as Layer from "effect/Layer";
+
+import * as CliSelection from "../cli/env/selection-layer.ts";
+import * as CliRuntime from "../cli/runtime/service.ts";
+import * as Config from "../config/config.ts";
+import * as Credential from "../config/credential/service.ts";
+import * as CredentialCipherNode from "../config/credential/cipher-node.ts";
+import { ConfigPlatformLayer } from "../config/platform.test-utils.ts";
+import { t3CliEnvConfigLayer } from "../config/env/env.test-utils.ts";
+import * as Keystore from "../config/keystore/service.test-utils.ts";
+
+export function cliConfigRoutingLayerTest(homeDir: string) {
+  const cliRuntimeLayer = CliRuntime.CliRuntime.layerTest({ cwd: homeDir });
+  const configLayer = t3CliEnvConfigLayer(homeDir, { T3CLI_ENV: "home" });
+  const platformEnvLayer = Layer.mergeAll(cliRuntimeLayer, configLayer);
+
+  return Layer.mergeAll(
+    ConfigPlatformLayer,
+    platformEnvLayer,
+    Config.layer.pipe(
+      Layer.provide(Credential.layer),
+      Layer.provide(
+        Layer.mergeAll(
+          platformEnvLayer,
+          CliSelection.layer.pipe(Layer.provide(platformEnvLayer)),
+          CredentialCipherNode.layerNode,
+          Keystore.unavailableKeystoreFactoryLayer,
+        ),
+      ),
+    ),
+  );
+}

package/src/runtime/layer.test.ts

@@ -0,0 +1,66 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import { Command } from "effect/unstable/cli";
+
+import { cliEnvironmentSetting } from "../cli/env/flag.ts";
+import type { ResolvedConfig } from "../config/types.ts";
+import { T3Config } from "../config/config.ts";
+import { makeTempHomeScoped } from "../config/temp-home.test-utils.ts";
+import { cliConfigRoutingLayerTest } from "./layer.test-utils.ts";
+
+describe("CLI config routing", () => {
+  it.effect(
+    "routes --environment through Command.run to T3Config.resolve ahead of default and T3CLI_ENV",
+    () =>
+      Effect.gen(function* () {
+        return yield* makeTempHomeScoped("t3cli-runtime-");
+      }).pipe(
+        Effect.flatMap((homeDir) => {
+          const testLayer = cliConfigRoutingLayerTest(homeDir);
+          return Effect.gen(function* () {
+            const resolvedRef = yield* Ref.make<ResolvedConfig | undefined>(undefined);
+            const resolveProbeCommand = Command.make("resolve-probe", {}, () =>
+              Effect.gen(function* () {
+                const config = yield* T3Config;
+                const resolved = yield* config.resolve();
+                yield* Ref.set(resolvedRef, resolved);
+              }),
+            ).pipe(Command.withGlobalFlags([cliEnvironmentSetting]));
+            const runResolveProbe = Command.runWith(resolveProbeCommand, { version: "0.0.0-test" });
+
+            yield* Effect.gen(function* () {
+              const config = yield* T3Config;
+              yield* config.upsertEnvironment({
+                name: "home",
+                url: "https://home.example",
+                token: "home-token",
+                local: false,
+              });
+              yield* config.upsertEnvironment({
+                name: "work",
+                url: "https://work.example",
+                token: "work-token",
+                local: false,
+              });
+            }).pipe(Effect.provide(testLayer));
+
+            yield* runResolveProbe(["--environment", "work"]).pipe(Effect.provide(testLayer));
+
+            const resolved = yield* Ref.get(resolvedRef);
+            assert.isDefined(resolved);
+            assert.equal(resolved.source, "config");
+            if (resolved.source === "config") {
+              assert.equal(resolved.environment, "work");
+              assert.equal(resolved.token, "work-token");
+            }
+          });
+        }),
+        Effect.provide(NodeServices.layer),
+        Effect.scoped,
+      ),
+  );
+});

package/src/runtime/layer.ts

@@ -10,16 +10,20 @@ import { T3LocalAuthOriginLive } from "../auth/local-origin.ts";
 import { T3LocalAuthTokenLive } from "../auth/local-token.ts";
 import { T3AuthPairingLive } from "../auth/pairing.ts";
 import { T3AuthTransportLive } from "../auth/transport.ts";
-import { T3ConfigLive } from "../config/layer.ts";
-import { T3Config } from "../config/service.ts";
+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";
 
+export const T3ConfigLayer = Config.layer.pipe(Layer.provide(Credential.layer));
 export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
   Layer.provide(NodeHttpClient.layerUndici),
 );
@@ -33,13 +37,13 @@ export const T3LocalAuthLayer = T3LocalAuthLive.pipe(
 export const T3AuthPairingLayer = T3AuthPairingLive.pipe(Layer.provide(T3AuthTransportLayer));
 export const T3AuthLayer = T3AuthLive.pipe(
   Layer.provide(
-    Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
+    Layer.mergeAll(T3ConfigLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
   ),
 );
 const T3ConfigConnectionProviderLayer = Layer.effect(
   T3CodeConnectionProvider,
   Effect.gen(function* () {
-    const config = yield* T3Config;
+    const config = yield* Config.T3Config;
     return makeT3CodeConnectionProvider(
       config.resolve().pipe(
         Effect.map((resolved) => ({
@@ -56,14 +60,15 @@ const T3ConfigConnectionProviderLayer = Layer.effect(
       ),
     );
   }),
-).pipe(Layer.provide(T3ConfigLive));
+).pipe(Layer.provide(T3ConfigLayer));
 
 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)),
     ),
   ),
 );
@@ -73,10 +78,8 @@ const T3ApplicationLayer = T3ApplicationLive.pipe(
   Layer.provide(Layer.mergeAll(T3RpcOperationsLayer, T3OrchestrationLayer)),
 );
 
-export const AuthAppLayer = Layer.mergeAll(T3ConfigLive, T3AuthLayer);
-
-export const AppLayer = Layer.mergeAll(
-  T3ConfigLive,
+export const BaseAppLayer = Layer.mergeAll(
+  T3ConfigLayer,
   T3AuthLayer,
   T3RpcLayer,
   T3RpcOperationsLayer,
@@ -84,3 +87,9 @@ export const AppLayer = Layer.mergeAll(
   T3ApplicationLayer,
   NodeCliPathLayer,
 );
+
+export const BaseAuthAppLayer = Layer.mergeAll(T3ConfigLayer, T3AuthLayer);
+
+export const AuthAppLayer = BaseAuthAppLayer.pipe(Layer.provideMerge(Selection.layer));
+
+export const AppLayer = BaseAppLayer.pipe(Layer.provideMerge(Selection.layer));

package/src/t3tools/index.ts

@@ -1 +1 @@
-export * from "#t3tools/contracts";
+export * from "@t3tools/contracts";

package/src/types/marked-terminal.d.ts

@@ -0,0 +1,11 @@
+declare module "marked-terminal" {
+  import type { MarkedExtension } from "marked";
+
+  export type TerminalRendererOptions = {
+    readonly reflowText?: boolean;
+    readonly showSectionPrefix?: boolean;
+    readonly width?: number;
+  };
+
+  export function markedTerminal(options?: TerminalRendererOptions): MarkedExtension;
+}

package/dist/layout.js

@@ -1,2 +0,0 @@
-import { L as readT3LayoutFromNodeProcess, R as resolveT3BaseDir } from "./shared.js";
-export { readT3LayoutFromNodeProcess, resolveT3BaseDir };

package/dist/scope.js

@@ -1,2 +0,0 @@
-import { Fd as resolveWorktreePath, Md as resolveCommandProjectRef, Nd as resolveProjectRef, Pd as resolveThreadId } from "./shared.js";
-export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath };

package/dist/src/cli/output-format.d.ts

@@ -1,11 +0,0 @@
-import type { EnvironmentShape } from "../environment/service.ts";
-export declare const humanJsonFormatChoices: readonly ["auto", "human", "json"];
-export declare const humanNdjsonFormatChoices: readonly ["auto", "human", "ndjson"];
-export declare const humanJsonNdjsonFormatChoices: readonly ["auto", "human", "json", "ndjson"];
-export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
-export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
-export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
-export declare function resolveOutputFormat<T extends "json" | "ndjson">(format: "auto" | "human" | T, environment: EnvironmentShape, nonHumanFormat: T): "human" | T;
-export declare function canRenderLiveTerminal(environment: EnvironmentShape): boolean;
-export declare function isInteractiveHumanTerminal(environment: EnvironmentShape): boolean;
-export declare function isAgentEnvironment(environment: EnvironmentShape): boolean;

package/dist/src/config/layer.d.ts

@@ -1,22 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { Environment } from "../environment/service.ts";
-import { ConfigError } from "./error.ts";
-import { T3Config, type StoredConfig } from "./service.ts";
-export declare const makeT3Config: () => Effect.Effect<{
-    readStored: () => Effect.Effect<{
-        readonly url?: string;
-        readonly token?: string;
-        readonly local?: boolean;
-    }, ConfigError, never>;
-    writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError, never>;
-    resolve: () => Effect.Effect<{
-        url: string;
-        token: string;
-        source: "config" | "env";
-        local: boolean;
-    }, import("./error.ts").UrlError | ConfigError, never>;
-}, never, Environment | Path.Path | FileSystem.FileSystem>;
-export declare const T3ConfigLive: Layer.Layer<T3Config, never, Environment | Path.Path | FileSystem.FileSystem>;

package/dist/src/config/service.d.ts

@@ -1,22 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { ConfigError, ConfigServiceError } from "./error.ts";
-export type StoredConfig = {
-    readonly url?: string;
-    readonly token?: string;
-    readonly local?: boolean;
-};
-export type ResolvedConfig = {
-    readonly url: string;
-    readonly token: string;
-    readonly source: "env" | "config";
-    readonly local: boolean;
-};
-declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
-    readonly readStored: () => Effect.Effect<StoredConfig, ConfigError>;
-    readonly writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError>;
-    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigServiceError>;
-}>;
-export declare class T3Config extends T3Config_base {
-}
-export {};

package/dist/src/environment/layer.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import { Environment } from "./service.ts";
-export declare const NodeEnvironmentLive: Layer.Layer<Environment, never, never>;

package/dist/src/environment/service.d.ts

@@ -1,12 +0,0 @@
-import * as Context from "effect/Context";
-export type EnvironmentShape = {
-    readonly cwd: string;
-    readonly homeDir: string;
-    readonly env: Readonly<Record<string, string | undefined>>;
-    readonly stdoutIsTTY: boolean;
-    readonly stderrIsTTY: boolean;
-};
-declare const Environment_base: Context.ServiceClass<Environment, "t3cli/Environment", EnvironmentShape>;
-export declare class Environment extends Environment_base {
-}
-export {};

package/dist/src/layout/index.d.ts

@@ -1 +0,0 @@
-export { readT3LayoutFromNodeProcess, resolveT3BaseDir, type T3Layout } from "./base-dir.ts";