@rehpic/vcli 0.1.0-beta.102.1 → 0.1.0-beta.103.1

package/dist/index.js

@@ -1463,13 +1463,14 @@ function discoverAttachableSessions() {
     ...discoverClaudeSessions()
   ]);
 }
-async function launchProviderSession(provider, cwd, prompt2, onEvent) {
+async function launchProviderSession(provider, cwd, prompt2, onEvent, signal) {
   if (provider === "codex") {
     return runCodexAppServerTurn({
       cwd,
       prompt: prompt2,
       launchCommand: "codex app-server",
-      onEvent
+      onEvent,
+      signal
     });
   }
   if (provider === "claude_code") {
@@ -1477,7 +1478,8 @@ async function launchProviderSession(provider, cwd, prompt2, onEvent) {
       cwd,
       prompt: prompt2,
       launchCommand: "@anthropic-ai/claude-agent-sdk query()",
-      onEvent
+      onEvent,
+      signal
     });
   }
   return runGenericCliAgentTurn({
@@ -1485,17 +1487,19 @@ async function launchProviderSession(provider, cwd, prompt2, onEvent) {
     cwd,
     prompt: prompt2,
     launchCommand: genericProviderLaunchCommand(provider),
-    onEvent
+    onEvent,
+    signal
   });
 }
-async function resumeProviderSession(provider, sessionKey, cwd, prompt2, onEvent) {
+async function resumeProviderSession(provider, sessionKey, cwd, prompt2, onEvent, signal) {
   if (provider === "codex") {
     return runCodexAppServerTurn({
       cwd,
       prompt: prompt2,
       sessionKey,
       launchCommand: "codex app-server (thread/resume)",
-      onEvent
+      onEvent,
+      signal
     });
   }
   if (provider === "claude_code") {
@@ -1504,7 +1508,8 @@ async function resumeProviderSession(provider, sessionKey, cwd, prompt2, onEvent
       prompt: prompt2,
       sessionKey,
       launchCommand: "@anthropic-ai/claude-agent-sdk query(resume)",
-      onEvent
+      onEvent,
+      signal
     });
   }
   return runGenericCliAgentTurn({
@@ -1513,10 +1518,12 @@ async function resumeProviderSession(provider, sessionKey, cwd, prompt2, onEvent
     prompt: prompt2,
     sessionKey,
     launchCommand: genericProviderLaunchCommand(provider),
-    onEvent
+    onEvent,
+    signal
   });
 }
 async function runGenericCliAgentTurn(args) {
+  throwIfAborted(args.signal);
   const command = genericProviderCommand(args.provider);
   const child = spawn2(command.bin, [...command.args, args.prompt], {
     cwd: args.cwd,
@@ -1525,6 +1532,8 @@ async function runGenericCliAgentTurn(args) {
   });
   let stdout = "";
   let stderr = "";
+  const abort = () => child.kill("SIGTERM");
+  args.signal?.addEventListener("abort", abort, { once: true });
   await Promise.resolve(
     args.onEvent?.({
       provider: args.provider,
@@ -1542,7 +1551,10 @@ async function runGenericCliAgentTurn(args) {
   const exit = await new Promise((resolve, reject) => {
     child.on("error", reject);
     child.on("close", (code, signal) => resolve({ code, signal }));
+  }).finally(() => {
+    args.signal?.removeEventListener("abort", abort);
   });
+  throwIfAborted(args.signal);
   if (exit.code && exit.code !== 0) {
     const message = stderr.trim() || `${providerLabel(args.provider)} exited with code ${exit.code}`;
     await Promise.resolve(
@@ -1600,6 +1612,7 @@ function providerLabel(provider) {
   return "Pi";
 }
 async function runCodexAppServerTurn(args) {
+  throwIfAborted(args.signal);
   const child = spawn2("codex", ["app-server"], {
     cwd: args.cwd,
     env: { ...process.env },
@@ -1616,6 +1629,7 @@ async function runCodexAppServerTurn(args) {
   const pending = /* @__PURE__ */ new Map();
   let completeTurn;
   let failTurn;
+  let activeTurnId;
   const turnCompleted = new Promise((resolve, reject) => {
     completeTurn = () => {
       completed = true;
@@ -1743,6 +1757,10 @@ async function runCodexAppServerTurn(args) {
           completeTurn?.();
         }
       }
+      if (method === "turn/started") {
+        const turn = asObject(params.turn);
+        activeTurnId = asString(turn?.id) ?? asString(turn?.turnId) ?? activeTurnId;
+      }
     }
   });
   child.stderr.on("data", (chunk) => {
@@ -1758,6 +1776,17 @@ async function runCodexAppServerTurn(args) {
     child.stdin.write(`${JSON.stringify({ method, params })}
 `);
   };
+  const abort = () => {
+    if (sessionKey && activeTurnId) {
+      notify("turn/interrupt", {
+        threadId: sessionKey,
+        turnId: activeTurnId
+      });
+    }
+    child.kill("SIGTERM");
+    failTurn?.(new Error("Agent turn interrupted"));
+  };
+  args.signal?.addEventListener("abort", abort, { once: true });
   const waitForExit = new Promise((_, reject) => {
     child.on("error", (error) => reject(error));
     child.on("close", (code) => {
@@ -1809,6 +1838,7 @@ async function runCodexAppServerTurn(args) {
       }),
       waitForExit
     ]);
+    throwIfAborted(args.signal);
     await Promise.race([turnCompleted, waitForExit]);
     await Promise.allSettled(eventWrites);
     const gitInfo = getGitInfo(args.cwd);
@@ -1826,6 +1856,7 @@ async function runCodexAppServerTurn(args) {
       launchCommand: args.launchCommand
     };
   } finally {
+    args.signal?.removeEventListener("abort", abort);
     for (const entry of pending.values()) {
       entry.reject(
         new Error("codex app-server closed before request resolved")
@@ -1836,6 +1867,7 @@ async function runCodexAppServerTurn(args) {
   }
 }
 async function runClaudeSdkTurn(args) {
+  throwIfAborted(args.signal);
   const { query } = await import("@anthropic-ai/claude-agent-sdk");
   const stream = query({
     prompt: args.prompt,
@@ -1854,8 +1886,13 @@ async function runClaudeSdkTurn(args) {
   let sessionKey = args.sessionKey;
   let responseText = "";
   let model;
+  const abort = () => {
+    stream.close();
+  };
+  args.signal?.addEventListener("abort", abort, { once: true });
   try {
     for await (const message of stream) {
+      throwIfAborted(args.signal);
       if (!message || typeof message !== "object") {
         continue;
       }
@@ -1897,6 +1934,7 @@ async function runClaudeSdkTurn(args) {
       throw new Error(detail);
     }
   } finally {
+    args.signal?.removeEventListener("abort", abort);
     stream.close();
   }
   if (!sessionKey) {
@@ -1918,6 +1956,11 @@ async function runClaudeSdkTurn(args) {
     launchCommand: args.launchCommand
   };
 }
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new Error("Agent turn interrupted");
+  }
+}
 function discoverCodexSessions() {
   const historyBySession = buildCodexHistoryIndex();
   return listLiveProcessIds("codex").flatMap((pid) => {
@@ -2536,6 +2579,7 @@ var BridgeService = class {
     this.terminalPeer = null;
     this.stopping = false;
     this.runningLoops = /* @__PURE__ */ new Set();
+    this.activeAgentRuns = /* @__PURE__ */ new Map();
     this.deviceLiveActivities = [];
     this.config = config;
     this.client = new ConvexHttpClient2(config.convexUrl);
@@ -2610,14 +2654,31 @@ var BridgeService = class {
       return;
     }
     console.log(`  ${cmd.kind}: ${cmd._id}`);
+    if (cmd.kind === "launch" || cmd.kind === "message") {
+      this.runAgentCommandInBackground(cmd);
+      return;
+    }
+    await this.runClaimedCommand(cmd);
+  }
+  runAgentCommandInBackground(cmd) {
+    const runKey = this.agentRunKey(cmd);
+    const controller = new AbortController();
+    this.activeAgentRuns.set(runKey, controller);
+    void this.runClaimedCommand(cmd, controller.signal).finally(() => {
+      if (this.activeAgentRuns.get(runKey) === controller) {
+        this.activeAgentRuns.delete(runKey);
+      }
+    });
+  }
+  async runClaimedCommand(cmd, signal) {
     try {
       switch (cmd.kind) {
         case "message":
-          await this.handleMessageCommand(cmd);
+          await this.handleMessageCommand(cmd, signal);
           await this.completeCommand(cmd._id, "delivered");
           return;
         case "launch":
-          await this.handleLaunchCommand(cmd);
+          await this.handleLaunchCommand(cmd, signal);
           await this.completeCommand(cmd._id, "delivered");
           return;
         case "resize":
@@ -2629,11 +2690,18 @@ var BridgeService = class {
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown bridge error";
+      if (message === "Agent turn interrupted") {
+        await this.completeCommand(cmd._id, "delivered");
+        return;
+      }
       console.error(`  ! ${message}`);
       await this.postCommandError(cmd, message);
       await this.completeCommand(cmd._id, "failed");
     }
   }
+  agentRunKey(cmd) {
+    return cmd.liveActivityId ?? cmd.workSession?._id ?? cmd.process?._id ?? cmd._id;
+  }
   async reportProcesses() {
     const processes = discoverAttachableSessions();
     const activeSessionKeys = processes.map((proc) => proc.sessionKey).filter((value) => Boolean(value));
@@ -2894,7 +2962,7 @@ var BridgeService = class {
     await new Promise(() => {
     });
   }
-  async handleMessageCommand(cmd) {
+  async handleMessageCommand(cmd, signal) {
     if (!cmd.liveActivityId) {
       throw new Error("Message command is missing liveActivityId");
     }
@@ -2970,7 +3038,8 @@ var BridgeService = class {
       (event) => {
         if (event.role === "assistant") emittedAssistantEvent = true;
         return this.postAgentSessionEvent(liveActivityId, event);
-      }
+      },
+      signal
     );
     const processId = await this.reportProcess(result);
     if (result.responseText && !emittedAssistantEvent) {
@@ -3031,14 +3100,17 @@ var BridgeService = class {
       return;
     }
     if (cmd.kind === "stop") {
+      const runKey = this.agentRunKey(cmd);
+      const activeRun = this.activeAgentRuns.get(runKey);
+      activeRun?.abort();
       await this.updateLiveActivity(cmd.liveActivityId, {
         status: "paused",
-        latestSummary: "Agent turn stop requested"
+        latestSummary: activeRun ? "Agent turn paused" : "Agent turn stop requested"
       });
       await this.postAgentMessage(
         cmd.liveActivityId,
         "status",
-        "Stop requested for the local agent session"
+        activeRun ? "Paused the local agent session" : "Stop requested for the local agent session"
       );
       return;
     }
@@ -3056,7 +3128,7 @@ var BridgeService = class {
       `Received ${label}; the provider runtime will continue when supported`
     );
   }
-  async handleLaunchCommand(cmd) {
+  async handleLaunchCommand(cmd, signal) {
     if (!cmd.liveActivityId) {
       throw new Error("Launch command is missing liveActivityId");
     }
@@ -3120,7 +3192,8 @@ var BridgeService = class {
         provider,
         workspacePath,
         prompt2,
-        (event) => this.postAgentSessionEvent(liveActivityId, event)
+        (event) => this.postAgentSessionEvent(liveActivityId, event),
+        signal
       );
       const processId = await this.reportProcess(result);
       await this.refreshWorkSessionTerminal(cmd.workSession?._id, {