t3code-cli 0.7.0 → 0.9.0

package/src/cli/thread.ts

@@ -1,9 +1,13 @@
 import { Command } from "effect/unstable/cli";
 
+import { approveThreadCommand } from "./threads/approve.ts";
 import { archiveThreadCommand } from "./threads/archive.ts";
+import { callbackThreadCommand } from "./threads/callback.ts";
 import { listThreadsCommand } from "./threads/list.ts";
 import { getThreadMessagesCommand } from "./threads/messages.ts";
+import { respondThreadCommand } from "./threads/respond.ts";
 import { sendThreadCommand } from "./threads/send.ts";
+import { showThreadCommand } from "./threads/show.ts";
 import { startThreadCommand } from "./threads/start.ts";
 import { waitForThreadCommand } from "./threads/wait.ts";
 
@@ -14,9 +18,13 @@ export function createThreadCommand() {
       listThreadsCommand,
       startThreadCommand,
       sendThreadCommand,
+      showThreadCommand,
+      approveThreadCommand,
+      respondThreadCommand,
       archiveThreadCommand,
       getThreadMessagesCommand,
       waitForThreadCommand,
+      callbackThreadCommand,
     ]),
   );
 }

package/src/cli/threads/approve.ts

@@ -0,0 +1,61 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingRequestError, MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+const approvalDecisionFlag = Flag.choice("decision", ["accept", "decline", "cancel"] as const).pipe(
+  Flag.withDescription("Approval decision"),
+);
+
+const requestFlag = Flag.string("request").pipe(
+  Flag.withDescription("Pending approval request id"),
+  Flag.optional,
+);
+
+export const approveThreadCommand = Command.make(
+  "approve",
+  {
+    thread: threadFlag,
+    request: requestFlag,
+    decision: approvalDecisionFlag,
+    format: formatFlag,
+  },
+  ({ thread, request, decision, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const requestId = Option.getOrUndefined(request);
+      if (requestId === undefined || requestId.length === 0) {
+        return yield* Effect.fail(
+          new MissingRequestError({ message: "request id is required: pass --request" }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* application.approveThread({ threadId, requestId, decision });
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(result);
+      }
+      return yield* output.printInfo(
+        `approval submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+      );
+    }),
+).pipe(Command.withDescription("respond to a pending approval request"));

package/src/cli/threads/archive.ts

@@ -1,9 +1,9 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { Command } from "effect/unstable/cli";
+import { Command, Flag } from "effect/unstable/cli";
 
 import { formatFlag, threadFlag } from "../flags.ts";
-import { MissingThreadError } from "../error.ts";
+import { MissingThreadError, SelfArchiveError } from "../error.ts";
 import { resolveThreadId } from "../../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
@@ -14,9 +14,10 @@ export const archiveThreadCommand = Command.make(
   "archive",
   {
     thread: threadFlag,
+    force: Flag.boolean("force").pipe(Flag.withAlias("f")),
     format: formatFlag,
   },
-  ({ thread, format }) =>
+  ({ thread, force, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
       const environment = yield* Environment;
@@ -32,6 +33,20 @@ export const archiveThreadCommand = Command.make(
           }),
         );
       }
+      const envThreadId = environment.env.T3CODE_THREAD_ID;
+      if (
+        envThreadId !== undefined &&
+        envThreadId.length > 0 &&
+        threadId === envThreadId &&
+        !force
+      ) {
+        return yield* Effect.fail(
+          new SelfArchiveError({
+            threadId,
+            message: `cannot archive thread ${threadId}: matches T3CODE_THREAD_ID (are you trying to archive yourself?). Use --force to override.`,
+          }),
+        );
+      }
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
       const dispatch = yield* application.archiveThread(threadId);
       if (resolvedFormat === "json") {

package/src/cli/threads/callback.ts

@@ -0,0 +1,92 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { Environment } from "../../environment/service.ts";
+import { T3Application } from "../../application/service.ts";
+import { T3Output } from "../output/service.ts";
+import { CliPath } from "../../cli-path/service.ts";
+
+export const callbackThreadCommand = Command.make(
+  "callback",
+  {
+    from: Flag.string("from").pipe(Flag.withDescription("Thread ID to watch for completion")),
+    thread: threadFlag,
+    prompt: Flag.string("prompt").pipe(Flag.withDescription("Message to send to target thread")),
+    background: Flag.boolean("background").pipe(
+      Flag.withDescription("Fork and detach as background process"),
+      Flag.optional,
+    ),
+  },
+  ({ from, thread, prompt, background }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const cliPath = yield* CliPath;
+      const spawner = yield* ChildProcessSpawner;
+
+      const fromThreadId = from;
+
+      const targetThreadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (targetThreadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "target thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+
+      const isBackground = Option.getOrElse(background, () => false);
+      if (isBackground) {
+        const args = [
+          cliPath.path,
+          "thread",
+          "callback",
+          "--from",
+          fromThreadId,
+          "--thread",
+          targetThreadId,
+          "--prompt",
+          prompt,
+        ];
+
+        const proc = ChildProcess.make(process.execPath, args, {
+          detached: true,
+          stdin: "ignore",
+          stdout: "ignore",
+          stderr: "ignore",
+        });
+
+        const handle = yield* spawner.spawn(proc);
+        const reref = yield* handle.unref;
+        yield* reref.pipe(Effect.ignore);
+
+        yield* output.printInfo(
+          `background callback scheduled: ${fromThreadId} -> ${targetThreadId} (pid: ${handle.pid})`,
+        );
+        return undefined;
+      }
+
+      yield* output.printInfo(`watching thread ${fromThreadId} for completion...`);
+
+      const result = yield* application.callbackThread({
+        fromThreadId,
+        targetThreadId,
+        prompt,
+      });
+
+      yield* output.printInfo(
+        `callback sent to ${result.targetThreadId} (dispatch: ${result.dispatch.sequence})`,
+      );
+      return undefined;
+    }),
+).pipe(Command.withDescription("watch a thread and send a message when it completes"));

package/src/cli/threads/respond.ts

@@ -0,0 +1,70 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingRequestError, MissingThreadError } from "../error.ts";
+import { readJsonAnswers } from "../message-input.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { T3Input } from "../input/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+const requestFlag = Flag.string("request").pipe(
+  Flag.withDescription("Pending user-input request id"),
+  Flag.optional,
+);
+
+export const respondThreadCommand = Command.make(
+  "respond",
+  {
+    thread: threadFlag,
+    request: requestFlag,
+    answers: Flag.string("answers").pipe(Flag.optional),
+    stdin: Flag.boolean("stdin"),
+    format: formatFlag,
+  },
+  ({ thread, request, answers, stdin, format }) =>
+    Effect.gen(function* () {
+      const inputService = yield* T3Input;
+      const parsedAnswers = yield* readJsonAnswers({
+        answers: Option.getOrUndefined(answers),
+        fromStdin: stdin,
+        readStdin: inputService.readStdin,
+      });
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const requestId = Option.getOrUndefined(request);
+      if (requestId === undefined || requestId.length === 0) {
+        return yield* Effect.fail(
+          new MissingRequestError({ message: "request id is required: pass --request" }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* application.respondToThread({
+        threadId,
+        requestId,
+        answers: parsedAnswers,
+      });
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(result);
+      }
+      return yield* output.printInfo(
+        `user input submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+      );
+    }),
+).pipe(Command.withDescription("respond to a pending user-input request"));

package/src/cli/threads/show.ts

@@ -0,0 +1,43 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { formatThreadShowHuman, formatThreadShowJson } from "../thread-format.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const showThreadCommand = Command.make(
+  "show",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const detail = yield* application.showThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(formatThreadShowJson(detail));
+      }
+      return yield* output.writeStdout(formatThreadShowHuman(detail));
+    }),
+).pipe(Command.withDescription("show thread status and pending requests"));

package/src/cli-path/layer.ts

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { CliPath } from "./service.ts";
+
+const makeCliPath = Effect.sync(() => ({
+  path: process.argv[1] ?? "dist/bin.js",
+}));
+
+export const NodeCliPathLayer = Layer.effect(CliPath, makeCliPath);

package/src/cli-path/service.ts

@@ -0,0 +1,7 @@
+import * as Context from "effect/Context";
+
+export type CliPathShape = {
+  readonly path: string;
+};
+
+export class CliPath extends Context.Service<CliPath, CliPathShape>()("t3cli/CliPath") {}

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

@@ -0,0 +1,321 @@
+import "vite-plus/test/config";
+
+import { EventId, TurnId, type OrchestrationThreadActivity } from "#t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+
+import { derivePendingApprovals, derivePendingUserInputs } from "./thread-activities.ts";
+
+let nextActivityId = 0;
+
+function makeActivity(overrides: {
+  id?: string;
+  createdAt?: string;
+  kind?: string;
+  summary?: string;
+  tone?: OrchestrationThreadActivity["tone"];
+  payload?: Record<string, unknown>;
+  turnId?: string;
+  sequence?: number;
+}): OrchestrationThreadActivity {
+  const payload = overrides.payload ?? {};
+  return {
+    id: EventId.make(overrides.id ?? `activity-${nextActivityId++}`),
+    createdAt: overrides.createdAt ?? "2026-02-23T00:00:00.000Z",
+    kind: overrides.kind ?? "tool.started",
+    summary: overrides.summary ?? "Tool call",
+    tone: overrides.tone ?? "tool",
+    payload,
+    turnId: overrides.turnId !== undefined ? TurnId.make(overrides.turnId) : null,
+    ...(overrides.sequence !== undefined ? { sequence: overrides.sequence } : {}),
+  };
+}
+
+describe("derivePendingApprovals", () => {
+  it("tracks open approvals and removes resolved ones", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-1",
+          requestKind: "command",
+          detail: "bun run lint",
+        },
+      }),
+      makeActivity({
+        id: "approval-close",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "approval.resolved",
+        summary: "Approval resolved",
+        tone: "info",
+        payload: { requestId: "req-2" },
+      }),
+      makeActivity({
+        id: "approval-closed-request",
+        createdAt: "2026-02-23T00:00:01.500Z",
+        kind: "approval.requested",
+        summary: "File-change approval requested",
+        tone: "approval",
+        payload: { requestId: "req-2", requestKind: "file-change" },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([
+      {
+        requestId: "req-1",
+        requestKind: "command",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        detail: "bun run lint",
+      },
+    ]);
+  });
+
+  it("maps canonical requestType payloads into pending approvals", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open-request-type",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-request-type",
+          requestType: "command_execution_approval",
+          detail: "pwd",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([
+      {
+        requestId: "req-request-type",
+        requestKind: "command",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        detail: "pwd",
+      },
+    ]);
+  });
+
+  it("clears stale pending approvals when provider reports unknown pending request", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open-stale",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-stale-1",
+          requestKind: "command",
+        },
+      }),
+      makeActivity({
+        id: "approval-failed-stale",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "provider.approval.respond.failed",
+        summary: "Provider approval response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-stale-1",
+          detail: "Unknown pending permission request: req-stale-1",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([]);
+  });
+
+  it("clears stale pending approvals when request and stale failure share createdAt", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "z-approval-open-same-ts",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-same-ts-1",
+          requestKind: "command",
+        },
+      }),
+      makeActivity({
+        id: "a-approval-failed-same-ts",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "provider.approval.respond.failed",
+        summary: "Provider approval response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-same-ts-1",
+          detail: "Unknown pending permission request: req-same-ts-1",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([]);
+  });
+
+  it("clears stale pending approvals when the backend marks them stale after restart", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open-stale-restart",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-stale-restart-1",
+          requestKind: "command",
+        },
+      }),
+      makeActivity({
+        id: "approval-failed-stale-restart",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "provider.approval.respond.failed",
+        summary: "Provider approval response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-stale-restart-1",
+          detail:
+            "Stale pending approval request: req-stale-restart-1. Provider callback state does not survive app restarts or recovered sessions. Restart the turn to continue.",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([]);
+  });
+});
+
+describe("derivePendingUserInputs", () => {
+  it("tracks open structured prompts and removes resolved ones", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "user-input-open",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "user-input.requested",
+        summary: "User input requested",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-1",
+          questions: [
+            {
+              id: "sandbox_mode",
+              header: "Sandbox",
+              question: "Which mode should be used?",
+              options: [
+                {
+                  label: "workspace-write",
+                  description: "Allow workspace writes only",
+                },
+              ],
+              multiSelect: true,
+            },
+          ],
+        },
+      }),
+      makeActivity({
+        id: "user-input-resolved",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "user-input.resolved",
+        summary: "User input submitted",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-2",
+          answers: {
+            sandbox_mode: "workspace-write",
+          },
+        },
+      }),
+      makeActivity({
+        id: "user-input-open-2",
+        createdAt: "2026-02-23T00:00:01.500Z",
+        kind: "user-input.requested",
+        summary: "User input requested",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-2",
+          questions: [
+            {
+              id: "approval",
+              header: "Approval",
+              question: "Continue?",
+              options: [
+                {
+                  label: "yes",
+                  description: "Continue execution",
+                },
+              ],
+              multiSelect: false,
+            },
+          ],
+        },
+      }),
+    ];
+
+    expect(derivePendingUserInputs(activities)).toEqual([
+      {
+        requestId: "req-user-input-1",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        questions: [
+          {
+            id: "sandbox_mode",
+            header: "Sandbox",
+            question: "Which mode should be used?",
+            options: [
+              {
+                label: "workspace-write",
+                description: "Allow workspace writes only",
+              },
+            ],
+            multiSelect: true,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("clears stale pending user-input prompts when the provider reports an orphaned request", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "user-input-open-stale",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "user-input.requested",
+        summary: "User input requested",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-stale-1",
+          questions: [
+            {
+              id: "sandbox_mode",
+              header: "Sandbox",
+              question: "Which mode should be used?",
+              options: [
+                {
+                  label: "workspace-write",
+                  description: "Allow workspace writes only",
+                },
+              ],
+              multiSelect: false,
+            },
+          ],
+        },
+      }),
+      makeActivity({
+        id: "user-input-failed-stale",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "provider.user-input.respond.failed",
+        summary: "Provider user input response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-user-input-stale-1",
+          detail:
+            "Stale pending user-input request: req-user-input-stale-1. Provider callback state does not survive app restarts or recovered sessions. Restart the turn to continue.",
+        },
+      }),
+    ];
+
+    expect(derivePendingUserInputs(activities)).toEqual([]);
+  });
+});