commonswarm 0.1.26 → 0.1.27

package/cswarm.cjs

@@ -28550,12 +28550,12 @@ function parseRetryAfterMs(header, nowMs = Date.now()) {
   if (!Number.isFinite(when)) return null;
   return Math.max(0, Math.min(when - nowMs, SIGNAL_FOLLOW_BACKOFF_MAX_MS));
 }
-function throwSignalHttp(response, body) {
+function throwSignalHttp(response, body, failure = "signal read failed") {
   const status = response.status;
   const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
   const envelope = parseServerErrorEnvelope(body);
   const error = new Error(
-    describeServerError(`signal read failed (HTTP ${status})`, envelope)
+    describeServerError(`${failure} (HTTP ${status})`, envelope)
   );
   plainHttpStatus.set(error, status);
   plainHttpRetryAfterMs.set(error, retryAfterMs);
@@ -28912,7 +28912,7 @@ async function readAgentSignalDirectory(target2, token, workspaceId2, fetcherOrO
   }
   const { response, body } = result;
   if (!response.ok) {
-    throw new Error(`member read failed (HTTP ${response.status})`);
+    throwSignalHttp(response, body, "member read failed");
   }
   if (!body || typeof body !== "object" || Array.isArray(body)) {
     throw new Error("member read returned malformed JSON");
@@ -29130,6 +29130,37 @@ function postSignalTargets(recipient) {
   };
 }
 var ASK_WAIT_TIMEOUT_MESSAGE = "Ask shared. No reply arrived before the wait ended; the ask remains live. Check for a reply with: cswarm inbox";
+function askFailureDetail(error) {
+  const readHttp = followHttpDetails(error);
+  if (readHttp !== null) {
+    return {
+      detail: describeServerError(
+        `HTTP ${readHttp.status}`,
+        followErrorEnvelope(error)
+      ),
+      serverError: true
+    };
+  }
+  if (error instanceof CommandHttpError) {
+    return {
+      detail: `HTTP ${error.status}; server detail: ${error.message.replace(/^signal read failed \(HTTP \d+\)(?:: )?/, "").slice(0, 240)}`,
+      serverError: true
+    };
+  }
+  return {
+    detail: error instanceof Error ? error.message.slice(0, 300) : "unknown error",
+    serverError: false
+  };
+}
+function askCreateFailureMessage(workspaceId2, error) {
+  const failure = askFailureDetail(error);
+  const cause = failure.serverError ? `server error before it was confirmed: ${failure.detail}` : `request failure before it was confirmed: ${failure.detail}`;
+  return `Your message may not have been posted (${cause}). Check with: cswarm feed --workspace-id ${workspaceId2} \u2014 and resend if it is not there.`;
+}
+function askReplyReadFailureMessage(workspaceId2, error) {
+  const failure = askFailureDetail(error);
+  return `Your message was posted, but its reply could not be fetched (${failure.detail}). Do not resend this ask. Check with: cswarm inbox --workspace-id ${workspaceId2}`;
+}
 function renderSignals(signals, options) {
   if (signals.length === 0) {
     return [
@@ -29763,6 +29794,18 @@ var AcpVersionError = class extends AcpHostError {
     this.name = "AcpVersionError";
   }
 };
+var AcpVersionMismatchError = class extends AcpVersionError {
+  constructor(expected, actual) {
+    super(
+      `refusing claude-agent-acp ${actual}; host core is measured for ${expected} only`
+    );
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "AcpVersionMismatchError";
+  }
+  expected;
+  actual;
+};
 var AcpPermissionCanaryError = class extends AcpHostError {
   constructor(message) {
     super("permission_canary_failed", message);
@@ -29800,11 +29843,26 @@ var AcpTransport = class extends import_node_events.EventEmitter {
     this.writable = options.writable;
     this.handlers = options.handlers ?? {};
     this.requestTimeoutMs = options.requestTimeoutMs ?? ACP_DEFAULT_REQUEST_TIMEOUT_MS;
+    const readableEndGraceMs = Math.max(0, options.readableEndGraceMs ?? 0);
+    let readableEndTimer = null;
     options.readable.on("data", (chunk) => {
       this.onData(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
     });
     options.readable.on("end", () => {
-      this.failAll(new AcpChildExitError(this.childExit?.code ?? null, this.childExit?.signal ?? null));
+      const fail = () => {
+        readableEndTimer = null;
+        this.failAll(
+          new AcpChildExitError(
+            this.childExit?.code ?? null,
+            this.childExit?.signal ?? null
+          )
+        );
+      };
+      if (readableEndGraceMs > 0 && options.onChildExit) {
+        readableEndTimer = setTimeout(fail, readableEndGraceMs);
+      } else {
+        fail();
+      }
     });
     options.readable.on("error", (err) => {
       this.failAll(asAcpHostError(err));
@@ -29813,6 +29871,10 @@ var AcpTransport = class extends import_node_events.EventEmitter {
       this.failAll(asAcpHostError(err));
     });
     options.onChildExit?.((code, signal) => {
+      if (readableEndTimer) {
+        clearTimeout(readableEndTimer);
+        readableEndTimer = null;
+      }
       this.childExit = { code, signal };
       this.failAll(new AcpChildExitError(code, signal));
     });
@@ -30633,6 +30695,7 @@ function createBoundTransport(options) {
     writable: options.writable,
     requestTimeoutMs: options.requestTimeoutMs,
     onChildExit: options.onChildExit,
+    readableEndGraceMs: options.readableEndGraceMs,
     handlers: {
       onNotification: (method, params) => {
         options.getSession()?.handleAgentNotification(method, params);
@@ -31256,6 +31319,8 @@ var import_node_fs4 = require("node:fs");
 var import_node_path6 = require("node:path");
 var CHILD_EXIT_WAIT_MS2 = 3e3;
 var CHILD_KILL_WAIT_MS2 = 1e3;
+var STDERR_EXIT_GRACE_MS = 100;
+var READABLE_END_GRACE_MS = STDERR_EXIT_GRACE_MS + 50;
 var WINDOWS_NPM_SHIM_MAX_BYTES = 64 * 1024;
 var WINDOWS_NPM_ENTRYPOINT = [
   "node_modules",
@@ -31264,6 +31329,30 @@ var WINDOWS_NPM_ENTRYPOINT = [
   "dist",
   "index.js"
 ];
+function isPackagedClaudeBridge(executable) {
+  const normalized = executable.replaceAll("\\", "/");
+  return normalized.endsWith(
+    "/node_modules/@agentclientprotocol/claude-agent-acp/dist/index.js"
+  );
+}
+function resolvePackagedClaudeBridge(pathEnv, platform = process.platform) {
+  const pathValue = pathEnv ?? process.env.PATH ?? "";
+  const names = platform === "win32" ? ["claude-agent-acp.cmd"] : ["claude-agent-acp"];
+  for (const dir of pathValue.split(import_node_path6.delimiter)) {
+    if (!dir) continue;
+    for (const name of names) {
+      try {
+        const candidate = resolvedClaudeCandidate((0, import_node_path6.join)(dir, name), platform);
+        if (isPackagedClaudeBridge(candidate)) return candidate;
+      } catch {
+      }
+    }
+  }
+  throw new AcpHostError(
+    "executable_missing",
+    "packaged claude-agent-acp executable not found; install @agentclientprotocol/claude-agent-acp@0.64.2"
+  );
+}
 function resolveWindowsNpmShim(shim) {
   let source;
   try {
@@ -31336,12 +31425,17 @@ function parseClaudeVersionOutput(stdout) {
   const match = stdout.trim().match(/^(\d+\.\d+\.\d+)$/);
   return match?.[1] ?? null;
 }
-async function assertClaudeMeasuredVersion(executable, options) {
-  const expected = options?.expected ?? CLAUDE_ACP_MEASURED_VERSION;
+function parseClaudeCodeVersionOutput(stdout) {
+  const match = stdout.match(
+    /^(\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?) \(Claude Code\)\s*$/m
+  );
+  return match?.[1] ?? null;
+}
+async function readClaudeVersionOutput(executable, options) {
   const timeoutMs = options?.timeoutMs ?? ACP_VERSION_CHECK_TIMEOUT_MS;
   const env = options?.env ?? sanitizeChildEnv(process.env);
   const launch = buildClaudeLaunch(executable, ["--version"], options?.platform);
-  const stdout = await new Promise((resolve, reject) => {
+  return await new Promise((resolve, reject) => {
     (0, import_node_child_process4.execFile)(
       launch.command,
       launch.args,
@@ -31359,6 +31453,10 @@ async function assertClaudeMeasuredVersion(executable, options) {
       }
     );
   });
+}
+async function assertClaudeMeasuredVersion(executable, options) {
+  const expected = options?.expected ?? CLAUDE_ACP_MEASURED_VERSION;
+  const stdout = await readClaudeVersionOutput(executable, options);
   const version3 = parseClaudeVersionOutput(stdout);
   if (!version3) {
     throw new AcpVersionError(
@@ -31366,17 +31464,19 @@ async function assertClaudeMeasuredVersion(executable, options) {
     );
   }
   if (version3 !== expected) {
-    throw new AcpVersionError(
-      `refusing claude-agent-acp ${version3}; host core is measured for ${expected} only`
-    );
+    throw new AcpVersionMismatchError(expected, version3);
   }
   return version3;
 }
 function buildClaudeAcpArgs() {
   return [];
 }
-function buildClaudeChildEnv(parent) {
-  return sanitizeChildEnv(parent);
+function buildClaudeChildEnv(parent, claudeCodeExecutable) {
+  const env = sanitizeChildEnv(parent);
+  if (claudeCodeExecutable) {
+    env.CLAUDE_CODE_EXECUTABLE = claudeCodeExecutable;
+  }
+  return env;
 }
 function waitForChildExit2(child, timeoutMs) {
   if (child.exitCode !== null || child.signalCode !== null) {
@@ -31419,13 +31519,49 @@ async function openClaudeAcpSession(options) {
     );
   }
   const pathEnv = parentEnv.PATH;
-  const executable = resolveClaudeExecutable(
-    options.executable ?? "claude-agent-acp",
-    typeof pathEnv === "string" ? pathEnv : void 0
-  );
-  const env = buildClaudeChildEnv(parentEnv);
-  if (!options.skipVersionCheck) {
-    await assertClaudeMeasuredVersion(executable, { env });
+  const resolvedPathEnv = typeof pathEnv === "string" ? pathEnv : void 0;
+  if (options.skipVersionCheck && options.executable) {
+    throw new AcpHostError(
+      "version_check_required",
+      "skipVersionCheck cannot classify an explicit Claude executable"
+    );
+  }
+  const requestedExecutable = options.executable ? resolveClaudeExecutable(options.executable, resolvedPathEnv) : null;
+  const baseEnv = buildClaudeChildEnv(parentEnv);
+  let executable;
+  let env = baseEnv;
+  let claudeCodeExecutable;
+  if (requestedExecutable) {
+    const output = await readClaudeVersionOutput(requestedExecutable, {
+      env: baseEnv
+    });
+    const bridgeVersion = parseClaudeVersionOutput(output);
+    if (bridgeVersion) {
+      if (bridgeVersion !== CLAUDE_ACP_MEASURED_VERSION) {
+        throw new AcpVersionMismatchError(
+          CLAUDE_ACP_MEASURED_VERSION,
+          bridgeVersion
+        );
+      }
+      executable = requestedExecutable;
+    } else if (parseClaudeCodeVersionOutput(output)) {
+      claudeCodeExecutable = requestedExecutable;
+      executable = resolvePackagedClaudeBridge(resolvedPathEnv);
+      env = buildClaudeChildEnv(parentEnv, claudeCodeExecutable);
+      await assertClaudeMeasuredVersion(executable, { env });
+    } else {
+      throw new AcpVersionError(
+        `could not identify Claude executable from: ${output.trim().slice(0, 200)}`
+      );
+    }
+  } else {
+    executable = requestedExecutable ?? resolveClaudeExecutable(
+      "claude-agent-acp",
+      resolvedPathEnv
+    );
+    if (!options.skipVersionCheck) {
+      await assertClaudeMeasuredVersion(executable, { env: baseEnv });
+    }
   }
   if (options.signal?.aborted) {
     throw new AcpHostError(
@@ -31474,25 +31610,33 @@ async function openClaudeAcpSession(options) {
     throw new AcpHostError("spawn_failed", "child missing stdio pipes");
   }
   const stderrTail = attachStderrTailRing(child.stderr);
-  if (options.onStderrTail) {
-    const deliverTail = options.onStderrTail;
-    let tailDelivered = false;
-    const publishTail = () => {
-      if (tailDelivered) return;
-      tailDelivered = true;
-      deliverTail(stderrTail.read());
-    };
-    child.once("exit", publishTail);
-    child.once("close", publishTail);
-  }
   let sessionRef = null;
   const transport = createBoundTransport({
     readable: child.stdout,
     writable: child.stdin,
     requestTimeoutMs: options.requestTimeoutMs ?? ACP_DEFAULT_REQUEST_TIMEOUT_MS,
+    readableEndGraceMs: READABLE_END_GRACE_MS,
     getSession: () => sessionRef,
     onChildExit: (handler) => {
-      child.on("exit", (code, signal) => handler(code, signal));
+      const observeExit = (code, signal) => {
+        let completed = false;
+        let timer2 = null;
+        const complete = () => {
+          if (completed) return;
+          completed = true;
+          if (timer2) clearTimeout(timer2);
+          child.removeListener("close", complete);
+          options.onStderrTail?.(stderrTail.read());
+          handler(code, signal);
+        };
+        child.once("close", complete);
+        timer2 = setTimeout(complete, STDERR_EXIT_GRACE_MS);
+      };
+      if (child.exitCode !== null || child.signalCode !== null) {
+        observeExit(child.exitCode, child.signalCode);
+      } else {
+        child.once("exit", observeExit);
+      }
     }
   });
   try {
@@ -37850,8 +37994,8 @@ var ACCEPTED_AGENT_CREDENTIAL_MESSAGES = [
   AGENT_CREDENTIAL_MESSAGE_D088
 ];
 function packageVersion() {
-  if ("0.1.26".length > 0) {
-    return "0.1.26";
+  if ("0.1.27".length > 0) {
+    return "0.1.27";
   }
   try {
     const value = JSON.parse(
@@ -39666,10 +39810,25 @@ async function runPostSignal(args, kind) {
     validateHumanWorkspace: true
   });
   const toSelector = allowTo ? args.optional("to") : void 0;
-  const recipient = toSelector === void 0 ? null : resolveSignalRecipient(
-    toSelector,
-    await signalDirectory(cloud, credential.selectedWorkspace, credential)
-  );
+  let recipient = null;
+  if (toSelector !== void 0) {
+    let directory;
+    try {
+      directory = await signalDirectory(
+        cloud,
+        credential.selectedWorkspace,
+        credential
+      );
+    } catch (error) {
+      if (kind === "ask") {
+        throw new Error(
+          askCreateFailureMessage(credential.selectedWorkspace, error)
+        );
+      }
+      throw error;
+    }
+    recipient = resolveSignalRecipient(toSelector, directory);
+  }
   if (waitSeconds !== void 0 && recipient === null) {
     throw new Error(
       "ask --wait requires --to with a direct member or agent recipient"
@@ -39684,21 +39843,38 @@ async function runPostSignal(args, kind) {
     about: args.optional("about") === void 0 ? null : signalText(args.required("about"), "about"),
     ...untilMs2 === void 0 ? {} : { until_ms: untilMs2 }
   };
-  const result = await postSignalCommand(cloud, credential, command2);
+  let result;
+  try {
+    result = await postSignalCommand(cloud, credential, command2);
+  } catch (error) {
+    if (kind === "ask") {
+      throw new Error(
+        askCreateFailureMessage(credential.selectedWorkspace, error)
+      );
+    }
+    throw error;
+  }
   const signal = result.response.signal;
   if (waitSeconds !== void 0) {
     const credentialForRead = signalCredentialOf(credential);
     const deadlineMs = waitDeadlineMs(waitSeconds);
-    const waitResult = await pollForSignals({
-      deadlineMs,
-      read: () => readSignals(cloud, credentialForRead, {
-        workspaceId: credential.selectedWorkspace,
-        inbox: true,
-        in_reply_to: signal.id,
-        includeStale: false,
-        limit: 1
-      }, { deadlineMs })
-    });
+    let waitResult;
+    try {
+      waitResult = await pollForSignals({
+        deadlineMs,
+        read: () => readSignals(cloud, credentialForRead, {
+          workspaceId: credential.selectedWorkspace,
+          inbox: true,
+          in_reply_to: signal.id,
+          includeStale: false,
+          limit: 1
+        }, { deadlineMs })
+      });
+    } catch (error) {
+      throw new Error(
+        askReplyReadFailureMessage(credential.selectedWorkspace, error)
+      );
+    }
     const reply = waitResult.signals[0] ?? null;
     if (args.has("json")) {
       printJson(askWaitJsonPayload(signal, reply, waitResult.timedOut));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commonswarm",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "CommonSwarm CLI — coordination for teams where people and AI agents work side by side.",
   "bin": {
     "cswarm": "cswarm.cjs"