agents-can-communicate 0.7.1 → 0.8.1

package/node_modules/@agents-can-communicate/adapter-claude-code/src/native-delivery.mjs

@@ -1,232 +0,0 @@
-import { readFile, readdir, stat } from "node:fs/promises";
-import net from "node:net";
-import path from "node:path";
-import { decisionBody } from "@agents-can-communicate/adapter-sdk";
-
-import { PROTOCOL_CONTRACT, endpointDir, isSocketSafe, readRegistration, routeAck, routeReply }
-  from "./channel.mjs";
-
-// The five native-delivery adapter methods for Claude Code. They keep every
-// Claude flag, protocol name, and endpoint detail inside this package and hand
-// core only opaque facts: a probe verdict, an activation plan, a handshake with
-// an opaque endpoint id, and an offer result. offerMessage is the sender-side
-// half - it connects to the receiver's session endpoint and delivers one
-// envelope; the Channel process itself turns acc_reply into a real ACC answer.
-
-const MIN_VERSION = "2.1.258";
-const CHANNEL_PLUGIN = "plugin:agents-can-communicate@acc-local";
-const DEV_CHANNEL_FLAG = "--dangerously-load-development-channels";
-// The bytes the installed 2.1.258 Mach-O carries for the Channel MCP protocol;
-// a build without Channels has neither. Read-only, bounded.
-const PROBE_NEEDLE = Buffer.from("notifications/claude/channel");
-const PROBE_MAX_BYTES = 256 * 1024 * 1024;
-const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z.-]+)?$/;
-
-function compare(left, right) {
-  const a = left.split("+")[0].split(".").map(Number);
-  const b = right.split("+")[0].split(".").map(Number);
-  for (let index = 0; index < 3; index += 1) if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
-  return 0;
-}
-
-async function executableHasChannel(realExecutable) {
-  let handle;
-  try {
-    handle = await (await import("node:fs/promises")).open(realExecutable, "r");
-  } catch {
-    return false;
-  }
-  try {
-    const chunk = Buffer.alloc(1024 * 1024);
-    let carry = Buffer.alloc(0);
-    let read = 0;
-    let position = 0;
-    do {
-      ({ bytesRead: read } = await handle.read(chunk, 0, chunk.length, position));
-      if (read === 0) break;
-      const window = Buffer.concat([carry, chunk.subarray(0, read)]);
-      if (window.includes(PROBE_NEEDLE)) return true;
-      carry = window.subarray(Math.max(0, window.length - PROBE_NEEDLE.length));
-      position += read;
-    } while (position < PROBE_MAX_BYTES);
-    return false;
-  } finally {
-    await handle.close().catch(() => null);
-  }
-}
-
-// Read-only: a stable version at or above the minimum whose executable carries
-// the Channel protocol. Never launches the client.
-export async function probeNativeDelivery({ realExecutable, timeoutMs = 750,
-  hasChannel = executableHasChannel, readVersion = defaultReadVersion } = {}) {
-  const unsupported = reasonCode => ({ supported: false, clientVersion: null,
-    protocolContract: PROTOCOL_CONTRACT, executableFingerprint: null, modes: [], reasonCode });
-  if (typeof realExecutable !== "string" || realExecutable === "") return unsupported("feature_probe_failed");
-  const clientVersion = await withTimeout(readVersion(realExecutable, timeoutMs), timeoutMs)
-    .catch(() => null);
-  if (clientVersion === null || !STABLE_VERSION.test(clientVersion)) {
-    return { ...unsupported("feature_probe_failed"), clientVersion };
-  }
-  if (compare(clientVersion, MIN_VERSION) < 0) {
-    return { ...unsupported("below_minimum_version"), clientVersion };
-  }
-  const present = await withTimeout(Promise.resolve(hasChannel(realExecutable)), timeoutMs)
-    .catch(() => false);
-  if (!present) return { ...unsupported("protocol_mismatch"), clientVersion };
-  return { supported: true, clientVersion, protocolContract: PROTOCOL_CONTRACT,
-    executableFingerprint: null, modes: ["livePush", "idleWake", "busyQueue", "replyRoute"],
-    reasonCode: null };
-}
-
-function defaultReadVersion(realExecutable, timeoutMs) {
-  return new Promise(resolve => {
-    import("node:child_process").then(({ execFile }) => {
-      execFile(realExecutable, ["--version"], { timeout: timeoutMs, windowsHide: true },
-        (error, stdout, stderr) => {
-          if (error !== null) return resolve(null);
-          resolve(/(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/.exec(`${stdout}${stderr}`)?.[1] ?? null);
-        });
-    });
-  });
-}
-
-function withTimeout(work, ms) {
-  let timer = null;
-  const deadline = new Promise((_resolve, reject) => {
-    timer = setTimeout(() => reject(Object.assign(new Error("native probe timed out"),
-      { code: "ETIMEDOUT" })), ms);
-  });
-  return Promise.race([work, deadline]).finally(() => clearTimeout(timer));
-}
-
-// The shell bootstrap adds only the captured Channel flag; the .mcp.json the
-// adapter's own install writes is the native-config artifact. ACC never
-// suppresses Claude's experimental warning.
-export function planNativeActivation({ detection, livePolicy }) {
-  if (detection?.realExecutable === undefined || detection.realExecutable === null) {
-    return { eligible: false, reasonCode: "feature_probe_failed", mechanisms: [] };
-  }
-  void livePolicy;
-  return { eligible: true, reasonCode: null, mechanisms: [
-    { kind: "native-config", artifactIds: ["claude-channel-mcp"] },
-    { kind: "shell-bootstrap", command: "claude", realExecutable: detection.realExecutable,
-      prefixArgs: [DEV_CHANNEL_FLAG, CHANNEL_PLUGIN] },
-  ] };
-}
-
-async function currentRegistrations(runtimeDir) {
-  const dir = endpointDir(runtimeDir);
-  let names;
-  try { names = await readdir(dir); } catch { return []; }
-  const registrations = [];
-  for (const name of names) {
-    if (!name.endsWith(".json")) continue;
-    try {
-      const record = readRegistration(await readFile(path.join(dir, name), "utf8"));
-      registrations.push(record);
-    } catch { /* skip a malformed neighbour */ }
-  }
-  return registrations;
-}
-
-// Bind the exact Channel the hook-resolved Claude process owns: match clientPid,
-// verify the protocol, and return an opaque endpoint id. Never selects the first
-// registration; two Claude sessions cannot receive each other's endpoint.
-export async function bindNativeSession({ clientPid, clientVersion, runtimeDir, timeoutMs = 750,
-  intervalMs = 50, now = () => Date.now(),
-  sleep = ms => new Promise(resolve => setTimeout(resolve, ms)) }) {
-  const closed = reasonCode => ({ supported: false, clientVersion: clientVersion ?? null,
-    protocolContract: PROTOCOL_CONTRACT, modes: [], opaqueEndpointRef: null, leaseUntil: null,
-    reasonCode });
-  if (!Number.isInteger(clientPid) || clientPid <= 0) return closed("handshake_failed");
-  // Both sides of this handshake are started by SessionStart: the hook writes
-  // the session binding and then calls here, while the Channel is still waiting
-  // for that same binding before it can listen and register. So the endpoint
-  // reliably appears after this begins, and a single read gave up on a channel
-  // that was moments from ready - measured, a healthy endpoint landed on disk
-  // just after the hook had already recorded no binding at all.
-  //
-  // The budget was always passed in for this. It stops one interval short of
-  // the hook's own timer, which races the same budget: an answer that arrives
-  // together with that timer is a coin toss the session loses.
-  const deadline = now() + Math.max(0, timeoutMs - intervalMs);
-  for (;;) {
-    const matches = (await currentRegistrations(runtimeDir))
-      .filter(record => record.clientPid === clientPid
-        && record.protocolContract === PROTOCOL_CONTRACT
-        && Date.parse(record.leaseUntil) > Date.now());
-    // Exactly one, still: waiting must not relax the rule that two Claude
-    // sessions can never be handed each other's endpoint.
-    if (matches.length === 1 && isSocketSafe(matches[0].socketPath)) {
-      const [record] = matches;
-      return { supported: true, clientVersion: clientVersion ?? null,
-        protocolContract: PROTOCOL_CONTRACT, modes: [...record.modes],
-        opaqueEndpointRef: record.endpointId, leaseUntil: record.leaseUntil, reasonCode: null };
-    }
-    if (now() >= deadline) return closed("handshake_failed");
-    await sleep(intervalMs);
-  }
-}
-
-// Sender side: resolve the endpoint id to its registration under this
-// workspace's runtime dir, connect to the session-scoped socket, and deliver one
-// envelope. Returns only accepted/duplicate plus the bound client version.
-export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 2_000,
-  connect = net.createConnection }) {
-  const rejected = safeErrorCode => ({ accepted: false, transport: "claude-channel",
-    clientVersion: binding?.clientVersion ?? null, safeErrorCode });
-  if (typeof runtimeDir !== "string" || binding?.opaqueEndpointRef === undefined) {
-    return rejected("recipient_unavailable");
-  }
-  const file = path.join(endpointDir(runtimeDir), `${binding.opaqueEndpointRef}.json`);
-  if (path.dirname(file) !== endpointDir(runtimeDir)) return rejected("recipient_unavailable");
-  let record;
-  try {
-    record = readRegistration(await readFile(file, "utf8"));
-  } catch {
-    return rejected("recipient_unavailable");
-  }
-  if (record.endpointId !== binding.opaqueEndpointRef
-    || record.protocolContract !== PROTOCOL_CONTRACT
-    || Date.parse(record.leaseUntil) <= Date.now()
-    || !(await stat(record.socketPath).then(s => s.isSocket(), () => false))
-    || !isSocketSafe(record.socketPath)) {
-    return rejected("recipient_unavailable");
-  }
-  return sendEnvelope({ record, message, binding, connect, timeoutMs, rejected });
-}
-
-function sendEnvelope({ record, message, binding, connect, timeoutMs, rejected }) {
-  const envelope = { nonce: record.nonce, messageId: message.messageId, kind: message.kind,
-    subject: message.subject ?? "", body: decisionBody(message),
-    ...(typeof message.inReplyTo === "string" ? { inReplyTo: message.inReplyTo } : {}) };
-  return new Promise(resolve => {
-    const socket = connect(record.socketPath);
-    let settled = false;
-    const finish = value => { if (settled) return; settled = true; clearTimeout(timer);
-      socket.destroy(); resolve(value); };
-    const timer = setTimeout(() => finish(rejected("transport_error")), timeoutMs);
-    socket.once("error", error => finish(rejected(
-      ["EPERM", "EACCES"].includes(error.code)
-        ? "transport_permission_denied" : "recipient_unavailable")));
-    socket.once("connect", () => {
-      socket.write(`${JSON.stringify(envelope)}\n`);
-      let buffer = "";
-      socket.on("data", chunk => {
-        buffer += chunk.toString("utf8");
-        const newline = buffer.indexOf("\n");
-        if (newline === -1) return;
-        let response;
-        try { response = JSON.parse(buffer.slice(0, newline)); }
-        catch { return finish(rejected("transport_rejected")); }
-        if (response.accepted === true) {
-          return finish({ accepted: true, transport: "claude-channel",
-            clientVersion: binding.clientVersion });
-        }
-        finish(rejected("transport_rejected"));
-      });
-    });
-  });
-}
-
-export { MIN_VERSION, endpointDir, routeAck, routeReply };

package/node_modules/@agents-can-communicate/installer/src/bootstrap-runtime.mjs

@@ -1,150 +0,0 @@
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { mkdir, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-
-import { evaluateNativeEligibility, ownVersion } from "@agents-can-communicate/adapter-sdk";
-
-// The launch-time check behind an owned shell shim. It answers one closed
-// question - may this exact executable receive native delivery? - from the
-// static minimum, a read-only adapter probe, and a keyed cache under ACC's own
-// data home. It never throws: a shim that cannot decide launches the vendor
-// command untouched, and this module is what makes "cannot decide" cheap.
-//
-// The cache key is the executable's identity - resolved path, symlink target,
-// inode, size, mtime, and full sha256 - plus platform and this ACC runtime's
-// version. A vendor upgrade, replacement, or changed certification contract is
-// therefore a miss. A cached failure is short-lived; a repaired client is
-// never disabled for long.
-
-export const BOOTSTRAP_CACHE_SCHEMA = 1;
-export const SUPPORTED_TTL_MS = 6 * 60 * 60 * 1_000;
-export const FAILED_TTL_MS = 5 * 60 * 1_000;
-const DEFAULT_TIMEOUT_MS = 750;
-const VERSION = /(?:^|[^0-9A-Za-z])v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\b|$)/;
-
-export const cachePathFor = (dataHome, adapterId) =>
-  path.join(dataHome, "acc", "native-bootstrap", `${adapterId}.json`);
-
-function sha256File(file) {
-  return new Promise((resolve, reject) => {
-    const hash = createHash("sha256");
-    createReadStream(file).on("data", chunk => hash.update(chunk))
-      .on("error", reject).on("end", () => resolve(`sha256:${hash.digest("hex")}`));
-  });
-}
-
-async function executableIdentity(realExecutable) {
-  const target = await realpath(realExecutable);
-  const facts = await stat(target);
-  if (!facts.isFile()) throw new Error("not a file");
-  return { path: realExecutable, target, inode: facts.ino, size: facts.size,
-    mtimeMs: Math.floor(facts.mtimeMs), executableFingerprint: await sha256File(target) };
-}
-
-function withTimeout(work, ms, label) {
-  let timer = null;
-  const deadline = new Promise((_resolve, reject) => {
-    timer = setTimeout(() => reject(Object.assign(new Error(`${label} timed out`),
-      { code: "ETIMEDOUT" })), ms);
-  });
-  return Promise.race([work, deadline]).finally(() => clearTimeout(timer));
-}
-
-// Read-only: the client's own version command, nothing else.
-export function defaultReadVersion({ realExecutable, versionArgs, timeoutMs }) {
-  return new Promise(resolve => {
-    execFile(realExecutable, versionArgs, { timeout: timeoutMs, windowsHide: true },
-      (error, stdout, stderr) => {
-        if (error !== null) return resolve(null);
-        resolve(VERSION.exec(`${stdout}${stderr}`)?.[1] ?? null);
-      });
-  });
-}
-
-const sameIdentity = (left, right) => left !== undefined && right !== undefined
-  && ["path", "target", "inode", "size", "mtimeMs", "executableFingerprint"]
-    .every(key => left[key] === right[key]);
-
-async function loadCache(file) {
-  try {
-    const record = JSON.parse(await readFile(file, "utf8"));
-    return record?.schemaVersion === BOOTSTRAP_CACHE_SCHEMA ? record : null;
-  } catch {
-    return null;
-  }
-}
-
-async function saveCache(file, record) {
-  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
-  const temporary = `${file}.${process.pid}.tmp`;
-  await writeFile(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
-  await rename(temporary, file);
-}
-
-const closedOutcome = (supported, reasonCode) => Object.freeze({ supported, reasonCode });
-
-export async function checkNativeBootstrap({ adapter, realExecutable, platform, dataHome,
-  timeoutMs = DEFAULT_TIMEOUT_MS, clock = { now: () => new Date().toISOString() },
-  readVersion = defaultReadVersion, accVersion }) {
-  try {
-    if (adapter?.nativeDelivery === undefined || typeof adapter.probeNativeDelivery !== "function") {
-      return closedOutcome(false, "native_delivery_unsupported");
-    }
-    const identity = await executableIdentity(realExecutable);
-    const file = cachePathFor(dataHome, adapter.id);
-    const now = Date.parse(clock.now());
-    const runtimeVersion = accVersion === undefined
-      ? await ownVersion(import.meta.url) : accVersion;
-    const runtimeVersionKnown = typeof runtimeVersion === "string" && runtimeVersion !== "";
-    const cached = await loadCache(file);
-    if (cached !== null && cached.adapterId === adapter.id && cached.platform === platform
-      && runtimeVersionKnown && cached.accVersion === runtimeVersion
-      && sameIdentity(cached.identity, identity) && Date.parse(cached.expiresAt) > now) {
-      return closedOutcome(cached.supported, cached.reasonCode);
-    }
-
-    const clientVersion = await withTimeout(readVersion({ realExecutable: identity.target,
-      versionArgs: adapter.client?.versionArgs ?? ["--version"], timeoutMs }), timeoutMs,
-    "version probe").catch(() => null);
-    let probe = null;
-    let reasonCode = null;
-    if (clientVersion !== null) {
-      try {
-        probe = await withTimeout(adapter.probeNativeDelivery({ realExecutable: identity.target,
-          timeoutMs }), timeoutMs, "native probe");
-      } catch (error) {
-        probe = null;
-        reasonCode = error?.code === "ETIMEDOUT" ? "probe_timeout" : "feature_probe_failed";
-      }
-    }
-    let eligibility;
-    try {
-      eligibility = evaluateNativeEligibility(adapter, { clientVersion, platform, probe });
-    } catch {
-      // A malformed probe is an adapter bug, and still not a reason to change
-      // the user's launch: it fails closed like any other probe failure.
-      eligibility = { eligible: false, reasonCode: "feature_probe_failed" };
-    }
-    const supported = eligibility.eligible === true;
-    // A probe that timed out or threw is reported as such rather than as the
-    // generic verdict the missing probe would otherwise produce.
-    const outcomeReason = supported ? null : (reasonCode ?? eligibility.reasonCode
-      ?? "feature_probe_failed");
-    // Only closed facts are stored: identity, versions, the eligibility verdict.
-    // Never command output, never a message body.
-    await saveCache(file, {
-      schemaVersion: BOOTSTRAP_CACHE_SCHEMA, adapterId: adapter.id, platform, identity,
-      accVersion: runtimeVersionKnown ? runtimeVersion : null,
-      clientVersion, supported, reasonCode: outcomeReason,
-      protocolContract: supported ? eligibility.protocolContract : null,
-      modes: supported ? [...eligibility.modes] : [],
-      checkedAt: new Date(now).toISOString(),
-      expiresAt: new Date(now + (supported ? SUPPORTED_TTL_MS : FAILED_TTL_MS)).toISOString(),
-    }).catch(() => null);
-    return closedOutcome(supported, outcomeReason);
-  } catch {
-    return closedOutcome(false, "feature_probe_failed");
-  }
-}