t3code-cli 0.10.0 → 0.12.0

package/src/application/terminals.ts

@@ -0,0 +1,208 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { WS_METHODS, type TerminalSummary } from "@t3tools/contracts";
+
+import { ProjectLookupError, TerminalLookupError, ThreadLookupError } from "../domain/error.ts";
+import { findProjectById } from "../domain/helpers.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { RpcError } from "../rpc/error.ts";
+import { T3RpcOperations } from "../rpc/operation.ts";
+import type { T3TerminalApplicationService, CreateTerminalInput, TerminalRef } from "./service.ts";
+
+export const makeTerminalApplication = Effect.fn("makeTerminalApplication")(function* () {
+  const crypto = yield* Crypto.Crypto;
+  const orchestration = yield* T3Orchestration;
+  const rpc = yield* T3RpcOperations;
+
+  const attachTerminal: T3TerminalApplicationService["attachTerminal"] = (input) =>
+    rpc.subscribe(WS_METHODS.terminalAttach, (client) =>
+      client[WS_METHODS.terminalAttach]({
+        threadId: input.terminal.threadId,
+        terminalId: input.terminal.terminalId,
+        cwd: input.terminal.cwd,
+        worktreePath: input.terminal.worktreePath,
+        ...(input.cols !== undefined ? { cols: input.cols } : {}),
+        ...(input.rows !== undefined ? { rows: input.rows } : {}),
+      }),
+    );
+
+  const watchTerminalMetadata: T3TerminalApplicationService["watchTerminalMetadata"] = () =>
+    rpc.subscribe(WS_METHODS.subscribeTerminalMetadata, (client) =>
+      client[WS_METHODS.subscribeTerminalMetadata]({}),
+    );
+
+  const getTerminalMetadataSnapshot = (): Effect.Effect<ReadonlyArray<TerminalSummary>, RpcError> =>
+    Effect.gen(function* () {
+      const item = yield* Stream.runHead(
+        rpc.subscribe(WS_METHODS.subscribeTerminalMetadata, (client) =>
+          client[WS_METHODS.subscribeTerminalMetadata]({}),
+        ),
+      );
+      const value = Option.getOrUndefined(item);
+      if (value === undefined || value.type !== "snapshot") {
+        return yield* Effect.fail(
+          new RpcError({
+            message: "server did not return terminal metadata snapshot",
+            method: WS_METHODS.subscribeTerminalMetadata,
+          }),
+        );
+      }
+      return value.terminals;
+    });
+
+  const listTerminals = Effect.fn("T3ApplicationLive.listTerminals")(function* (threadId: string) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    if (snapshot.threads.find((candidate) => candidate.id === threadId) === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${threadId}`,
+          threadId,
+        }),
+      );
+    }
+    const terminals = yield* getTerminalMetadataSnapshot();
+    return terminals.filter((terminal) => terminal.threadId === threadId);
+  });
+
+  const getTerminal = Effect.fn("T3ApplicationLive.getTerminal")(function* (terminal: TerminalRef) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    if (snapshot.threads.find((candidate) => candidate.id === terminal.threadId) === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${terminal.threadId}`,
+          threadId: terminal.threadId,
+        }),
+      );
+    }
+    const terminals = yield* getTerminalMetadataSnapshot();
+    const match = terminals.find(
+      (candidate) =>
+        candidate.threadId === terminal.threadId && candidate.terminalId === terminal.terminalId,
+    );
+    if (match !== undefined) {
+      return match;
+    }
+    return yield* Effect.fail(
+      new TerminalLookupError({
+        message: `terminal not found: ${terminal.terminalId} in thread ${terminal.threadId}`,
+        threadId: terminal.threadId,
+        terminalId: terminal.terminalId,
+      }),
+    );
+  });
+
+  const createTerminal = Effect.fn("T3ApplicationLive.createTerminal")(function* (
+    input: CreateTerminalInput,
+  ) {
+    const snapshot = yield* orchestration.getShellSnapshot();
+    const thread = snapshot.threads.find((candidate) => candidate.id === input.threadId);
+    if (thread === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${input.threadId}`,
+          threadId: input.threadId,
+        }),
+      );
+    }
+    const project = findProjectById(snapshot, thread.projectId);
+    if (project === null) {
+      return yield* Effect.fail(
+        new ProjectLookupError({
+          message: `project not found for thread: ${input.threadId}`,
+          ref: thread.projectId,
+        }),
+      );
+    }
+
+    const terminalId = input.terminalId ?? `t3cli-${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`;
+    const cwd = thread.worktreePath ?? project.workspaceRoot;
+    const opened = yield* rpc.run(WS_METHODS.terminalOpen, (client) =>
+      client[WS_METHODS.terminalOpen]({
+        threadId: thread.id,
+        terminalId,
+        cwd,
+        worktreePath: thread.worktreePath ?? null,
+        ...(input.env !== undefined ? { env: input.env } : {}),
+      }),
+    );
+
+    if (input.command !== undefined) {
+      yield* rpc.run(WS_METHODS.terminalWrite, (client) =>
+        client[WS_METHODS.terminalWrite]({
+          threadId: thread.id,
+          terminalId,
+          data: `${input.command}\r`,
+        }),
+      );
+      const refreshed = yield* Stream.runHead(
+        attachTerminal({
+          terminal: {
+            threadId: opened.threadId,
+            terminalId: opened.terminalId,
+            cwd: opened.cwd,
+            worktreePath: opened.worktreePath,
+          },
+        }),
+      );
+      const event = Option.getOrUndefined(refreshed);
+      if (event !== undefined && (event.type === "snapshot" || event.type === "restarted")) {
+        return event.snapshot;
+      }
+    }
+
+    return opened;
+  });
+
+  const writeTerminal = Effect.fn("T3ApplicationLive.writeTerminal")(function* (input: {
+    readonly terminal: TerminalRef;
+    readonly data: string;
+  }) {
+    yield* rpc.run(WS_METHODS.terminalWrite, (client) =>
+      client[WS_METHODS.terminalWrite]({
+        threadId: input.terminal.threadId,
+        terminalId: input.terminal.terminalId,
+        data: input.data,
+      }),
+    );
+  });
+
+  const resizeTerminal = Effect.fn("T3ApplicationLive.resizeTerminal")(function* (input: {
+    readonly terminal: TerminalRef;
+    readonly cols: number;
+    readonly rows: number;
+  }) {
+    yield* rpc.run(WS_METHODS.terminalResize, (client) =>
+      client[WS_METHODS.terminalResize]({
+        threadId: input.terminal.threadId,
+        terminalId: input.terminal.terminalId,
+        cols: input.cols,
+        rows: input.rows,
+      }),
+    );
+  });
+
+  const destroyTerminal = Effect.fn("T3ApplicationLive.destroyTerminal")(function* (
+    terminal: TerminalRef,
+  ) {
+    yield* rpc.run(WS_METHODS.terminalClose, (client) =>
+      client[WS_METHODS.terminalClose]({
+        threadId: terminal.threadId,
+        terminalId: terminal.terminalId,
+        deleteHistory: true,
+      }),
+    );
+  });
+
+  return {
+    attachTerminal,
+    createTerminal,
+    destroyTerminal,
+    getTerminal,
+    listTerminals,
+    resizeTerminal,
+    watchTerminalMetadata,
+    writeTerminal,
+  } satisfies T3TerminalApplicationService;
+});

package/src/application/thread-commands.test.ts

@@ -0,0 +1,43 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+
+import { makeThreadInterruptCommand, makeThreadUnarchiveCommand } from "./thread-commands.ts";
+
+describe("thread command builders", () => {
+  it.layer(NodeServices.layer)("thread command builders", (t) => {
+    t.effect("makeThreadInterruptCommand includes turnId when provided", () =>
+      Effect.gen(function* () {
+        const command = yield* makeThreadInterruptCommand({
+          threadId: "thread-1",
+          turnId: "turn-1",
+        });
+        assert.equal(command.type, "thread.turn.interrupt");
+        assert.equal(command.threadId, "thread-1");
+        assert.equal(command.turnId, "turn-1");
+        assert.equal(typeof command.createdAt, "string");
+      }),
+    );
+
+    t.effect("makeThreadInterruptCommand omits turnId when not provided", () =>
+      Effect.gen(function* () {
+        const command = yield* makeThreadInterruptCommand({
+          threadId: "thread-1",
+        });
+        assert.equal(command.type, "thread.turn.interrupt");
+        assert.equal(command.threadId, "thread-1");
+        assert.equal("turnId" in command, false);
+      }),
+    );
+
+    t.effect("makeThreadUnarchiveCommand builds thread.unarchive command", () =>
+      Effect.gen(function* () {
+        const command = yield* makeThreadUnarchiveCommand("thread-1");
+        assert.equal(command.type, "thread.unarchive");
+        assert.equal(command.threadId, "thread-1");
+      }),
+    );
+  });
+});

package/src/application/thread-commands.ts

@@ -6,12 +6,13 @@ import {
   CommandId,
   MessageId,
   ThreadId,
+  TurnId,
   type ClientOrchestrationCommand,
   type ModelSelection,
   type OrchestrationProjectShell,
   type ProviderApprovalDecision,
   type ProviderUserInputAnswers,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import { resolveModelSelection } from "./model-selection.ts";
 import type { SendThreadInput, StartThreadInput } from "./service.ts";
@@ -101,6 +102,63 @@ export const makeThreadArchiveCommand = Effect.fn("makeThreadArchiveCommand")(fu
   } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.archive" }>;
 });
 
+export const makeThreadUnarchiveCommand = Effect.fn("makeThreadUnarchiveCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.unarchive",
+    commandId: CommandId.make(
+      `t3cli:thread-unarchive:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.unarchive" }>;
+});
+
+export const makeThreadSessionStopCommand = Effect.fn("makeThreadSessionStopCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  const createdAt = DateTime.formatIso(yield* DateTime.now);
+  return {
+    type: "thread.session.stop",
+    commandId: CommandId.make(
+      `t3cli:thread-session-stop:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+    createdAt,
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.session.stop" }>;
+});
+
+export const makeThreadDeleteCommand = Effect.fn("makeThreadDeleteCommand")(function* (
+  threadId: string,
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.delete",
+    commandId: CommandId.make(
+      `t3cli:thread-delete:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.delete" }>;
+});
+
+export const makeThreadInterruptCommand = Effect.fn("makeThreadInterruptCommand")(
+  function* (input: { readonly threadId: string; readonly turnId?: string }) {
+    const crypto = yield* Crypto.Crypto;
+    const createdAt = DateTime.formatIso(yield* DateTime.now);
+    return {
+      type: "thread.turn.interrupt",
+      commandId: CommandId.make(
+        `t3cli:thread-interrupt:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      threadId: ThreadId.make(input.threadId),
+      ...(input.turnId !== undefined ? { turnId: TurnId.make(input.turnId) } : {}),
+      createdAt,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.turn.interrupt" }>;
+  },
+);
+
 export const makeThreadApprovalRespondCommand = Effect.fn("makeThreadApprovalRespondCommand")(
   function* (input: {
     readonly threadId: string;
@@ -142,3 +200,26 @@ export const makeThreadUserInputRespondCommand = Effect.fn("makeThreadUserInputR
     } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.user-input.respond" }>;
   },
 );
+
+export const makeThreadMetaUpdateCommand = Effect.fn("makeThreadMetaUpdateCommand")(function* (
+  threadId: string,
+  input: {
+    readonly title?: string;
+    readonly modelSelection?: ModelSelection;
+    readonly branch?: string | null;
+    readonly worktreePath?: string | null;
+  },
+) {
+  const crypto = yield* Crypto.Crypto;
+  return {
+    type: "thread.meta.update",
+    commandId: CommandId.make(
+      `t3cli:thread-meta-update:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+    ),
+    threadId: ThreadId.make(threadId),
+    ...(input.title !== undefined ? { title: input.title } : {}),
+    ...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}),
+    ...(input.branch !== undefined ? { branch: input.branch } : {}),
+    ...(input.worktreePath !== undefined ? { worktreePath: input.worktreePath } : {}),
+  } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.meta.update" }>;
+});

package/src/application/thread-update.ts

@@ -0,0 +1,72 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { ModelSelection } from "@t3tools/contracts";
+
+import { ModelSelectionError, ThreadEventError } from "../domain/error.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { mergeModelOptions, resolveUpdateModelSelection } from "./model-selection.ts";
+import type { UpdateThreadInput } from "./service.ts";
+import { makeThreadMetaUpdateCommand } from "./thread-commands.ts";
+
+export function makeUpdateThread() {
+  return Effect.fn("T3ApplicationLive.updateThread")(function* (input: UpdateThreadInput) {
+    const orchestration = yield* T3Orchestration;
+    const crypto = yield* Crypto.Crypto;
+    const hasProvider = input.provider !== undefined && input.provider.length > 0;
+    const hasModel = input.model !== undefined && input.model.length > 0;
+    const options = input.options;
+    const hasOptions = options !== undefined && options.length > 0;
+    const thread = yield* orchestration.getThreadSnapshot(input.threadId);
+    let modelSelection: ModelSelection | undefined;
+    if (hasProvider || hasModel) {
+      const snapshot = yield* orchestration.getShellSnapshot();
+      const project = snapshot.projects.find((entry) => entry.id === thread.projectId);
+      if (project === undefined) {
+        return yield* Effect.fail(
+          new ThreadEventError({
+            message: `project not found for thread: ${input.threadId}`,
+          }),
+        );
+      }
+      const serverConfig = yield* orchestration.getServerConfig();
+      if (hasProvider && thread.session !== null && thread.session.status !== "stopped") {
+        const sessionProviderId =
+          thread.session.providerInstanceId ?? thread.modelSelection.instanceId;
+        const sessionProvider = serverConfig.providers.find(
+          (provider) => provider.instanceId === sessionProviderId,
+        );
+        const targetProvider = serverConfig.providers.find(
+          (provider) => provider.instanceId === input.provider,
+        );
+        if (
+          sessionProvider !== undefined &&
+          targetProvider !== undefined &&
+          targetProvider.driver !== sessionProvider.driver
+        ) {
+          return yield* Effect.fail(
+            new ModelSelectionError({
+              message: `thread ${input.threadId} is bound to ${sessionProvider.driver} provider ${sessionProviderId}; cannot update provider to ${targetProvider.driver} provider ${input.provider}`,
+            }),
+          );
+        }
+      }
+      modelSelection = yield* resolveUpdateModelSelection({
+        current: thread.modelSelection,
+        ...(hasProvider ? { provider: input.provider } : {}),
+        ...(hasModel ? { model: input.model } : {}),
+        ...(hasOptions ? { options } : {}),
+        project,
+        serverConfig,
+      });
+    } else if (hasOptions) {
+      modelSelection = mergeModelOptions(thread.modelSelection, options);
+    }
+    const command = yield* makeThreadMetaUpdateCommand(input.threadId, {
+      ...(input.title !== undefined ? { title: input.title } : {}),
+      ...(modelSelection !== undefined ? { modelSelection } : {}),
+      ...(input.branch !== undefined ? { branch: input.branch } : {}),
+      ...(input.worktreePath !== undefined ? { worktreePath: input.worktreePath } : {}),
+    }).pipe(Effect.provideService(Crypto.Crypto, crypto));
+    return yield* orchestration.dispatch(command);
+  });
+}

package/src/application/thread-wait.ts

@@ -1,10 +1,10 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import type { OrchestrationMessage, OrchestrationThread } from "#t3tools/contracts";
+import type { OrchestrationMessage, OrchestrationThread } from "@t3tools/contracts";
 
 import { ThreadSessionError } from "../domain/error.ts";
-import type { Orchestration } from "../orchestration/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
 import type { WaitEvent } from "./service.ts";
 import {
   applyThreadEvent,
@@ -15,60 +15,59 @@ import {
   threadStatus,
 } from "../domain/thread-lifecycle.ts";
 
-export function watchThread(input: {
-  readonly orchestration: Orchestration;
-  readonly threadId: string;
-}) {
+export function watchThread(input: { readonly threadId: string }) {
   let current: OrchestrationThread | undefined;
   let currentMessages: Map<string, OrchestrationMessage> | undefined;
-  return Stream.scoped(
-    input.orchestration.watchThreadItems(input.threadId).pipe(
-      Stream.flatMap((item) => {
-        if (item.kind === "snapshot") {
-          const messages = new Map<string, OrchestrationMessage>();
-          for (const message of item.snapshot.thread.messages) {
-            messages.set(messageKey(message), message);
-          }
-          current = item.snapshot.thread;
-          currentMessages = messages;
+  return Stream.unwrap(
+    Effect.gen(function* () {
+      const orchestration = yield* T3Orchestration;
+      return Stream.scoped(
+        orchestration.watchThreadItems(input.threadId).pipe(
+          Stream.flatMap((item) => {
+            if (item.kind === "snapshot") {
+              const messages = new Map<string, OrchestrationMessage>();
+              for (const message of item.snapshot.thread.messages) {
+                messages.set(messageKey(message), message);
+              }
+              current = item.snapshot.thread;
+              currentMessages = messages;
 
-          const events: Array<WaitEvent> = [
-            { type: "thread", thread: current },
-            { type: "status", status: threadStatus(current), threadId: current.id },
-          ];
-          if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
-            events.push({ type: "done", thread: current });
-          }
-          return Stream.fromIterable(events);
-        }
+              const events: Array<WaitEvent> = [
+                { type: "thread", thread: current },
+                { type: "status", status: threadStatus(current), threadId: current.id },
+              ];
+              if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
+                events.push({ type: "done", thread: current });
+              }
+              return Stream.fromIterable(events);
+            }
 
-        if (current === undefined || currentMessages === undefined) {
-          return Stream.fail(
-            new ThreadSessionError({
-              message: `thread stream event received before snapshot: ${input.threadId}`,
-              threadId: input.threadId,
-            }),
-          );
-        }
+            if (current === undefined || currentMessages === undefined) {
+              return Stream.fail(
+                new ThreadSessionError({
+                  message: `thread stream event received before snapshot: ${input.threadId}`,
+                  threadId: input.threadId,
+                }),
+              );
+            }
 
-        current = applyThreadEvent(current, item.event, currentMessages);
-        const message = messageFromEvent(item.event, currentMessages);
-        const events: Array<WaitEvent> = message !== null ? [{ type: "message", message }] : [];
-        events.push({ type: "status", status: threadStatus(current), threadId: current.id });
-        if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
-          events.push({ type: "done", thread: current });
-        }
-        return Stream.fromIterable(events);
-      }),
-      Stream.takeUntil((event) => event.type === "done"),
-    ),
+            current = applyThreadEvent(current, item.event, currentMessages);
+            const message = messageFromEvent(item.event, currentMessages);
+            const events: Array<WaitEvent> = message !== null ? [{ type: "message", message }] : [];
+            events.push({ type: "status", status: threadStatus(current), threadId: current.id });
+            if (!isThreadActive(current) && isThreadCompleteEnough(current)) {
+              events.push({ type: "done", thread: current });
+            }
+            return Stream.fromIterable(events);
+          }),
+          Stream.takeUntil((event) => event.type === "done"),
+        ),
+      );
+    }),
   );
 }
 
-export function waitForThread(input: {
-  readonly orchestration: Orchestration;
-  readonly threadId: string;
-}) {
+export function waitForThread(input: { readonly threadId: string }) {
   return watchThread(input).pipe(
     Stream.runLast,
     Effect.flatMap((event) => {