@skaile/workspaces 2.4.0 → 2.5.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 2.5.0
+
+### Minor Changes
+
+- [#500](https://github.com/skaile-ai/workspaces/pull/500) [`5104b98`](https://github.com/skaile-ai/workspaces/commit/5104b980e3e7243f19142079257c5fc42be20722) Thanks [@peteralbert](https://github.com/peteralbert)! - Protocol 3.8 — acknowledge receipt of a prompt
+
+  `prompt` was the only frame in the protocol with no acknowledgement. A host sent
+  it into the socket and got nothing back, so a runner that had stopped executing
+  while its WebSocket stayed open (an in-container OOM is enough) swallowed every
+  subsequent user message with no trace anywhere: no log, no event, no failed
+  send. The host had no way to distinguish "delivered, still thinking" from "never
+  arrived".
+
+  The `prompt` command gains an optional `messageId`. When it is set the runner
+  emits exactly one new `prompt_ack` event echoing it back, as the **first act** of
+  `handlePrompt` — before `awaitSessionReadyOrFail()` (which drops prompts
+  silently), before the secrets check, and before the driver starts. When it is
+  absent nothing is emitted, so a 3.7 host sees byte-identical behaviour, and a
+  3.8 host talking to a 3.7 runner must feature-detect on
+  `major === 3 && minor >= 8` rather than read the missing ack as a lost prompt.
+
+  The ack is deliberately receipt-only: it says the frame arrived and was decoded,
+  never that the turn ran. A driver that accepts a prompt and then leaves the turn
+  promise pending is a separate failure mode and needs turn-level supervision.
+
+  `prompt_ack` is transient — system RPC, not chat. It is on the dispatcher's
+  denylist so it is never persisted (an unlisted ack would also split the
+  assistant's streaming bubble mid-turn).
+
+### Patch Changes
+
+- [#501](https://github.com/skaile-ai/workspaces/pull/501) [`1076360`](https://github.com/skaile-ai/workspaces/commit/107636009ebbbfeb7d82b93a2a8633f84dfc59b6) Thanks [@peteralbert](https://github.com/peteralbert)! - Fix `ClaudeSdkDriver` so aborting a turn (Stop) actually kills an in-flight
+  tool subprocess (e.g. a running Bash command) instead of leaving it orphaned.
+  `query.close()` only tore down the SDK's connection to the CLI subprocess, not
+  whatever process that CLI in turn spawned for the tool call, and a
+  process-group signal to the CLI didn't reach it either since the CLI spawns
+  the tool's shell into its own new process group. The driver now captures the
+  CLI subprocess's own OS pid via `spawnClaudeCodeProcess`, snapshots its
+  descendant processes before sending any abort signal (reparenting on exit
+  would otherwise make a post-abort snapshot come back empty), and SIGKILLs
+  that snapshot from `abort()` and `kill()` alike.
+
 ## 2.4.0
 
 ### Minor Changes

package/dist/app-sdk/index.js

@@ -1,4 +1,4 @@
-import { PROTOCOL_VERSION_STRING } from '../chunk-RDE43ORT.js';
+import { PROTOCOL_VERSION_STRING } from '../chunk-D4VHBAJC.js';
 import '../chunk-NSBPE2FW.js';
 import * as z from 'zod';
 

package/dist/bridge/drivers/claude-sdk.js

@@ -2,7 +2,7 @@ import { SUPPORTED_CLOUDS, buildClaudeCloudEnv } from '../../chunk-ISQWMBKD.js';
 import { dispatchCapability } from '../../chunk-RRVQAE5D.js';
 import { fetchProviderModels } from '../../chunk-BMQKMOQY.js';
 import { AuthError, classifyClaudeSdkError, reclassifyAuthAsAccountUnavailable, AccountUnavailableError } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-GM2X24Q6.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-HY3MBSNC.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-P43HBWKK.js';
 import '../../chunk-F3HNW354.js';
@@ -17,8 +17,8 @@ import '../../chunk-GEEW6SY2.js';
 import '../../chunk-U5POE4BA.js';
 import '../../chunk-7GOCNYUV.js';
 import '../../chunk-NSBPE2FW.js';
-import { spawnSync } from 'child_process';
-import { existsSync, createReadStream, createWriteStream } from 'fs';
+import { spawnSync, spawn } from 'child_process';
+import { readFileSync, existsSync, createReadStream, createWriteStream } from 'fs';
 import { createRequire } from 'module';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -393,6 +393,12 @@ var ClaudeSdkDriver = class extends AgentDriver {
   suppressingAuthStream = false;
   /** Active query — may stay alive between turns if streamInput works. */
   query = null;
+  /**
+   * OS pid of the CLI subprocess backing `query`, captured via
+   * `spawnClaudeCodeProcess` in {@link startQuery}. Feeds
+   * {@link snapshotDescendantPids}; see `_devlog/notes/2026-08-12-abort-kills-tool-subprocess.md`.
+   */
+  cliProcessPid = null;
   /** Resolves when the current turn completes. */
   turnResolve = null;
   /** Rejects when the current turn errors. */
@@ -629,7 +635,9 @@ var ClaudeSdkDriver = class extends AgentDriver {
   onTurnStalled(idleMs) {
     const idle = idleMs < 6e4 ? `${Math.round(idleMs / 1e3)}s` : `${Math.round(idleMs / 6e4)}m`;
     this.log.error("turn stalled \u2014 no SDK message received; resetting the query", { idleMs });
+    const descendants = this.snapshotDescendantPids();
     this.hardResetQuery();
+    this.killPids(descendants);
     this.failTurn(
       new Error(
         `Agent stalled: no response from the model process for ${idle}. The conversation is intact \u2014 send your message again.`
@@ -642,6 +650,10 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * Deliberately does NOT clear `sessionId` / `hasSession` — the next
    * `startQuery()` must resume the same SDK session so the conversation
    * survives. That is what separates this from {@link kill}.
+   *
+   * Does NOT sweep the CLI's descendant processes — callers needing that must
+   * snapshot via {@link snapshotDescendantPids} *before* this (and any other
+   * abort signal) runs, then {@link killPids} after.
    */
   hardResetQuery() {
     if (this.query) {
@@ -653,6 +665,60 @@ var ClaudeSdkDriver = class extends AgentDriver {
     }
     this.abortController?.abort();
   }
+  /**
+   * Capture every current OS descendant of the CLI subprocess (SIGKILLed
+   * later via {@link killPids}). **Call BEFORE `interrupt()` /
+   * `abortController.abort()` / `query.close()` — never after**: once the CLI
+   * exits, Linux reparents its children immediately, so a later walk finds
+   * nothing. Linux-only; `[]` if there's no captured pid or no `/proc`. Full
+   * rationale: `_devlog/notes/2026-08-12-abort-kills-tool-subprocess.md`.
+   */
+  snapshotDescendantPids() {
+    const rootPid = this.cliProcessPid;
+    if (rootPid == null) return [];
+    return this.collectDescendantPids(rootPid);
+  }
+  /** SIGKILL every pid in a snapshot from {@link snapshotDescendantPids}. */
+  killPids(pids) {
+    if (pids.length === 0) return;
+    let killed = 0;
+    for (const pid of pids) {
+      try {
+        process.kill(pid, "SIGKILL");
+        killed++;
+      } catch {
+      }
+    }
+    this.log.info("swept CLI descendant processes on abort", {
+      attempted: pids.length,
+      killed
+    });
+  }
+  /** Direct children of `pid` via Linux procfs — no external binary required. */
+  childPids(pid) {
+    try {
+      const raw = readFileSync(`/proc/${pid}/task/${pid}/children`, "utf8");
+      return raw.trim().split(/\s+/).filter(Boolean).map(Number);
+    } catch {
+      return [];
+    }
+  }
+  /** Every descendant of `rootPid` (excluding `rootPid` itself), breadth-first. */
+  collectDescendantPids(rootPid) {
+    const descendants = [];
+    let frontier = [rootPid];
+    while (frontier.length > 0) {
+      const next = [];
+      for (const pid of frontier) {
+        for (const child of this.childPids(pid)) {
+          descendants.push(child);
+          next.push(child);
+        }
+      }
+      frontier = next;
+    }
+    return descendants;
+  }
   /**
    * Side-effects of the stale-resume recovery path: emit the resume-outcome and
    * non-fatal error events, then reset session state so the recursive prompt()
@@ -850,6 +916,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     const apiKey = cloud === "default" ? this.config.apiKeys?.anthropic || this.config.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY : void 0;
     this.usingOauthCredential = cloud === "default" && !apiKey;
     const claudePath = this.findClaudeBinary();
+    const onStderr = (data) => this.log.warn("claude stderr", { line: data.trim() });
     const options = {
       cwd: this.config.cwd,
       // Load project + user settings so .claude/skills/ are discovered
@@ -872,7 +939,29 @@ var ClaudeSdkDriver = class extends AgentDriver {
       // Reasoning effort — passed directly to the SDK
       ...this.config.effort ? { effort: this.config.effort } : {},
       hooks: {},
-      stderr: (data) => this.log.warn("claude stderr", { line: data.trim() }),
+      stderr: onStderr,
+      // Spawn the CLI ourselves to capture its OS pid for snapshotDescendantPids()
+      // (Query never exposes it otherwise). This replaces the SDK's own default
+      // spawn, so we also have to re-wire child.stderr -> onStderr ourselves below.
+      spawnClaudeCodeProcess: (spawnOpts) => {
+        const child = spawn(spawnOpts.command, spawnOpts.args, {
+          cwd: spawnOpts.cwd,
+          env: spawnOpts.env,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        this.cliProcessPid = child.pid ?? null;
+        child.stderr?.on("data", (chunk) => onStderr(chunk.toString()));
+        child.once("exit", () => {
+          if (this.cliProcessPid === child.pid) this.cliProcessPid = null;
+        });
+        spawnOpts.signal.addEventListener("abort", () => {
+          try {
+            child.kill();
+          } catch {
+          }
+        });
+        return child;
+      },
       ...claudePath ? { pathToClaudeCodeExecutable: claudePath } : {},
       ...this.config.systemPrompt ? {
         systemPrompt: {
@@ -1542,6 +1631,10 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * Requests the current SDK query to stop processing via `query.interrupt()` and
    * signals the underlying `AbortController`. The driver remains usable after abort.
    *
+   * Also SIGKILLs every OS descendant of the CLI subprocess (e.g. a running
+   * Bash command) on either path the turn ends — see
+   * {@link snapshotDescendantPids}'s doc for why that's needed.
+   *
    * @remarks Best-effort: if `interrupt()` throws (e.g. query already ended) the
    *   error is silently swallowed and the abort signal is still sent. A query
    *   whose generator refuses to unwind within {@link ABORT_GRACE_MS} is torn
@@ -1551,6 +1644,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     this.denyPendingQuestion("turn aborted before the question was answered");
     const abortedQuery = this.query;
     const abortedController = this.abortController;
+    const descendants = this.snapshotDescendantPids();
     if (abortedQuery) {
       try {
         await abortedQuery.interrupt();
@@ -1569,6 +1663,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       this.hardResetQuery();
       this.completeTurn();
     }
+    this.killPids(descendants);
   }
   /** `true` while the driver is processing a `prompt()` call. */
   get isRunning() {
@@ -1579,9 +1674,14 @@ var ClaudeSdkDriver = class extends AgentDriver {
    *
    * The driver instance must not be reused after `kill()`. Session IDs are cleared,
    * so a new `ClaudeSdkDriver` will start a fresh session.
+   *
+   * Also SIGKILLs every OS descendant of the CLI subprocess (e.g. a running
+   * Bash command) — see {@link snapshotDescendantPids}'s doc for why that
+   * needs to be snapshotted before `query.close()` runs, not after.
    */
   kill() {
     this.denyPendingQuestion("session terminated before the question was answered");
+    const descendants = this.snapshotDescendantPids();
     if (this.query) {
       try {
         this.query.close();
@@ -1590,6 +1690,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       this.query = null;
     }
     this.abortController?.abort();
+    this.killPids(descendants);
     this.running = false;
     this.sessionId = "";
     this.hasSession = false;
@@ -1609,6 +1710,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
   }
   async resetSession() {
     this.denyPendingQuestion("session reset before the question was answered");
+    const descendants = this.snapshotDescendantPids();
     if (this.query) {
       try {
         this.query.close();
@@ -1617,6 +1719,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       this.query = null;
     }
     this.abortController?.abort();
+    this.killPids(descendants);
     this.sessionId = "";
     this.hasSession = false;
     this._lastTokens = null;