t3code-cli 0.9.1 → 0.11.0

package/src/domain/model-config.ts

@@ -12,6 +12,10 @@ export function firstSelectableModel(provider: ServerProvider) {
   return provider.models[0];
 }
 
+export function findSelectableModel(provider: ServerProvider, slug: string) {
+  return provider.models.find((model) => model.slug === slug);
+}
+
 export function findSelectableProvider(
   providers: ReadonlyArray<ServerProvider>,
   instanceId: string,

package/src/domain/thread-lifecycle.test.ts

@@ -0,0 +1,35 @@
+import "vite-plus/test/config";
+
+import { describe, expect, it } from "vite-plus/test";
+import { fromPartial } from "@total-typescript/shoehorn";
+
+import type { OrchestrationThread } from "#t3tools/contracts";
+
+import { isThreadActive, isThreadCompleteEnough } from "./thread-lifecycle.ts";
+
+describe("thread lifecycle", () => {
+  it("treats a ready session with a stale running latestTurn as complete", () => {
+    const thread = fromPartial<OrchestrationThread>({
+      session: {
+        status: "ready",
+      },
+      latestTurn: {
+        state: "running",
+      },
+      messages: [
+        {
+          role: "user",
+          text: "run review",
+        },
+        {
+          role: "assistant",
+          text: "verdict: requested changes",
+          streaming: false,
+        },
+      ],
+    });
+
+    expect(isThreadCompleteEnough(thread)).toBe(true);
+    expect(isThreadActive(thread)).toBe(false);
+  });
+});

package/src/domain/thread-lifecycle.ts

@@ -2,18 +2,33 @@ import {
   OrchestrationMessage,
   type OrchestrationEvent,
   type OrchestrationMessage as OrchestrationMessageType,
+  type OrchestrationSession,
   type OrchestrationThread,
   type OrchestrationThreadShell,
 } from "#t3tools/contracts";
 import * as Schema from "effect/Schema";
 
+type SessionStatusForDelete = OrchestrationSession["status"] | "closed";
+
+function isClosedSessionStatus(status: SessionStatusForDelete): status is "closed" {
+  return status === "closed";
+}
+
+export function sessionNeedsStopBeforeDelete(session: OrchestrationSession | null) {
+  if (session === null) {
+    return false;
+  }
+  return !isClosedSessionStatus(session.status);
+}
+
 export function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread) {
-  return (
-    thread.session?.status === "starting" ||
-    thread.session?.status === "running" ||
-    thread.latestTurn?.state === "running" ||
-    isPendingStart(thread)
-  );
+  if (thread.session?.status === "starting" || thread.session?.status === "running") {
+    return true;
+  }
+  if (thread.latestTurn?.state === "running") {
+    return !("messages" in thread && hasTerminalSession(thread) && isThreadCompleteEnough(thread));
+  }
+  return isPendingStart(thread);
 }
 
 export type ThreadLifecycleStatus = ReturnType<typeof threadStatus>;
@@ -91,3 +106,11 @@ function isPendingStart(thread: OrchestrationThreadShell | OrchestrationThread)
   }
   return thread.messages.at(-1)?.role === "user";
 }
+
+function hasTerminalSession(thread: OrchestrationThreadShell | OrchestrationThread) {
+  return (
+    thread.session !== null &&
+    thread.session?.status !== "starting" &&
+    thread.session?.status !== "running"
+  );
+}

package/src/node/index.ts

@@ -0,0 +1,2 @@
+export { T3CodeNodeRpcLayer } from "../connection/node.ts";
+export { NodeEnvironmentLive } from "../environment/layer.ts";

package/src/orchestration/index.ts

@@ -4,4 +4,5 @@ export {
   type Orchestration,
   type OrchestrationError,
 } from "./service.ts";
+export { makeT3Orchestration, T3OrchestrationLive } from "./layer.ts";
 export { T3OrchestrationLayer } from "../runtime/layer.ts";

package/src/orchestration/layer.ts

@@ -1,7 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Schedule from "effect/Schedule";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import {
@@ -12,86 +11,45 @@ import {
   type OrchestrationShellStreamItem,
   type OrchestrationThreadStreamItem,
 } from "#t3tools/contracts";
-import { RpcClientError } from "effect/unstable/rpc";
 
 import { RpcError } from "../rpc/error.ts";
-import { T3Rpc, type WsClient } from "../rpc/service.ts";
-import type { CliRpcRequestError } from "../rpc/ws-group.ts";
-import { T3Orchestration, type OpenThread } from "./service.ts";
+import { T3RpcOperations } from "../rpc/operation.ts";
+import { T3Orchestration, type OpenThread, type Orchestration } from "./service.ts";
 
-type RpcRequestError = RpcClientError.RpcClientError | CliRpcRequestError;
-
-const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
-  Schedule.take(4),
-  Schedule.collectWhile(
-    (metadata: Schedule.Metadata) => metadata.input instanceof RpcClientError.RpcClientError,
-  ),
-);
+export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* () {
+  const rpc = yield* T3RpcOperations;
 
-function runRpc<A>(
-  rpc: T3Rpc["Service"],
-  method: string,
-  f: (client: WsClient) => Effect.Effect<A, RpcRequestError>,
-): Effect.Effect<A, RpcError> {
-  return Effect.gen(function* () {
-    const client = yield* rpc.getClient;
-    return yield* f(client);
-  }).pipe(
-    Effect.tapError((error) =>
-      error instanceof RpcClientError.RpcClientError ? rpc.disconnect : Effect.void,
-    ),
-    Effect.retry(rpcRetrySchedule),
-    Effect.catchTags({
-      RpcError: (error) => Effect.fail(error),
-      EnvironmentAuthorizationError: (error) => Effect.fail(toRpcRequestError(error, method)),
-      RpcClientError: (error) => Effect.fail(toRpcRequestError(error, method)),
-      KeybindingsConfigParseError: (error) => Effect.fail(toRpcRequestError(error, method)),
-      OrchestrationDispatchCommandError: (error) => Effect.fail(toRpcRequestError(error, method)),
-      OrchestrationGetSnapshotError: (error) => Effect.fail(toRpcRequestError(error, method)),
-      ServerSettingsError: (error) => Effect.fail(toRpcRequestError(error, method)),
-    }),
-  );
-}
+  const watchShellSequence: Orchestration["watchShellSequence"] = () =>
+    rpc
+      .subscribe(ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
+        client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
+      )
+      .pipe(
+        Stream.map((item: OrchestrationShellStreamItem) =>
+          item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
+        ),
+      );
 
-function subscribeRpc<A>(
-  rpc: T3Rpc["Service"],
-  method: string,
-  f: (client: WsClient) => Stream.Stream<A, RpcRequestError>,
-): Stream.Stream<A, RpcError> {
-  return Stream.unwrap(Effect.map(rpc.getClient, f)).pipe(
-    Stream.tapError((error) =>
-      error instanceof RpcClientError.RpcClientError ? rpc.disconnect : Effect.void,
-    ),
-    Stream.retry(rpcRetrySchedule),
-    Stream.catchTags({
-      RpcError: (error) => Stream.fail(error),
-      EnvironmentAuthorizationError: (error) => Stream.fail(toRpcRequestError(error, method)),
-      RpcClientError: (error) => Stream.fail(toRpcRequestError(error, method)),
-      KeybindingsConfigParseError: (error) => Stream.fail(toRpcRequestError(error, method)),
-      OrchestrationDispatchCommandError: (error) => Stream.fail(toRpcRequestError(error, method)),
-      OrchestrationGetSnapshotError: (error) => Stream.fail(toRpcRequestError(error, method)),
-      ServerSettingsError: (error) => Stream.fail(toRpcRequestError(error, method)),
-    }),
-  );
-}
+  const watchThreadItems: Orchestration["watchThreadItems"] = (threadId: string) =>
+    rpc.subscribe(ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
+      client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
+    );
 
-export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* () {
-  const rpc = yield* T3Rpc;
   const dispatch = Effect.fn("T3OrchestrationLive.dispatch")(function* (
     command: ClientOrchestrationCommand,
   ) {
-    return yield* runRpc(rpc, ORCHESTRATION_WS_METHODS.dispatchCommand, (client) =>
+    return yield* rpc.run(ORCHESTRATION_WS_METHODS.dispatchCommand, (client) =>
       client[ORCHESTRATION_WS_METHODS.dispatchCommand](command),
     );
   });
   const getServerConfig = Effect.fn("T3OrchestrationLive.getServerConfig")(function* () {
-    return yield* runRpc(rpc, WS_METHODS.serverGetConfig, (client) =>
+    return yield* rpc.run(WS_METHODS.serverGetConfig, (client) =>
       client[WS_METHODS.serverGetConfig]({}),
     );
   });
   const getShellSnapshot = Effect.fn("T3OrchestrationLive.getShellSnapshot")(function* () {
     const item = yield* Stream.runHead(
-      subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
+      rpc.subscribe(ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
         client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
       ),
     );
@@ -106,12 +64,21 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     }
     return value.snapshot;
   });
+  const getArchivedShellSnapshot = Effect.fn("T3OrchestrationLive.getArchivedShellSnapshot")(
+    function* () {
+      return yield* rpc.run(ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot, (client) =>
+        client[ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot]({}),
+      );
+    },
+  );
   const getThreadSnapshot = Effect.fn("T3OrchestrationLive.getThreadSnapshot")(function* (
     threadId: string,
   ) {
     const item = yield* Stream.runHead(
-      subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
-        client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
+      rpc.subscribe(ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
+        client[ORCHESTRATION_WS_METHODS.subscribeThread]({
+          threadId: ThreadId.make(threadId),
+        }),
       ),
     );
     const value = Option.getOrUndefined(item);
@@ -125,18 +92,6 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     }
     return value.snapshot.thread;
   });
-  const watchShellSequence = () =>
-    subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
-      client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
-    ).pipe(
-      Stream.map((item: OrchestrationShellStreamItem) =>
-        item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
-      ),
-    );
-  const watchThreadItems = (threadId: string) =>
-    subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
-      client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
-    );
   const openThread = Effect.fn("T3OrchestrationLive.openThread")(function* (threadId: string) {
     return yield* watchThreadItems(threadId).pipe(
       Stream.peel(Sink.head<OrchestrationThreadStreamItem>()),
@@ -168,6 +123,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     dispatch,
     getServerConfig,
     getShellSnapshot,
+    getArchivedShellSnapshot,
     getThreadSnapshot,
     watchShellSequence,
     watchThreadItems,
@@ -176,11 +132,3 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
 });
 
 export const T3OrchestrationLive = Layer.effect(T3Orchestration, makeT3Orchestration());
-
-function toRpcRequestError(error: RpcRequestError, method: string) {
-  return new RpcError({
-    message: error.message,
-    method,
-    cause: error,
-  });
-}

package/src/orchestration/service.ts

@@ -31,6 +31,10 @@ export type Orchestration = {
   ) => Effect.Effect<DispatchResult, OrchestrationError>;
   readonly getServerConfig: () => Effect.Effect<ServerConfigForCli, OrchestrationError>;
   readonly getShellSnapshot: () => Effect.Effect<OrchestrationShellSnapshot, OrchestrationError>;
+  readonly getArchivedShellSnapshot: () => Effect.Effect<
+    OrchestrationShellSnapshot,
+    OrchestrationError
+  >;
   readonly getThreadSnapshot: (
     threadId: string,
   ) => Effect.Effect<OrchestrationThread, OrchestrationError>;

package/src/rpc/error.ts

@@ -5,6 +5,10 @@ import {
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
+  TerminalCwdError,
+  TerminalHistoryError,
+  TerminalNotRunningError,
+  TerminalSessionLookupError,
 } from "#t3tools/contracts";
 import { HttpClientError } from "effect/unstable/http";
 import { RpcClientError } from "effect/unstable/rpc";
@@ -20,6 +24,10 @@ const RpcErrorCauseSchema = Schema.Union([
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
+  TerminalCwdError,
+  TerminalHistoryError,
+  TerminalNotRunningError,
+  TerminalSessionLookupError,
   AuthTransportError,
   T3CodeConnectionError,
   HttpClientError.HttpClientErrorSchema,
@@ -27,6 +35,8 @@ const RpcErrorCauseSchema = Schema.Union([
   Schema.instanceOf(Schema.SchemaError),
 ]);
 
+export type RpcKnownCause = Schema.Schema.Type<typeof RpcErrorCauseSchema>;
+
 export class RpcError extends Schema.TaggedErrorClass<RpcError>()("RpcError", {
   message: Schema.String,
   method: Schema.optionalKey(Schema.String),

package/src/rpc/index.ts

@@ -1 +1,6 @@
 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 { T3RpcService, WsClient } from "./service.ts";

package/src/rpc/operation.ts

@@ -0,0 +1,83 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+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 const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
+  Schedule.take(4),
+  Schedule.collectWhile((metadata: Schedule.Metadata) =>
+    Predicate.isTagged(metadata.input, "RpcClientError"),
+  ),
+);
+
+export type T3RpcOperationsService = {
+  readonly run: <A, R>(
+    method: string,
+    operation: (client: WsClient) => Effect.Effect<A, CliRpcOperationError, R>,
+  ) => Effect.Effect<A, RpcError, R>;
+  readonly subscribe: <A>(
+    method: string,
+    operation: (client: WsClient) => Stream.Stream<A, CliRpcOperationError>,
+  ) => Stream.Stream<A, RpcError>;
+};
+
+export class T3RpcOperations extends Context.Service<T3RpcOperations, T3RpcOperationsService>()(
+  "t3cli/T3RpcOperations",
+) {}
+
+export const makeT3RpcOperations = Effect.fn("makeT3RpcOperations")(function* () {
+  const rpc = yield* T3Rpc;
+
+  const run: T3RpcOperationsService["run"] = <A, R>(
+    method: string,
+    operation: (client: WsClient) => Effect.Effect<A, CliRpcOperationError, R>,
+  ): Effect.Effect<A, RpcError, R> =>
+    rpc.getClient.pipe(
+      Effect.flatMap((client) => operation(client)),
+      Effect.tapError((error) =>
+        Predicate.isTagged(error, "RpcClientError") ? rpc.disconnect : Effect.void,
+      ),
+      Effect.retry(rpcRetrySchedule),
+      Effect.mapError((error) =>
+        Predicate.isTagged(error, "RpcError") ? error : toRpcError(error, method),
+      ),
+    );
+
+  const subscribe: T3RpcOperationsService["subscribe"] = <A>(
+    method: string,
+    operation: (client: WsClient) => Stream.Stream<A, CliRpcOperationError>,
+  ): Stream.Stream<A, RpcError> =>
+    Stream.unwrap(rpc.getClient.pipe(Effect.map((client) => operation(client)))).pipe(
+      Stream.tapError((error) =>
+        Predicate.isTagged(error, "RpcClientError") ? rpc.disconnect : Effect.void,
+      ),
+      Stream.retry(rpcRetrySchedule),
+      Stream.mapError((error) =>
+        Predicate.isTagged(error, "RpcError") ? error : toRpcError(error, method),
+      ),
+    );
+
+  return {
+    run,
+    subscribe,
+  } satisfies T3RpcOperationsService;
+});
+
+export const T3RpcOperationsLive = Layer.effect(T3RpcOperations, makeT3RpcOperations());
+
+function toRpcError(error: CliRpcOperationError, method: string): RpcError {
+  return new RpcError({
+    message: error.message,
+    method,
+    cause: error,
+  });
+}

package/src/rpc/ws-group.ts

@@ -6,8 +6,20 @@ import {
   ServerConfig,
   ServerProviders,
   ServerSettingsError,
+  TerminalCwdError,
+  TerminalHistoryError,
+  TerminalNotRunningError,
+  TerminalSessionLookupError,
   WS_METHODS,
+  WsSubscribeTerminalEventsRpc,
+  WsSubscribeTerminalMetadataRpc,
+  WsTerminalAttachRpc,
+  WsTerminalCloseRpc,
+  WsTerminalOpenRpc,
+  WsTerminalResizeRpc,
+  WsTerminalWriteRpc,
   WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
 } from "#t3tools/contracts";
@@ -29,7 +41,15 @@ export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
 });
 
 export const CliWsRpcGroup = RpcGroup.make(
+  WsTerminalOpenRpc,
+  WsTerminalAttachRpc,
+  WsTerminalWriteRpc,
+  WsTerminalResizeRpc,
+  WsTerminalCloseRpc,
+  WsSubscribeTerminalEventsRpc,
+  WsSubscribeTerminalMetadataRpc,
   WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
   WsServerGetConfigRpc,
@@ -40,4 +60,8 @@ export type CliRpcRequestError =
   | KeybindingsConfigError
   | OrchestrationDispatchCommandError
   | OrchestrationGetSnapshotError
+  | TerminalCwdError
+  | TerminalHistoryError
+  | TerminalNotRunningError
+  | TerminalSessionLookupError
   | ServerSettingsError;

package/src/runtime/layer.ts

@@ -16,6 +16,7 @@ import { T3CodeConnectionError } from "../connection/error.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 { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
 import { NodeCliPathLayer } from "../cli-path/layer.ts";
 
@@ -66,8 +67,11 @@ const T3RpcLayer = T3RpcLive.pipe(
     ),
   ),
 );
-export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
-const T3ApplicationLayer = T3ApplicationLive.pipe(Layer.provide(T3OrchestrationLayer));
+const T3RpcOperationsLayer = T3RpcOperationsLive.pipe(Layer.provide(T3RpcLayer));
+export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcOperationsLayer));
+const T3ApplicationLayer = T3ApplicationLive.pipe(
+  Layer.provide(Layer.mergeAll(T3RpcOperationsLayer, T3OrchestrationLayer)),
+);
 
 export const AuthAppLayer = Layer.mergeAll(T3ConfigLive, T3AuthLayer);
 
@@ -75,6 +79,7 @@ export const AppLayer = Layer.mergeAll(
   T3ConfigLive,
   T3AuthLayer,
   T3RpcLayer,
+  T3RpcOperationsLayer,
   T3OrchestrationLayer,
   T3ApplicationLayer,
   NodeCliPathLayer,