chatroom-cli 1.61.1 → 1.61.3

package/dist/index.js

@@ -29106,6 +29106,7 @@ var init_claude_sdk_stream_adapter = __esm(() => {
 });
 
 // src/infrastructure/services/remote-agents/claude-sdk/claude-sdk-agent-service.ts
+import { randomUUID } from "node:crypto";
 async function loadSdk() {
   if (_sdkCache)
     return _sdkCache;
@@ -29157,9 +29158,24 @@ function writeSpawnError(logPrefix, err, emitLogLine) {
   emitLogLine?.(line);
   console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
 }
-function captureSessionId(message, session2) {
-  if ("session_id" in message && typeof message.session_id === "string") {
-    session2.sessionId = message.session_id;
+function notifyResumableSessionId(message, session2, correlationId, callbacks) {
+  if (!("session_id" in message) || typeof message.session_id !== "string") {
+    return;
+  }
+  const resumableId = message.session_id;
+  const previousResumableId = session2.sessionId;
+  if (previousResumableId === resumableId) {
+    return;
+  }
+  session2.sessionId = resumableId;
+  const info = {
+    correlationId,
+    resumableId,
+    source: previousResumableId ? "provider_rotated" : "provider_allocated",
+    ...previousResumableId ? { previousResumableId } : {}
+  };
+  for (const cb of callbacks) {
+    cb(info);
   }
 }
 var CLAUDE_SDK_COMMAND = "claude-sdk", DEFAULT_MAX_TURNS2 = 200, TURN_TIMEOUT_MS = 3600000, _sdkCache, _sdkLoadError, cachedSdkPackageVersion, ClaudeSdkAgentService;
@@ -29263,14 +29279,16 @@ var init_claude_sdk_agent_service = __esm(() => {
         initialPrompt,
         deferInitialTurn = false,
         storedSystemPrompt,
-        executablePath
+        executablePath,
+        resumedProviderSessionId
       } = args2;
       const entry = this.registerProcess(pid, context5);
       const logPrefix = buildAgentLogPrefix("claude-sdk", context5);
       const sdkSession = {
         keeper,
         aborted: false,
-        storedSystemPrompt
+        storedSystemPrompt,
+        ...resumedProviderSessionId ? { sessionId: resumedProviderSessionId, resumeOnFirstQuery: true } : {}
       };
       this.sessions.set(pid, sdkSession);
       const exitCallbacks = [];
@@ -29278,10 +29296,12 @@ var init_claude_sdk_agent_service = __esm(() => {
       const agentEndCallbacks = [];
       const logLineCallbacks = [];
       const assistantTextCallbacks = [];
+      const sessionIdUpdatedCallbacks = [];
       const emitLogLine = (line) => {
         for (const cb of logLineCallbacks)
           cb(line);
       };
+      const harnessSessionId = randomUUID();
       const finishExit = (code2, signal) => {
         sdkSession.activeQuery = undefined;
         this.sessions.delete(pid);
@@ -29292,6 +29312,8 @@ var init_claude_sdk_agent_service = __esm(() => {
       };
       this.runTurnLoop({
         sdkSession,
+        correlationId: harnessSessionId,
+        sessionIdUpdatedCallbacks,
         entry,
         logPrefix,
         workingDir,
@@ -29307,7 +29329,7 @@ var init_claude_sdk_agent_service = __esm(() => {
       });
       return {
         pid,
-        harnessSessionId: undefined,
+        harnessSessionId,
         onExit: (cb) => {
           exitCallbacks.push(cb);
         },
@@ -29322,12 +29344,24 @@ var init_claude_sdk_agent_service = __esm(() => {
         },
         onAssistantText: (cb) => {
           assistantTextCallbacks.push(cb);
+        },
+        onHarnessSessionIdUpdated: (cb) => {
+          sessionIdUpdatedCallbacks.push(cb);
+          if (resumedProviderSessionId) {
+            cb({
+              correlationId: harnessSessionId,
+              resumableId: resumedProviderSessionId,
+              source: "provider_allocated"
+            });
+          }
         }
       };
     }
     runTurnLoop(args2) {
       const {
         sdkSession,
+        correlationId,
+        sessionIdUpdatedCallbacks,
         logPrefix,
         workingDir,
         model,
@@ -29344,6 +29378,8 @@ var init_claude_sdk_agent_service = __esm(() => {
       let exited = false;
       this.executeTurnLoop({
         sdkSession,
+        correlationId,
+        sessionIdUpdatedCallbacks,
         logPrefix,
         workingDir,
         model,
@@ -29374,6 +29410,8 @@ var init_claude_sdk_agent_service = __esm(() => {
     async executeTurnLoop(args2) {
       const {
         sdkSession,
+        correlationId,
+        sessionIdUpdatedCallbacks,
         logPrefix,
         workingDir,
         model,
@@ -29416,6 +29454,7 @@ var init_claude_sdk_agent_service = __esm(() => {
               agentEndCallbacks,
               entry
             });
+            const useResume = Boolean(sdkSession.sessionId) && (!isFirstQuery || sdkSession.resumeOnFirstQuery === true);
             const queryInstance = query({
               prompt: nextPrompt,
               options: {
@@ -29424,19 +29463,25 @@ var init_claude_sdk_agent_service = __esm(() => {
                 maxTurns: DEFAULT_MAX_TURNS2,
                 pathToClaudeCodeExecutable: executablePath,
                 includePartialMessages: true,
-                systemPrompt: isFirstQuery ? sdkSession.storedSystemPrompt : undefined,
-                resume: !isFirstQuery ? sdkSession.sessionId : undefined,
-                settingSources: []
+                systemPrompt: isFirstQuery && !sdkSession.resumeOnFirstQuery ? sdkSession.storedSystemPrompt : undefined,
+                resume: useResume ? sdkSession.sessionId : undefined,
+                settingSources: [],
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+                canUseTool: async (_toolName, input) => ({ behavior: "allow", updatedInput: input })
               }
             });
             sdkSession.activeQuery = queryInstance;
+            if (sdkSession.resumeOnFirstQuery) {
+              sdkSession.resumeOnFirstQuery = false;
+            }
             isFirstQuery = false;
             nextPrompt = null;
             await withTimeout((async () => {
               for await (const message of queryInstance) {
                 if (sdkSession.aborted)
                   break;
-                captureSessionId(message, sdkSession);
+                notifyResumableSessionId(message, sdkSession, correlationId, sessionIdUpdatedCallbacks);
                 adapter.handleMessage(message);
                 if (message.type === "result")
                   break;
@@ -29495,6 +29540,30 @@ var init_claude_sdk_agent_service = __esm(() => {
         executablePath
       });
     }
+    async resumeFromDaemonMemory(options, stored) {
+      try {
+        const keeper = this.spawnKeeper(stored.workingDir);
+        const pid = keeper.pid;
+        await loadSdk();
+        const executablePath = await resolvePathToClaudeCodeExecutable();
+        return this.startRunningSession({
+          pid,
+          keeper,
+          context: options.context,
+          workingDir: stored.workingDir,
+          model: options.model ?? stored.model,
+          initialPrompt: options.prompt,
+          deferInitialTurn: false,
+          storedSystemPrompt: options.systemPrompt,
+          executablePath,
+          resumedProviderSessionId: stored.harnessSessionId
+        });
+      } catch (err) {
+        writeSpawnError(buildAgentLogPrefix("claude-sdk", options.context), err, (line) => process.stderr.write(`${line}
+`));
+        return this.spawn(options);
+      }
+    }
   };
 });
 
@@ -29911,7 +29980,7 @@ var init_cursor_sdk_stream_adapter = __esm(() => {
 });
 
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-agent-service.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 async function loadSdk2() {
   if (_sdkCache2)
     return _sdkCache2;
@@ -30260,7 +30329,7 @@ ${deferredResume}` : deferredResume;
               }
               const run3 = await withTimeout(agent.send(nextPrompt, {
                 local: { force: isFirstTurn },
-                idempotencyKey: randomUUID()
+                idempotencyKey: randomUUID2()
               }), SEND_TIMEOUT_MS, "agent.send");
               session2.run = run3;
               isFirstTurn = false;
@@ -34092,7 +34161,7 @@ var init_detection = __esm(() => {
 var MACHINE_CONFIG_VERSION = "1";
 
 // src/infrastructure/machine/storage.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import * as fs4 from "node:fs/promises";
 import { homedir as homedir3, hostname as hostname2 } from "node:os";
 import { join as join11 } from "node:path";
@@ -34149,7 +34218,7 @@ async function createNewEndpointConfig() {
   const now = new Date().toISOString();
   const availableHarnesses = await detectAvailableHarnesses();
   return {
-    machineId: randomUUID2(),
+    machineId: randomUUID3(),
     hostname: hostname2(),
     os: process.platform,
     registeredAt: now,
@@ -77106,7 +77175,7 @@ var claudeSdkCapabilities;
 var init_claude_sdk_config = __esm(() => {
   claudeSdkCapabilities = {
     runtimeKind: "sdk",
-    supportsDaemonMemoryResume: false,
+    supportsDaemonMemoryResume: true,
     supportsNativeIntegration: true,
     lifecycle: {
       turnCompleted: true,
@@ -82506,7 +82575,7 @@ var init_pid = __esm(() => {
 });
 
 // src/infrastructure/harnesses/cursor-sdk/cursor-session.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 class CursorSdkSession {
   opencodeSessionId;
@@ -82533,13 +82602,13 @@ class CursorSdkSession {
       throw new Error("Session is closed");
     const text = input.parts.map((p) => p.text).join(`
 `);
-    const messageId = randomUUID3();
+    const messageId = randomUUID4();
     const isFirstTurn = this.turnCount === 0;
     this.turnCount += 1;
     const modelId = input.model ? resolveModelFromPrompt(input.model.providerID, input.model.modelID) : undefined;
     const run3 = await withTimeout(this.agent.send(text, {
       local: { force: isFirstTurn },
-      idempotencyKey: randomUUID3(),
+      idempotencyKey: randomUUID4(),
       ...modelId ? { model: { id: modelId } } : {}
     }), SEND_TIMEOUT_MS2, "agent.send");
     for await (const message of run3.stream()) {
@@ -83308,7 +83377,7 @@ var init_opencode_harness = __esm(() => {
 });
 
 // src/infrastructure/harnesses/pi-sdk/pi-session.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 class PiSdkSession {
   opencodeSessionId;
@@ -83335,7 +83404,7 @@ class PiSdkSession {
       throw new Error("Session is closed");
     const text = input.parts.map((p) => p.text).join(`
 `);
-    const messageId = randomUUID4();
+    const messageId = randomUUID5();
     const onSessionEvent = (event) => {
       if (this.closed)
         return;
@@ -86685,6 +86754,11 @@ var init_native_task_delivery_coordinator = __esm(() => {
   init_convex_error();
 });
 
+// src/domain/agent-lifecycle/resolve-resumable-harness-session-id.ts
+function resolveResumableHarnessSessionId(snapshot) {
+  return snapshot.resumableHarnessSessionId ?? snapshot.harnessSessionId;
+}
+
 // src/domain/agent-lifecycle/entities/stop-reason.ts
 function resolveStopReason(code2, signal) {
   if (signal !== null)
@@ -87440,6 +87514,7 @@ class AgentProcessManager {
         pid: slot.pid,
         harness: slot.harness,
         harnessSessionId: slot.harnessSessionId,
+        resumableHarnessSessionId: slot.resumableHarnessSessionId,
         model: slot.model,
         workingDir: slot.workingDir,
         startedAt: slot.startedAt,
@@ -87462,6 +87537,7 @@ class AgentProcessManager {
       slot.pid = undefined;
       slot.harness = undefined;
       slot.harnessSessionId = undefined;
+      slot.resumableHarnessSessionId = undefined;
       slot.model = undefined;
       slot.workingDir = undefined;
       slot.startedAt = undefined;
@@ -87689,6 +87765,7 @@ class AgentProcessManager {
       model: slot.model,
       workingDir: slot.workingDir,
       harnessSessionId: slot.harnessSessionId,
+      resumableHarnessSessionId: slot.resumableHarnessSessionId,
       wantResume: slot.wantResume,
       recentLogLines: slot.recentLogLines,
       stopReason,
@@ -87700,6 +87777,7 @@ class AgentProcessManager {
     const harnessMeta = service3 && slot.pid ? this.readHarnessReconnectMetadata(service3, slot.pid) : undefined;
     this.recordLastHarnessSession(key, {
       harnessSessionId,
+      resumableHarnessSessionId: ctx.resumableHarnessSessionId,
       harness,
       agentName: harnessMeta?.agentName ?? "",
       workingDir: ctx.workingDir ?? "",
@@ -87836,7 +87914,8 @@ class AgentProcessManager {
           this.clearHarnessSessionAfterResumePhaseFailure(key, opts);
         }
         const wantResume = this.resolveCursorSdkReopenWantResume(hadRunError, attempt, ctx);
-        const storedSessionId = this.lastHarnessSessions.get(key)?.harnessSessionId;
+        const stored = this.lastHarnessSessions.get(key);
+        const storedSessionId = stored ? resolveResumableHarnessSessionId(stored) : undefined;
         await this.emitSessionReopenRetry(opts.chatroomId, opts.role, attempt, attempt > 1 ? lastError : undefined, storedSessionId);
         const result = await this.ensureRunning({
           chatroomId: opts.chatroomId,
@@ -88086,7 +88165,8 @@ class AgentProcessManager {
       return null;
     }
     try {
-      await this.emitSessionResumeRequested(opts.chatroomId, opts.role, opts.agentHarness, stored.harnessSessionId);
+      const resumableId = resolveResumableHarnessSessionId(stored);
+      await this.emitSessionResumeRequested(opts.chatroomId, opts.role, opts.agentHarness, resumableId);
       const spawnResult = await opts.service.resumeFromDaemonMemory({
         workingDir: stored.workingDir,
         prompt: createSpawnPrompt(opts.initPrompt),
@@ -88099,17 +88179,17 @@ class AgentProcessManager {
         },
         resolvedConvexUrl: this.deps.convexUrl
       }, {
-        harnessSessionId: stored.harnessSessionId,
+        harnessSessionId: resumableId,
         agentName: stored.agentName,
         workingDir: stored.workingDir,
         model: stored.model
       });
-      await this.emitSessionResumed(opts.chatroomId, opts.role, stored.harnessSessionId);
+      await this.emitSessionResumed(opts.chatroomId, opts.role, resumableId);
       return spawnResult;
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
       this.clearLastHarnessSession(opts.key);
-      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, reason, stored.harnessSessionId);
+      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, reason, resolveResumableHarnessSessionId(stored));
       return null;
     }
   }
@@ -88120,16 +88200,16 @@ class AgentProcessManager {
     }
     if (stored.workingDir !== opts.workingDir) {
       this.clearLastHarnessSession(opts.key);
-      this.emitSessionResumeFailed(opts.chatroomId, opts.role, "working directory changed", stored.harnessSessionId);
+      this.emitSessionResumeFailed(opts.chatroomId, opts.role, "working directory changed", resolveResumableHarnessSessionId(stored));
       return "working directory changed";
     }
     if (stored.harness !== opts.agentHarness || !stored.agentName) {
       this.clearLastHarnessSession(opts.key);
-      this.emitSessionResumeFailed(opts.chatroomId, opts.role, stored.harness !== opts.agentHarness ? "harness changed" : "incomplete session in daemon memory", stored.harnessSessionId);
+      this.emitSessionResumeFailed(opts.chatroomId, opts.role, stored.harness !== opts.agentHarness ? "harness changed" : "incomplete session in daemon memory", resolveResumableHarnessSessionId(stored));
       return "validation failed";
     }
     if (!opts.service.resumeFromDaemonMemory) {
-      this.emitSessionResumeFailed(opts.chatroomId, opts.role, "daemon-memory session resume not yet supported", stored.harnessSessionId);
+      this.emitSessionResumeFailed(opts.chatroomId, opts.role, "daemon-memory session resume not yet supported", resolveResumableHarnessSessionId(stored));
       return "not supported";
     }
     return null;
@@ -88195,6 +88275,36 @@ class AgentProcessManager {
       console.log(`   ⚠️  Failed to emit sessionReopenRetry event: ${err.message}`);
     }
   }
+  applyHarnessSessionIdUpdate(key, slot, chatroomId, role, info) {
+    if (!slot.harnessSessionId || slot.harnessSessionId !== info.correlationId) {
+      return;
+    }
+    slot.resumableHarnessSessionId = info.resumableId;
+    const stored = this.lastHarnessSessions.get(key);
+    if (stored?.harnessSessionId === info.correlationId) {
+      this.recordLastHarnessSession(key, {
+        ...stored,
+        resumableHarnessSessionId: info.resumableId
+      });
+    }
+    this.emitHarnessSessionIdUpdated(chatroomId, role, info);
+  }
+  async emitHarnessSessionIdUpdated(chatroomId, role, info) {
+    try {
+      await this.deps.backend.mutation(api.machines.emitHarnessSessionIdUpdated, {
+        sessionId: this.deps.sessionId,
+        machineId: this.deps.machineId,
+        chatroomId,
+        role,
+        correlationId: info.correlationId,
+        ...info.previousResumableId ? { previousResumableId: info.previousResumableId } : {},
+        resumableId: info.resumableId,
+        source: info.source
+      });
+    } catch (err) {
+      console.log(`   ⚠️  Failed to emit harnessSessionIdUpdated event: ${err.message}`);
+    }
+  }
   resetSlotIdle(slot) {
     slot.state = "idle";
     slot.pendingOperation = undefined;
@@ -88337,9 +88447,11 @@ class AgentProcessManager {
     slot.pid = pid;
     slot.harness = opts.agentHarness;
     slot.harnessSessionId = spawnResult.harnessSessionId;
+    slot.resumableHarnessSessionId = undefined;
     if (spawnResult.harnessSessionId) {
       this.recordLastHarnessSession(key, {
         harnessSessionId: spawnResult.harnessSessionId,
+        resumableHarnessSessionId: undefined,
         harness: opts.agentHarness,
         agentName: spawnResult.harnessReconnect?.agentName ?? "",
         workingDir: opts.workingDir,
@@ -88391,6 +88503,12 @@ class AgentProcessManager {
         }));
       });
     }
+    if (spawnResult.onHarnessSessionIdUpdated) {
+      spawnResult.onHarnessSessionIdUpdated((info) => {
+        const slotKey = agentKey3(opts.chatroomId, opts.role);
+        this.applyHarnessSessionIdUpdate(slotKey, slot, opts.chatroomId, opts.role, info);
+      });
+    }
     let lastReportedTokenAt = 0;
     spawnResult.onOutput(() => {
       const now = this.deps.clock.now();
@@ -88477,6 +88595,7 @@ class AgentProcessManager {
     const harnessMeta = service3 ? this.readHarnessReconnectMetadata(service3, pid) : undefined;
     this.recordLastHarnessSession(key, {
       harnessSessionId: slot.harnessSessionId,
+      resumableHarnessSessionId: slot.resumableHarnessSessionId,
       harness,
       agentName: harnessMeta?.agentName ?? "",
       workingDir: slot.workingDir ?? "",
@@ -107736,4 +107855,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=7B9AE1A5001DAD3964756E2164756E21
+//# debugId=6FC50BA17F0D043E64756E2164756E21