agents-can-communicate 0.8.5 → 0.9.0

package/node_modules/@agents-can-communicate/core/src/session-opening.mjs

@@ -100,6 +100,17 @@ export function createSessionOpener(ports, locate) {
     };
     if (await isMaterialised(store, workspaceId)) return openDurable();
 
+    // Another live session already here makes this the second, which
+    // materialises the workspace: this one opens in that same transaction
+    // rather than as an ephemeral copy to be copied and retired at once. The
+    // look is taken without the lock; materialise asks again under it.
+    const joining = (await store.ephemeral.list("session")).some(item => item.state === "open"
+      && item.sessionId !== sessionId);
+    if (joining && await materialise(ports, { workspaceId, descriptor: input.descriptor,
+      reason: "second_live_session", opening: { participant, session, assertAvailable } })) {
+      return session;
+    }
+
     // Preparing a participant must not rename one that already exists, or
     // recreate an ephemeral copy after promotion has taken ownership.
     await store.ephemeral.update("participant", participant.participantId, async current =>

package/node_modules/@agents-can-communicate/core/src/sessions.mjs

@@ -92,8 +92,14 @@ export function createSessionService(ports) {
     // presence transitions surface through cursor sync. Read and validate under
     // the writer lock, so a pending heartbeat cannot restore an old generation.
     // Promoted copies may await cleanup; their durable record already owns writes.
-    const ephemeral = await store.ephemeral.update("session", sessionId, async current =>
-      current !== null && !await isMaterialised(store, current.workspaceId) ? beat(current) : null);
+    // The update below writes only a lone session's ephemeral record. A session
+    // with none, or in a materialised workspace, is durable - and stays so: a
+    // workspace never returns to ephemeral - so it goes straight to the durable
+    // record rather than taking the writer lock to find nothing.
+    const seen = await store.ephemeral.get("session", sessionId);
+    const ephemeral = seen === null || await isMaterialised(store, seen.workspaceId) ? null
+      : await store.ephemeral.update("session", sessionId, async current =>
+        current !== null && !await isMaterialised(store, current.workspaceId) ? beat(current) : null);
     if (ephemeral !== null) return ephemeral;
     return store.transaction(tx => {
       const beaten = beat(tx.get("session", sessionId));

package/node_modules/@agents-can-communicate/delivery-router/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/delivery-router",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/hook-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/hook-runner",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/hook-runner/src/client-pid.mjs

@@ -1,4 +1,4 @@
-import path from "node:path";
+import { splitWindowsCommandLine } from "@agents-can-communicate/adapter-sdk";
 
 // Deep enough for a client that wraps its hook in a shell and a launcher, short
 // enough that a table which disagrees with itself cannot spin.
@@ -8,11 +8,35 @@ const MAX_HOPS = 16;
 // interpreter. Gemini CLI is one, measured on 0.60.0. For these, the script the
 // interpreter was given names the client.
 const SCRIPT_HOSTS = new Set(["node"]);
+// What scriptsOf reports for a script inside the client's own package.
+const CLIENT_PACKAGE = Symbol("client package");
 const SCRIPT_EXTENSION = /\.[mc]?js$/;
 
+// Either separator: `ps` names POSIX paths, Win32_Process names Windows ones,
+// and the host running the walk may be either.
+const basename = value => value.split(/[\\/]/).at(-1);
+
+/** An image name as the client's command: Windows adds `.exe` in any case. */
+function imageName(comm) {
+  const name = basename(comm);
+  return /\.exe$/i.test(name) ? name.slice(0, -4).toLowerCase() : name;
+}
+
+/** The words of a command line: Windows quotes paths with spaces. */
+const wordsOf = entry => (/\.exe$/i.test(entry.comm) ? splitWindowsCommandLine(entry.args)
+  : entry.args.trim().split(/\s+/));
+
 /** What the script a script host runs could be called, without extensions. */
-function scriptsOf(entry) {
-  if (!SCRIPT_HOSTS.has(path.basename(entry.comm)) || typeof entry.args !== "string") return [];
+function scriptsOf(entry, clientPackage) {
+  if (!SCRIPT_HOSTS.has(imageName(entry.comm)) || typeof entry.args !== "string") return [];
+  if (/\.exe$/i.test(entry.comm)) {
+    // Windows: the client is node.exe running its package's entry file, whose
+    // own name (`index.js`) says nothing; the package directory does.
+    const script = wordsOf(entry).slice(1).find(word => !word.startsWith("-"));
+    const inPackage = typeof clientPackage === "string" && typeof script === "string"
+      && script.replaceAll("\\", "/").includes(`/node_modules/${clientPackage}/`);
+    return inPackage ? [CLIENT_PACKAGE] : [];
+  }
   // `args` starts with the interpreter as it was invoked, which is the comm
   // itself on macOS; past it, the first word that is no option is the script -
   // unless an option written without `=` came right before it, since that word
@@ -26,7 +50,7 @@ function scriptsOf(entry) {
   for (const word of rest.trim().split(/\s+/)) {
     if (word === "") continue;
     if (word.startsWith("-")) { afterBareOption = !word.includes("="); continue; }
-    candidates.push(path.basename(word).replace(SCRIPT_EXTENSION, ""));
+    candidates.push(basename(word).replace(SCRIPT_EXTENSION, ""));
     if (!afterBareOption) break;
     afterBareOption = false;
   }
@@ -44,16 +68,51 @@ function scriptsOf(entry) {
  *
  * Null is a first-class answer: it means judge this session by age alone.
  */
-export function resolveClientPid({ table, from, command, maxHops = MAX_HOPS }) {
+export function resolveClientPid({ table, from, command, clientPackage, maxHops = MAX_HOPS }) {
+  return resolveClient({ table, from, command, clientPackage, maxHops })?.pid ?? null;
+}
+
+// What an adapter's identifyClientProcess said about one ancestor, or null.
+// It reads a vendor's command line, so a throw is a "no", never a failed hook.
+function recognised(identify, entry) {
+  if (typeof identify !== "function") return null;
+  try {
+    const answer = identify({ comm: entry.comm, args: typeof entry.args === "string" ? entry.args : "" });
+    return answer !== null && typeof answer === "object" ? answer : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The client this hook runs under: its pid, its process-table entry, and what
+ * the adapter recognised it as - another product it serves, and that
+ * product's version when the process names it. Null when nobody knows.
+ *
+ * At each ancestor the adapter's own identifier is asked first; the declared
+ * command still matches whatever it does not recognise. Antigravity 2.0 runs
+ * hooks under a language server that names its version on its command line,
+ * where Antigravity CLI runs them under `agy`.
+ */
+export function resolveClient({ table, from, command, clientPackage, identify,
+  maxHops = MAX_HOPS }) {
   const seen = new Set();
   let current = from;
   for (let hop = 0; hop < maxHops; hop += 1) {
     const entry = table.get(current);
     if (entry === undefined || seen.has(current)) return null;
     seen.add(current);
+    const product = recognised(identify, entry);
+    if (product !== null) {
+      return { pid: current, entry, certificationName: product.certificationName,
+        version: product.version };
+    }
     // `ps` reports some entries bare (`claude`) and some with a path
     // (`/bin/zsh`), so the comparison has to be on the basename.
-    if (path.basename(entry.comm) === command || scriptsOf(entry).includes(command)) return current;
+    if (imageName(entry.comm) === command
+      || scriptsOf(entry, clientPackage).some(name => name === command || name === CLIENT_PACKAGE)) {
+      return { pid: current, entry, certificationName: undefined, version: undefined };
+    }
     if (entry.ppid === current || entry.ppid <= 1) return null;
     current = entry.ppid;
   }

package/node_modules/@agents-can-communicate/hook-runner/src/client-version.mjs

@@ -1,4 +1,8 @@
 import { execFile } from "node:child_process";
+import { readFile as readText } from "node:fs/promises";
+import path from "node:path";
+
+import { resolveExecutable, runExecutable } from "@agents-can-communicate/adapter-sdk";
 
 const VERSION = /(?:^|[^0-9A-Za-z])v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\b|$)/;
 
@@ -8,6 +12,7 @@ export function parseClientVersion(output) {
 
 /** Probe the client binary once when its real session starts. */
 export function probeClientVersion(adapter, { timeoutMs = 1_000 } = {}) {
+  if (process.platform === "win32") return probeOnWindows(adapter, timeoutMs);
   return new Promise(resolve => {
     execFile(adapter.client.command, adapter.client.versionArgs ?? ["--version"], {
       timeout: timeoutMs,
@@ -19,3 +24,78 @@ export function probeClientVersion(adapter, { timeoutMs = 1_000 } = {}) {
     });
   });
 }
+
+/**
+ * The executable a client process runs, when `ps` names it by absolute path and
+ * that path is the client's command: a desktop app starts its own build by full
+ * path (Claude.app's claude, ChatGPT.app's codex), and asking that file is
+ * asking the session's own build. Null otherwise, and always on Windows, whose
+ * process names carry no path.
+ */
+export function ownExecutable(entry, command) {
+  if (process.platform === "win32" || typeof entry?.comm !== "string") return null;
+  return path.isAbsolute(entry.comm) && path.basename(entry.comm) === command ? entry.comm : null;
+}
+
+/** That executable's `--version`, parsed like the PATH probe's; null on any failure. */
+export function probeExecutableVersion(file, versionArgs = ["--version"], { timeoutMs = 1_000 } = {}) {
+  return new Promise(resolve => {
+    execFile(file, versionArgs, { timeout: timeoutMs, killSignal: "SIGKILL", windowsHide: true },
+      (error, stdout, stderr) => resolve(error === null ? parseClientVersion(`${stdout}${stderr}`) : null));
+  });
+}
+
+// A package script the npm .cmd shim runs: `"%dp0%\<path inside the prefix>"`.
+const SHIM_TARGET = /"%dp0%\\([^"%]+\.(?:c|m)?js)"/gi;
+const DEPTH = 6;
+
+/**
+ * The version of the package an npm .cmd shim runs, or null when the file is no
+ * such shim. npm writes a .cmd per bin that runs node on the package's script;
+ * the package whose `bin` names that script is the client, and its version is
+ * what the client's --version prints - without starting cmd.exe, node and, for
+ * Codex, the native binary behind it.
+ */
+export async function npmShimVersion(file, { readFile = readText } = {}) {
+  try {
+    const targets = [...String(await readFile(file, "utf8")).matchAll(SHIM_TARGET)];
+    if (targets.length !== 1) return null;
+    const script = path.win32.join(path.win32.dirname(file), targets[0][1]);
+    let directory = path.win32.dirname(script);
+    for (let depth = 0; depth < DEPTH; depth += 1) {
+      const manifest = await readFile(path.win32.join(directory, "package.json"), "utf8")
+        .then(JSON.parse, error => (error.code === "ENOENT" ? null : Promise.reject(error)));
+      if (manifest !== null) {
+        const bins = typeof manifest.bin === "string" ? [manifest.bin] : Object.values(manifest.bin ?? {});
+        const runs = bins.some(bin => typeof bin === "string"
+          && path.win32.resolve(directory, bin).toLowerCase() === path.win32.resolve(script).toLowerCase());
+        return runs ? parseClientVersion(String(manifest.version)) : null;
+      }
+      const parent = path.win32.dirname(directory);
+      if (parent === directory) return null;
+      directory = parent;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// Windows finds `codex.cmd` or `claude.exe`, never the bare name, and starts a
+// .cmd only through cmd.exe.
+async function probeOnWindows(adapter, timeoutMs) {
+  const started = Date.now();
+  try {
+    const file = await resolveExecutable(adapter.client.command);
+    if (file === null) return null;
+    if (/\.cmd$/i.test(file)) {
+      const packaged = await npmShimVersion(file);
+      if (packaged !== null) return packaged;
+    }
+    const { stdout, stderr } = await runExecutable(file, adapter.client.versionArgs ?? ["--version"],
+      { timeout: Math.max(1, timeoutMs - (Date.now() - started)), killSignal: "SIGKILL" });
+    return parseClientVersion(`${stdout}${stderr}`);
+  } catch {
+    return null;
+  }
+}

package/node_modules/@agents-can-communicate/hook-runner/src/native-attempt.mjs

@@ -1,5 +1,5 @@
 import { storeNativeAttempt } from "@agents-can-communicate/adapter-sdk";
-import { readInstalledLivePolicyState } from "@agents-can-communicate/installer";
+import { readInstalledLivePolicyState } from "@agents-can-communicate/installer/hook-support";
 
 import { establishNativeBinding } from "./native-binding.mjs";
 

package/node_modules/@agents-can-communicate/hook-runner/src/owner-context.mjs

@@ -1,11 +1,39 @@
-import { assertPortableId } from "@agents-can-communicate/protocol";
+import { AccError, EXIT, assertPortableId } from "@agents-can-communicate/protocol";
 
-const shellQuote = value => `'${value.replaceAll("'", "'\\''")}'`;
+const posixQuote = value => `'${value.replaceAll("'", "'\\''")}'`;
+// The model appends the header in whatever shell its client gives it, and on
+// Windows that can be cmd.exe, PowerShell or Git Bash. Double quotes are the one
+// quoting all three read alike, for a value with none of what one of them acts
+// on inside double quotes: a double quote - PowerShell also ends a string at
+// U+201C to U+201E, which NTFS allows in names - $ and a backtick, which
+// PowerShell and bash expand, and %, which cmd expands. Single quotes are no
+// answer: cmd takes them as part of the path. Such a value is refused rather
+// than handed to a model that would read it as something else.
+const DOUBLE_QUOTE_BREAKERS = /["\u201C-\u201E$`%]/;
+const windowsQuote = value => {
+  if (!DOUBLE_QUOTE_BREAKERS.test(value)) return `"${value}"`;
+  throw new AccError(EXIT.USAGE, `${value} has a double quote, $, \` or % in it, which no quoting `
+    + "reads alike in cmd, PowerShell and Git Bash, and ACC's hooks will not hand the model a "
+    + "command line it would read differently; rename the directory",
+  { value, reasonCode: "workspace_path_unquotable" });
+};
 
-export const ownerHeader = (binding, cwd, workspaceRef) => "ACC CLI (append): --session "
-  + assertPortableId(binding.accSessionId, "sessionId") + " --generation "
-  + assertPortableId(binding.generation, "generation") + " --cwd " + shellQuote(cwd)
-  + (workspaceRef === undefined ? "" : " --workspace " + shellQuote(workspaceRef));
+// Before anything opens: a session that attached and could then never be told
+// its CLI arguments would look live to its peers, and every one of its turns
+// would fail before their messages reached it.
+export function assertOwnerQuotable(cwd, workspaceRef, platform = process.platform) {
+  if (platform !== "win32") return;
+  windowsQuote(cwd);
+  if (workspaceRef !== undefined) windowsQuote(workspaceRef);
+}
+
+export const ownerHeader = (binding, cwd, workspaceRef, platform = process.platform) => {
+  const quote = platform === "win32" ? windowsQuote : posixQuote;
+  return "ACC CLI (append): --session "
+    + assertPortableId(binding.accSessionId, "sessionId") + " --generation "
+    + assertPortableId(binding.generation, "generation") + " --cwd " + quote(cwd)
+    + (workspaceRef === undefined ? "" : " --workspace " + quote(workspaceRef));
+};
 
 export function ownerOnlyOutcome(inject, owner, budgetBytes) {
   if (Buffer.byteLength(owner, "utf8") > budgetBytes) {

package/node_modules/@agents-can-communicate/hook-runner/src/process-table.mjs

@@ -1,50 +1,3 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-const run = promisify(execFile);
-
-// A hook runs in front of someone's turn. Reading the table is worth a few
-// hundred milliseconds once per session and nothing at all if it is slow.
-const DEFAULT_TIMEOUT_MS = 1_000;
-
-const LINE = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/;
-// A pid, then the whole rest of the line: a command line has spaces anywhere.
-const ARGS_LINE = /^\s*(\d+)\s+(.+?)\s*$/;
-// Command lines are long; measured at 231 KB for 1,137 processes on a desktop
-// Mac, a quarter of execFile's default buffer.
-const ARGS_BUFFER = 16 * 1024 * 1024;
-
-/**
- * Every process on this machine, as pid -> parent, executable and, when it
- * could be read, command line.
- *
- * Returns an empty map rather than throwing when the platform has no `ps`
- * (Windows) or the call fails. An empty table resolves no client, which is the
- * "nobody knows" answer the caller already handles. The command lines are read
- * at the same time and within the same timeout; they only name a client that
- * is a script, so when that read fails every entry keeps what it had before.
- */
-export async function readProcessTable({ run: exec = run,
-  timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
-  const options = { timeout: timeoutMs, killSignal: "SIGKILL" };
-  const [tree, commandLines] = await Promise.all([
-    exec("ps", ["-o", "pid=,ppid=,comm=", "-A"], options).then(({ stdout }) => stdout, () => null),
-    exec("ps", ["-A", "-o", "pid=,args="], { ...options, maxBuffer: ARGS_BUFFER })
-      .then(({ stdout }) => stdout, () => ""),
-  ]);
-  if (typeof tree !== "string") return new Map();
-  const args = new Map();
-  for (const line of String(commandLines).split("\n")) {
-    const match = ARGS_LINE.exec(line);
-    if (match !== null) args.set(Number(match[1]), match[2]);
-  }
-  const table = new Map();
-  for (const line of tree.split("\n")) {
-    const match = LINE.exec(line);
-    if (match === null) continue;
-    const pid = Number(match[1]);
-    table.set(pid, { ppid: Number(match[2]), comm: match[3],
-      ...(args.has(pid) ? { args: args.get(pid) } : {}) });
-  }
-  return table;
-}
+// The table lives in the adapter SDK, which adapters that read a process's
+// arguments share with the hook runner; this keeps the runner's own name.
+export { readProcessTable } from "@agents-can-communicate/adapter-sdk";