chatroom-cli 1.47.0 → 1.49.0

package/dist/index.js

@@ -26260,9 +26260,25 @@ var init_pi_agent_service = __esm(() => {
     id = "pi";
     displayName = "Pi";
     command = PI_COMMAND;
+    childProcesses = new Map;
     constructor(deps) {
       super(deps);
     }
+    untrack(pid) {
+      this.childProcesses.delete(pid);
+      super.untrack(pid);
+    }
+    async resumeTurn(pid, prompt) {
+      const child = this.childProcesses.get(pid);
+      if (!child?.stdin) {
+        throw new Error(`No tracked pi process or stdin for pid=${pid}`);
+      }
+      const message = JSON.stringify({ type: "prompt", message: prompt }) + `
+`;
+      await new Promise((resolve, reject) => {
+        child.stdin.write(message, (err) => err ? reject(err) : resolve());
+      });
+    }
     async isInstalled() {
       return this.checkInstalled(PI_COMMAND);
     }
@@ -26321,6 +26337,7 @@ var init_pi_agent_service = __esm(() => {
       }
       const pid = childProcess.pid;
       const context4 = options.context;
+      this.childProcesses.set(pid, childProcess);
       const entry = this.registerProcess(pid, context4);
       const roleTag = context4.role ?? "unknown";
       const chatroomSuffix = context4.chatroomId ? `@${context4.chatroomId.slice(-6)}` : "";
@@ -26407,6 +26424,7 @@ var init_pi_agent_service = __esm(() => {
           pid,
           onExit: (cb) => {
             childProcess.on("exit", (code2, signal) => {
+              this.childProcesses.delete(pid);
               this.deleteProcess(pid);
               cb({ code: code2, signal, context: context4 });
             });
@@ -26431,6 +26449,7 @@ var init_pi_agent_service = __esm(() => {
         pid,
         onExit: (cb) => {
           childProcess.on("exit", (code2, signal) => {
+            this.childProcesses.delete(pid);
             this.deleteProcess(pid);
             cb({ code: code2, signal, context: context4 });
           });
@@ -26918,6 +26937,40 @@ var init_registry2 = __esm(() => {
   registry = new Map;
 });
 
+// src/infrastructure/services/remote-agents/claude/claude-models.ts
+async function fetchClaudeModels() {
+  const apiKey = process.env.ANTHROPIC_API_KEY?.trim();
+  if (!apiKey)
+    return;
+  try {
+    const resp = await fetch("https://api.anthropic.com/v1/models", {
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      }
+    });
+    if (!resp.ok)
+      return;
+    const json = await resp.json();
+    const ids3 = json.data.map((m) => m.id).filter((id3) => id3.startsWith("claude-"));
+    return ids3.length > 0 ? ids3 : undefined;
+  } catch {
+    return;
+  }
+}
+var CLAUDE_FALLBACK_MODELS;
+var init_claude_models = __esm(() => {
+  CLAUDE_FALLBACK_MODELS = [
+    "opus",
+    "sonnet",
+    "haiku",
+    "claude-opus-4-8",
+    "claude-opus-4-6",
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5"
+  ];
+});
+
 // src/infrastructure/services/remote-agents/claude/claude-stream-reader.ts
 import { createInterface as createInterface4 } from "node:readline";
 
@@ -26983,6 +27036,7 @@ var init_claude_stream_reader = () => {};
 var CLAUDE_COMMAND = "claude", DEFAULT_MAX_TURNS = 200, ClaudeCodeAgentService;
 var init_claude_code_agent_service = __esm(() => {
   init_base_cli_agent_service();
+  init_claude_models();
   init_claude_stream_reader();
   ClaudeCodeAgentService = class ClaudeCodeAgentService extends BaseCLIAgentService {
     id = "claude";
@@ -26998,7 +27052,10 @@ var init_claude_code_agent_service = __esm(() => {
       return this.checkVersion(CLAUDE_COMMAND);
     }
     async listModels() {
-      return ["claude-haiku-4-5", "claude-sonnet-4-6", "claude-opus-4-6"];
+      const dynamic = await fetchClaudeModels();
+      if (dynamic)
+        return dynamic;
+      return [...CLAUDE_FALLBACK_MODELS];
     }
     async spawn(options) {
       const { prompt, systemPrompt, model } = options;
@@ -27543,6 +27600,26 @@ async function withTimeout(p, ms, label) {
       clearTimeout(timer);
   }
 }
+function waitForResumeOrAbort(session) {
+  if (session.aborted)
+    return Promise.resolve(null);
+  return Promise.race([
+    new Promise((resolve) => {
+      session.resumeResolve = (prompt) => {
+        session.resumeResolve = undefined;
+        session.abortResolve = undefined;
+        resolve(prompt);
+      };
+    }),
+    new Promise((resolve) => {
+      session.abortResolve = () => {
+        session.resumeResolve = undefined;
+        session.abortResolve = undefined;
+        resolve(null);
+      };
+    })
+  ]);
+}
 function buildLogPrefix(context4) {
   const roleTag = context4.role ?? "unknown";
   const chatroomSuffix = context4.chatroomId ? `@${context4.chatroomId.slice(-6)}` : "";
@@ -27605,10 +27682,24 @@ var init_cursor_sdk_agent_service = __esm(() => {
         return [...CURSOR_SDK_FALLBACK_MODELS];
       }
     }
+    async resumeTurn(pid, prompt) {
+      const session = this.sessions.get(pid);
+      if (!session) {
+        throw new Error(`No cursor-sdk session for pid=${pid}`);
+      }
+      if (!session.resumeResolve) {
+        throw new Error(`cursor-sdk session pid=${pid} not waiting for resume`);
+      }
+      const resolve = session.resumeResolve;
+      session.resumeResolve = undefined;
+      session.abortResolve = undefined;
+      resolve(prompt);
+    }
     async stop(pid) {
       const session = this.sessions.get(pid);
       if (session) {
         session.aborted = true;
+        session.abortResolve?.();
         const run3 = session.run;
         if (run3?.supports("cancel")) {
           try {
@@ -27683,38 +27774,51 @@ ${options.prompt}` : options.prompt;
       (async () => {
         let exitCode = 0;
         let exitSignal = null;
+        let nextPrompt = fullPrompt;
+        let isFirstTurn = true;
         try {
-          const run3 = await withTimeout(agent.send(fullPrompt, {
-            local: { force: true },
-            idempotencyKey: randomUUID()
-          }), SEND_TIMEOUT_MS, "agent.send");
-          session.run = run3;
-          const adapter = new CursorSdkStreamAdapter(logPrefix);
-          adapter.onOutput(() => {
-            entry.lastOutputAt = Date.now();
-            for (const cb of outputCallbacks)
-              cb();
-          });
-          adapter.onAgentEnd(() => {
-            for (const cb of agentEndCallbacks)
-              cb();
-          });
-          for await (const message of run3.stream()) {
-            if (session.aborted)
+          while (!session.aborted) {
+            const run3 = await withTimeout(agent.send(nextPrompt, {
+              local: { force: isFirstTurn },
+              idempotencyKey: randomUUID()
+            }), SEND_TIMEOUT_MS, "agent.send");
+            session.run = run3;
+            isFirstTurn = false;
+            const adapter = new CursorSdkStreamAdapter(logPrefix);
+            adapter.onOutput(() => {
+              entry.lastOutputAt = Date.now();
+              for (const cb of outputCallbacks)
+                cb();
+            });
+            for await (const message of run3.stream()) {
+              if (session.aborted)
+                break;
+              adapter.handleMessage(message);
+            }
+            if (session.aborted) {
+              exitCode = 1;
+              exitSignal = "SIGTERM";
               break;
-            adapter.handleMessage(message);
-          }
-          if (!session.aborted) {
+            }
             const result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS, "run.wait");
             adapter.finish();
             if (result.status === "error") {
               exitCode = 2;
               process.stderr.write(`${logPrefix} run-error] run ${result.id} failed
 `);
+              break;
             }
-          } else {
-            exitCode = 1;
-            exitSignal = "SIGTERM";
+            for (const cb of agentEndCallbacks)
+              cb();
+            const resumePrompt = await waitForResumeOrAbort(session);
+            if (resumePrompt === null || session.aborted) {
+              if (session.aborted) {
+                exitCode = 1;
+                exitSignal = "SIGTERM";
+              }
+              break;
+            }
+            nextPrompt = resumePrompt;
           }
         } catch (err) {
           exitCode = 1;
@@ -30070,6 +30174,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
       });
       let sessionId;
       let forwarder;
+      let agentName;
       try {
         const sessionCreateResult = await withTimeout2(client4.session.create({ body: {} }), SESSION_CREATE_TIMEOUT_MS, "session.create");
         if (!sessionCreateResult.data?.id) {
@@ -30083,6 +30188,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
         const agentsResponse = await withTimeout2(client4.app.agents(), AGENTS_LIST_TIMEOUT_MS, "app.agents");
         const availableAgents = agentsResponse.data ?? [];
         const selected = selectAgent(availableAgents);
+        agentName = selected.name;
         const composedSystem = composeSystemPrompt(selected.prompt, systemPrompt);
         const modelParts = model ? parseModelId(model) : undefined;
         await withTimeout2(client4.session.promptAsync({
@@ -30114,6 +30220,8 @@ var init_opencode_sdk_agent_service = __esm(() => {
         machineId: context4.machineId,
         chatroomId: context4.chatroomId,
         role: context4.role,
+        agentName,
+        ...model ? { model } : {},
         pid,
         createdAt: new Date().toISOString(),
         baseUrl
@@ -30141,6 +30249,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
       }
       return {
         pid,
+        harnessSessionId: sessionId,
         onExit: (cb) => {
           childProcess.on("exit", (code2, signal) => {
             const fwd = this.forwarders.get(pid);
@@ -30161,6 +30270,27 @@ var init_opencode_sdk_agent_service = __esm(() => {
         }
       };
     }
+    async resumeTurn(pid, prompt) {
+      const meta = this.sessionStore.findByPid(pid);
+      if (!meta) {
+        throw new Error(`No opencode-sdk session metadata for pid=${pid}`);
+      }
+      const client4 = createOpencodeClient({ baseUrl: meta.baseUrl });
+      const modelParts = meta.model ? parseModelId(meta.model) : undefined;
+      await withTimeout2(client4.session.promptAsync({
+        path: { id: meta.sessionId },
+        body: {
+          agent: meta.agentName,
+          parts: [{ type: "text", text: prompt }],
+          ...modelParts ? { model: modelParts } : {},
+          tools: {
+            task: false,
+            question: false,
+            external_directory: false
+          }
+        }
+      }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
+    }
   };
 });
 
@@ -76596,6 +76726,30 @@ var init_fromContext4 = __esm(() => {
 // ../../services/backend/prompts/review-guidelines/index.ts
 var init_review_guidelines = () => {};
 
+// ../../services/backend/prompts/cli/resume-session/message.ts
+function composeResumeMessage(params) {
+  const cliEnvPrefix = getCliEnvPrefix(params.convexUrl);
+  const getNextTask2 = getNextTaskCommand({
+    chatroomId: params.chatroomId,
+    role: params.role,
+    cliEnvPrefix
+  });
+  const contextRead = `${cliEnvPrefix}chatroom context read --chatroom-id="${params.chatroomId}" --role="${params.role}"`;
+  return [
+    "Your previous turn has ended.",
+    "Please rejoin the chatroom and get your next task by running:",
+    `  ${getNextTask2}`,
+    "",
+    "If you need context on what you were doing, run:",
+    `  ${contextRead}`
+  ].join(`
+`);
+}
+var init_message = __esm(() => {
+  init_command();
+  init_env();
+});
+
 // ../../services/backend/prompts/generator.ts
 function generateHandoffOutput(params) {
   const { role, nextRole, chatroomId, convexUrl } = params;
@@ -76629,6 +76783,7 @@ var init_generator = __esm(() => {
   init_fromContext4();
   init_utils3();
   init_review_guidelines();
+  init_message();
 });
 
 // src/commands/handoff/index.ts
@@ -83184,6 +83339,96 @@ function resolveStopReason(code2, signal) {
   return "agent_process.crashed";
 }
 
+// ../../services/backend/src/domain/entities/harness/claude.config.ts
+var claudeCapabilities;
+var init_claude_config = __esm(() => {
+  claudeCapabilities = {
+    supportsSessionResume: false
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/commandcode.config.ts
+var commandcodeCapabilities;
+var init_commandcode_config = __esm(() => {
+  commandcodeCapabilities = {
+    supportsSessionResume: false
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/copilot.config.ts
+var copilotCapabilities;
+var init_copilot_config = __esm(() => {
+  copilotCapabilities = {
+    supportsSessionResume: false
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/cursor.config.ts
+var cursorCapabilities;
+var init_cursor_config = __esm(() => {
+  cursorCapabilities = {
+    supportsSessionResume: false
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/cursor-sdk.config.ts
+var cursorSdkCapabilities;
+var init_cursor_sdk_config = __esm(() => {
+  cursorSdkCapabilities = {
+    supportsSessionResume: true
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/opencode.config.ts
+var opencodeCapabilities;
+var init_opencode_config = __esm(() => {
+  opencodeCapabilities = {
+    supportsSessionResume: false
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/opencode-sdk.config.ts
+var opencodeSdkCapabilities;
+var init_opencode_sdk_config = __esm(() => {
+  opencodeSdkCapabilities = {
+    supportsSessionResume: true
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/pi.config.ts
+var piCapabilities;
+var init_pi_config = __esm(() => {
+  piCapabilities = {
+    supportsSessionResume: true
+  };
+});
+
+// ../../services/backend/src/domain/entities/harness/types.ts
+function getHarnessCapabilities(harness) {
+  return HARNESS_CAPABILITIES[harness];
+}
+var HARNESS_CAPABILITIES;
+var init_types = __esm(() => {
+  init_claude_config();
+  init_commandcode_config();
+  init_copilot_config();
+  init_cursor_config();
+  init_cursor_sdk_config();
+  init_opencode_config();
+  init_opencode_sdk_config();
+  init_pi_config();
+  HARNESS_CAPABILITIES = {
+    claude: claudeCapabilities,
+    commandcode: commandcodeCapabilities,
+    copilot: copilotCapabilities,
+    cursor: cursorCapabilities,
+    "cursor-sdk": cursorSdkCapabilities,
+    opencode: opencodeCapabilities,
+    "opencode-sdk": opencodeSdkCapabilities,
+    pi: piCapabilities
+  };
+});
+
 // src/infrastructure/services/remote-agents/spawn-prompt.ts
 function createSpawnPrompt(raw) {
   const trimmed = raw?.trim();
@@ -83263,6 +83508,29 @@ class AgentProcessManager {
     await operation;
     return { success: true };
   }
+  async handleAgentEnd(opts) {
+    const capabilities = getHarnessCapabilities(opts.harness);
+    console.log(`[AgentProcessManager] agent_end: role=${opts.role} pid=${opts.pid} harness=${opts.harness} wantResume=${opts.wantResume} supportsResume=${capabilities.supportsSessionResume}`);
+    if (capabilities.supportsSessionResume && opts.wantResume) {
+      const service = this.deps.agentServices.get(opts.harness);
+      if (service?.resumeTurn) {
+        try {
+          const resumePrompt = composeResumeMessage({
+            chatroomId: opts.chatroomId,
+            role: opts.role,
+            convexUrl: this.deps.convexUrl
+          });
+          await service.resumeTurn(opts.pid, resumePrompt);
+          return;
+        } catch (err) {
+          console.log(`[AgentProcessManager] ⚠️  resumeTurn failed for ${opts.role} (pid ${opts.pid}): ${err.message} — falling back to kill`);
+        }
+      }
+    }
+    try {
+      this.deps.processes.kill(-opts.pid, "SIGTERM");
+    } catch {}
+  }
   async handleExit(opts) {
     const key = agentKey2(opts.chatroomId, opts.role);
     const slot = this.slots.get(key);
@@ -83371,7 +83639,8 @@ class AgentProcessManager {
         this.slots.set(key, {
           state: "running",
           pid: entry.pid,
-          harness: entry.harness
+          harness: entry.harness,
+          wantResume: true
         });
         recovered++;
       } else {
@@ -83384,7 +83653,7 @@ class AgentProcessManager {
   getOrCreateSlot(key) {
     let slot = this.slots.get(key);
     if (!slot) {
-      slot = { state: "idle" };
+      slot = { state: "idle", wantResume: true };
       this.slots.set(key, slot);
     }
     return slot;
@@ -83424,6 +83693,8 @@ class AgentProcessManager {
   }
   async doEnsureRunning(key, slot, opts) {
     slot.state = "spawning";
+    slot.wantResume = opts.wantResume ?? true;
+    console.log(`[AgentProcessManager] harness start: role=${opts.role} harness=${opts.agentHarness} wantResume=${slot.wantResume} reason=${opts.reason}`);
     try {
       const spawnCheck = this.deps.spawning.shouldAllowSpawn(opts.chatroomId, opts.reason, {
         bypassConcurrentLimit: opts.reason.startsWith("user.")
@@ -83525,6 +83796,7 @@ class AgentProcessManager {
       slot.state = "running";
       slot.pid = pid;
       slot.harness = opts.agentHarness;
+      slot.harnessSessionId = spawnResult.harnessSessionId;
       slot.model = opts.model;
       slot.workingDir = opts.workingDir;
       slot.startedAt = this.deps.clock.now();
@@ -83554,9 +83826,13 @@ class AgentProcessManager {
       });
       if (spawnResult.onAgentEnd) {
         spawnResult.onAgentEnd(() => {
-          try {
-            this.deps.processes.kill(-pid, "SIGTERM");
-          } catch {}
+          this.handleAgentEnd({
+            chatroomId: opts.chatroomId,
+            role: opts.role,
+            pid,
+            harness: opts.agentHarness,
+            wantResume: slot.wantResume
+          });
         });
       }
       let lastReportedTokenAt = 0;
@@ -83646,6 +83922,8 @@ class AgentProcessManager {
 var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4;
 var init_agent_process_manager = __esm(() => {
   init_api3();
+  init_types();
+  init_generator();
 });
 
 // src/infrastructure/services/harness-spawning/rate-limiter.ts
@@ -86229,4 +86507,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=20A53A569D865DC964756E2164756E21
+//# debugId=2DBCEF13548BACBB64756E2164756E21