t3code-cli 0.10.0 → 0.12.0

package/src/application/threads.test.ts

@@ -0,0 +1,172 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import { fromPartial } from "@total-typescript/shoehorn";
+import type {
+  ClientOrchestrationCommand,
+  OrchestrationShellSnapshot,
+  OrchestrationThread,
+  OrchestrationThreadShell,
+} from "@t3tools/contracts";
+
+import * as CliRuntime from "../cli/runtime/service.ts";
+import { t3CliEnvConfigLayer } from "../config/env/env.test-utils.ts";
+import { T3Orchestration, type Orchestration } from "../orchestration/service.ts";
+import { makeThreadApplication } from "./threads.ts";
+
+function makeThread(
+  id: string,
+  projectId: string,
+  archivedAt: string | null,
+): OrchestrationThreadShell {
+  return fromPartial({
+    id,
+    projectId,
+    archivedAt,
+    title: `thread-${id}`,
+    updatedAt: "2026-01-01T00:00:00.000Z",
+  });
+}
+
+function makeSnapshot(threads: OrchestrationThreadShell[]): OrchestrationShellSnapshot {
+  return fromPartial({
+    projects: [{ id: "proj-1", workspaceRoot: "/workspace" }],
+    threads,
+  });
+}
+
+function makeOrchestrationLayer(input: {
+  readonly active?: OrchestrationShellSnapshot;
+  readonly archived?: OrchestrationShellSnapshot;
+  readonly threadSnapshot?: OrchestrationThread;
+  readonly onDispatch?: (command: ClientOrchestrationCommand) => void;
+}) {
+  return Layer.succeed(
+    T3Orchestration,
+    fromPartial<Orchestration>({
+      getShellSnapshot: () => Effect.succeed(input.active ?? makeSnapshot([])),
+      getArchivedShellSnapshot: () => Effect.succeed(input.archived ?? makeSnapshot([])),
+      getThreadSnapshot: () => Effect.succeed(input.threadSnapshot ?? fromPartial({})),
+      dispatch: (command: ClientOrchestrationCommand) => {
+        input.onDispatch?.(command);
+        return Effect.succeed({ sequence: 42 });
+      },
+    }),
+  );
+}
+
+const testLayer = (orchestration: Layer.Layer<T3Orchestration>) =>
+  Layer.mergeAll(
+    orchestration,
+    NodeServices.layer,
+    CliRuntime.layer,
+    t3CliEnvConfigLayer("/tmp/t3cli-test"),
+  );
+
+describe("interruptThread", () => {
+  it.layer(NodeServices.layer)("interruptThread", (t) => {
+    t.effect("dispatches thread.turn.interrupt with activeTurnId from snapshot", () =>
+      Effect.gen(function* () {
+        let dispatched: ClientOrchestrationCommand | undefined;
+        const threadSnapshot = fromPartial<OrchestrationThread>({
+          id: "thread-1",
+          session: {
+            activeTurnId: "turn-1",
+          },
+        });
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(
+            testLayer(
+              makeOrchestrationLayer({
+                threadSnapshot,
+                onDispatch: (command) => {
+                  dispatched = command;
+                },
+              }),
+            ),
+          ),
+        );
+
+        const dispatch = yield* app.interruptThread("thread-1");
+        assert.equal(dispatch.sequence, 42);
+        assert.equal(dispatched?.type, "thread.turn.interrupt");
+        if (dispatched?.type === "thread.turn.interrupt") {
+          assert.equal(dispatched.threadId, "thread-1");
+          assert.equal(dispatched.turnId, "turn-1");
+        }
+      }),
+    );
+  });
+});
+
+describe("listThreads", () => {
+  it.layer(NodeServices.layer)("listThreads", (t) => {
+    t.effect("returns active threads by default", () =>
+      Effect.gen(function* () {
+        const active = makeSnapshot([
+          makeThread("active-1", "proj-1", null),
+          makeThread("active-2", "proj-1", null),
+        ]);
+        const archived = makeSnapshot([
+          makeThread("archived-1", "proj-1", "2026-01-01T00:00:00.000Z"),
+        ]);
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(testLayer(makeOrchestrationLayer({ active, archived }))),
+        );
+
+        const result = yield* app.listThreads("proj-1");
+        assert.deepEqual(
+          result.threads.map((thread) => thread.id),
+          ["active-1", "active-2"],
+        );
+      }),
+    );
+
+    t.effect("returns archived threads when include is archived", () =>
+      Effect.gen(function* () {
+        const active = makeSnapshot([makeThread("active-1", "proj-1", null)]);
+        const archived = makeSnapshot([
+          makeThread("archived-1", "proj-1", "2026-01-01T00:00:00.000Z"),
+          makeThread("archived-2", "proj-1", "2026-01-02T00:00:00.000Z"),
+        ]);
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(testLayer(makeOrchestrationLayer({ active, archived }))),
+        );
+
+        const result = yield* app.listThreads("proj-1", { include: "archived" });
+        assert.deepEqual(
+          result.threads.map((thread) => thread.id),
+          ["archived-1", "archived-2"],
+        );
+        assert.isTrue(result.threads.every((thread) => thread.archivedAt !== null));
+      }),
+    );
+
+    t.effect("returns merged threads without duplicates when include is all", () =>
+      Effect.gen(function* () {
+        const active = makeSnapshot([
+          makeThread("active-1", "proj-1", null),
+          makeThread("shared", "proj-1", null),
+        ]);
+        const archived = makeSnapshot([
+          makeThread("archived-1", "proj-1", "2026-01-01T00:00:00.000Z"),
+          makeThread("shared", "proj-1", "2026-01-02T00:00:00.000Z"),
+        ]);
+        const app = yield* makeThreadApplication().pipe(
+          Effect.provide(testLayer(makeOrchestrationLayer({ active, archived }))),
+        );
+
+        const result = yield* app.listThreads("proj-1", { include: "all" });
+        assert.deepEqual(
+          result.threads.map((thread) => thread.id).toSorted(),
+          ["active-1", "archived-1", "shared"].toSorted(),
+        );
+        const shared = result.threads.find((thread) => thread.id === "shared");
+        assert.equal(shared?.archivedAt, "2026-01-02T00:00:00.000Z");
+      }),
+    );
+  });
+});

package/src/application/threads.ts

@@ -1,25 +1,36 @@
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-
-import { Environment } from "../environment/service.ts";
+import * as Stream from "effect/Stream";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
-import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
+import { ProjectLookupError, ThreadLookupError, ThreadSessionError } from "../domain/error.ts";
 import { resolveProjectScope } from "../domain/helpers.ts";
-import { type StartThreadInput } from "./service.ts";
-import type { SendThreadInput, CallbackThreadInput } from "./service.ts";
+import { type ListThreadsInclude, type StartThreadInput } from "./service.ts";
+import type { CallbackThreadInput, SendThreadInput } from "./service.ts";
+import type { T3ThreadApplicationService } from "./service.ts";
+import type { OrchestrationThreadShell } from "@t3tools/contracts";
 import { mergeModelOptions } from "./model-selection.ts";
 import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
-import { threadStatus, type ThreadLifecycleStatus } from "../domain/thread-lifecycle.ts";
-import type { OrchestrationThread } from "#t3tools/contracts";
-import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "#t3tools/contracts";
+import {
+  sessionNeedsStopBeforeDelete,
+  threadStatus,
+  type ThreadLifecycleStatus,
+} from "../domain/thread-lifecycle.ts";
+import type { OrchestrationThread } from "@t3tools/contracts";
+import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "@t3tools/contracts";
 import {
   makeThreadApprovalRespondCommand,
   makeThreadArchiveCommand,
+  makeThreadDeleteCommand,
+  makeThreadInterruptCommand,
+  makeThreadSessionStopCommand,
   makeThreadStartCommands,
   makeThreadTurnContinueCommand,
+  makeThreadUnarchiveCommand,
   makeThreadUserInputRespondCommand,
 } from "./thread-commands.ts";
+import { makeUpdateThread } from "./thread-update.ts";
 import {
   waitForThread as waitForThreadUntilComplete,
   watchThread as watchThreadEvents,
@@ -30,9 +41,25 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   const orchestration = yield* T3Orchestration;
   const crypto = yield* Crypto.Crypto;
   const path = yield* Path.Path;
-  const environment = yield* Environment;
-  const listThreads = Effect.fn("T3ApplicationLive.listThreads")(function* (projectRef: string) {
-    const snapshot = yield* orchestration.getShellSnapshot();
+  const cliRuntime = yield* CliRuntime;
+  const awaitShellSequence = (sequence: number) =>
+    waitForShellSequence({ sequence }).pipe(Effect.provideService(T3Orchestration, orchestration));
+  const awaitThreadCompletion = (threadId: string) =>
+    waitForThreadUntilComplete({ threadId }).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
+  const streamThreadEvents = (threadId: string) =>
+    watchThreadEvents({ threadId }).pipe(Stream.provideService(T3Orchestration, orchestration));
+  const listThreads = Effect.fn("T3ApplicationLive.listThreads")(function* (
+    projectRef: string,
+    options?: {
+      readonly include?: ListThreadsInclude;
+    },
+  ) {
+    const include = options?.include ?? "active";
+    const snapshot = yield* loadThreadsSnapshot(include).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
     const scope = yield* resolveProjectScope(snapshot, {
       ref: projectRef,
     }).pipe(Effect.provideService(Path.Path, path));
@@ -61,6 +88,55 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     );
     return yield* orchestration.dispatch(command);
   });
+  const unarchiveThread = Effect.fn("T3ApplicationLive.unarchiveThread")(function* (
+    threadId: string,
+  ) {
+    const command = yield* makeThreadUnarchiveCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    return yield* orchestration.dispatch(command);
+  });
+  const interruptThread = Effect.fn("T3ApplicationLive.interruptThread")(function* (
+    threadId: string,
+  ) {
+    const snapshot = yield* orchestration.getThreadSnapshot(threadId);
+    const activeTurnId = snapshot.session?.activeTurnId ?? undefined;
+    const command = yield* makeThreadInterruptCommand({
+      threadId,
+      ...(activeTurnId !== undefined ? { turnId: activeTurnId } : {}),
+    }).pipe(Effect.provideService(Crypto.Crypto, crypto));
+    return yield* orchestration.dispatch(command);
+  });
+  const deleteThread = Effect.fn("T3ApplicationLive.deleteThread")(function* (threadId: string) {
+    const snapshot = yield* loadThreadsSnapshot("all").pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+    );
+    const thread = snapshot.threads.find((item) => item.id === threadId);
+    if (thread === undefined) {
+      return yield* Effect.fail(
+        new ThreadLookupError({
+          message: `thread not found: ${threadId}`,
+          threadId,
+        }),
+      );
+    }
+    if (sessionNeedsStopBeforeDelete(thread.session)) {
+      const stopCommand = yield* makeThreadSessionStopCommand(threadId).pipe(
+        Effect.provideService(Crypto.Crypto, crypto),
+      );
+      yield* orchestration.dispatch(stopCommand);
+    }
+    const command = yield* makeThreadDeleteCommand(threadId).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    const dispatch = yield* orchestration.dispatch(command);
+    return { threadId, dispatch };
+  });
+  const updateThread: T3ThreadApplicationService["updateThread"] = (input) =>
+    makeUpdateThread()(input).pipe(
+      Effect.provideService(T3Orchestration, orchestration),
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
   const startThread = Effect.fn("T3ApplicationLive.startThread")(function* (
     startInput: StartThreadInput,
     policy?: {
@@ -73,7 +149,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       return yield* Effect.fail(
         new ProjectLookupError({
           message: "project is required",
-          ref: environment.cwd,
+          ref: cliRuntime.cwd,
         }),
       );
     }
@@ -96,20 +172,14 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       serverConfig,
     }).pipe(Effect.provideService(Crypto.Crypto, crypto));
     const createDispatch = yield* orchestration.dispatch(commands.createCommand);
-    yield* waitForShellSequence({
-      orchestration,
-      sequence: createDispatch.sequence,
-    });
+    yield* awaitShellSequence(createDispatch.sequence);
     const dispatch = yield* orchestration.dispatch(commands.turnCommand);
     const threadId = commands.threadId;
     const until = policy?.until ?? "dispatch";
     if (until === "dispatch") {
       return { dispatch, project: scope.project, threadId };
     }
-    yield* waitForShellSequence({
-      orchestration,
-      sequence: dispatch.sequence,
-    });
+    yield* awaitShellSequence(dispatch.sequence);
     if (until === "visible") {
       const thread = yield* Effect.scoped(
         Effect.gen(function* () {
@@ -119,10 +189,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       );
       return { dispatch, project: scope.project, threadId, thread };
     }
-    const thread = yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId,
-    });
+    const thread = yield* awaitThreadCompletion(threadId);
     yield* failIfThreadError(thread);
     return { dispatch, project: scope.project, threadId, thread };
   });
@@ -148,10 +215,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     if (until === "dispatch") {
       return { dispatch, threadId: input.threadId };
     }
-    yield* waitForShellSequence({
-      orchestration,
-      sequence: dispatch.sequence,
-    });
+    yield* awaitShellSequence(dispatch.sequence);
     if (until === "visible") {
       const thread = yield* Effect.scoped(
         Effect.gen(function* () {
@@ -161,33 +225,20 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       );
       return { dispatch, threadId: input.threadId, thread };
     }
-    const thread = yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId: input.threadId,
-    });
+    const thread = yield* awaitThreadCompletion(input.threadId);
     yield* failIfThreadError(thread);
     return { dispatch, threadId: input.threadId, thread };
   });
-  const watchThread = (threadId: string) =>
-    watchThreadEvents({
-      orchestration,
-      threadId,
-    });
+  const watchThread = (threadId: string) => streamThreadEvents(threadId);
   const waitForThread = Effect.fn("T3ApplicationLive.waitForThread")(function* (threadId: string) {
-    const thread = yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId,
-    });
+    const thread = yield* awaitThreadCompletion(threadId);
     yield* failIfThreadError(thread);
     return thread;
   });
   const callbackThread = Effect.fn("T3ApplicationLive.callbackThread")(function* (
     input: CallbackThreadInput,
   ) {
-    yield* waitForThreadUntilComplete({
-      orchestration,
-      threadId: input.fromThreadId,
-    });
+    yield* awaitThreadCompletion(input.fromThreadId);
     const result = yield* sendThread(
       { threadId: input.targetThreadId, message: input.prompt },
       { until: "dispatch" },
@@ -220,6 +271,10 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   return {
     approveThread,
     archiveThread,
+    deleteThread,
+    interruptThread,
+    updateThread,
+    unarchiveThread,
     listThreads,
     getThreadMessages,
     respondToThread,
@@ -229,9 +284,37 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     watchThread,
     waitForThread,
     callbackThread,
+  } satisfies T3ThreadApplicationService;
+});
+
+const loadThreadsSnapshot = Effect.fn("loadThreadsSnapshot")(function* (
+  include: ListThreadsInclude,
+) {
+  const orchestration = yield* T3Orchestration;
+  if (include === "active") {
+    return yield* orchestration.getShellSnapshot();
+  }
+  if (include === "archived") {
+    return yield* orchestration.getArchivedShellSnapshot();
+  }
+  const [activeSnapshot, archivedSnapshot] = yield* Effect.all([
+    orchestration.getShellSnapshot(),
+    orchestration.getArchivedShellSnapshot(),
+  ]);
+  return {
+    ...activeSnapshot,
+    threads: dedupeThreadsById([...activeSnapshot.threads, ...archivedSnapshot.threads]),
   };
 });
 
+function dedupeThreadsById(threads: ReadonlyArray<OrchestrationThreadShell>) {
+  const byId = new Map<string, OrchestrationThreadShell>();
+  for (const thread of threads) {
+    byId.set(thread.id, thread);
+  }
+  return [...byId.values()];
+}
+
 export type ThreadShow = {
   readonly id: string;
   readonly projectId: string;

package/src/auth/error.ts

@@ -3,7 +3,8 @@ import * as Schema from "effect/Schema";
 import { PlatformError } from "effect/PlatformError";
 import { HttpClientError } from "effect/unstable/http";
 
-import { ConfigError, UrlError } from "../config/error.ts";
+import { ConfigError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
 
 export class AuthPairingUrlError extends Schema.TaggedErrorClass<AuthPairingUrlError>()(
   "AuthPairingUrlError",

package/src/auth/index.ts

@@ -17,7 +17,13 @@ export type { AuthError } from "./error.ts";
 export type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
 export type {
   AuthConfigInput,
+  AuthEnvironmentListItem,
+  AuthEnvironmentSummary,
+  AuthResolvedConfig,
   AuthSessionRole,
+  AuthStatusResult,
+  AuthUnpairResult,
+  AuthUseResult,
   LocalAuthInput,
   LocalAuthOriginInput,
   LocalAuthResult,
@@ -25,4 +31,5 @@ export type {
   LocalAuthTokenResult,
   PairingUrl,
   PairResult,
+  PersistEnvironmentInput,
 } from "./type.ts";

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

@@ -0,0 +1,34 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { T3AuthLive } from "./layer.ts";
+import { T3LocalAuth } from "./local.ts";
+import { T3AuthPairing } from "./pairing.ts";
+import { T3AuthTransport } from "./transport.ts";
+import { t3ConfigDepsLayer } from "../config/layer.test-utils.ts";
+import { ConfigPlatformLayer } from "../config/platform.test-utils.ts";
+
+export function t3AuthDepsLayer(homeDir: string) {
+  return T3AuthLive.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        t3ConfigDepsLayer(homeDir),
+        Layer.succeed(T3AuthTransport)({
+          bootstrapBearer: () => Effect.die("unused in test"),
+          getSession: () => Effect.succeed({ authenticated: false }),
+          issueWebSocketTicket: () => Effect.die("unused in test"),
+        }),
+        Layer.succeed(T3LocalAuth)({
+          local: () => Effect.die("unused in test"),
+        }),
+        Layer.succeed(T3AuthPairing)({
+          pair: () => Effect.die("unused in test"),
+        }),
+      ),
+    ),
+  );
+}
+
+export function t3AuthLayerTest(homeDir: string) {
+  return Layer.mergeAll(ConfigPlatformLayer, t3AuthDepsLayer(homeDir));
+}