agent-runway 0.2.0

package/src/installs.mjs

@@ -0,0 +1,425 @@
+// Which copies of each agent exist on this machine.
+//
+// "Claude" or "Codex" is not a precise enough answer for an agent about to
+// spawn one: the same machine carries several, and they disagree. Measured
+// here, all four diverge — the Claude CLI on PATH is 2.1.241 while its VS Code
+// extension bundles 2.1.269, and the Codex CLI is 0.149.1 while its extension
+// runs 0.153.4. A model the extension offers may be unknown to the binary a
+// delegation would actually invoke.
+//
+// So the unit is the install, identified by its path, and a fingerprint that
+// changes whenever the file does.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+import * as cache from "./cache.mjs";
+
+const IS_WINDOWS = process.platform === "win32";
+const SPAWN = { encoding: "utf-8", windowsHide: true, timeout: 8000 };
+
+export const AGENTS = {
+  claude: {
+    label: "Claude Code",
+    binary: "claude",
+    vscode: { publisher: "anthropic.claude-code", bundled: ["resources", "native-binary"] },
+    // The desktop app keeps its own copies under a directory named for each
+    // version, so the version comes free from the path. Two sit side by side
+    // here, distinct from both the npm install and the VS Code extensions.
+    //
+    // These are the app's user-data directories, which is where the embedded
+    // binaries live whatever the install source: a Microsoft Store package and
+    // an installer put the app itself in different places, but both write their
+    // agent builds here, so the install method does not have to be detected.
+    //
+    // No Linux entry, and that is a finding rather than an omission: there is no
+    // Claude desktop app for Linux, so an earlier guess at ~/.config/Claude was
+    // a path that could never match. (Established in brainclaw's surface
+    // inventory, which classifies Claude on Linux as a web surface.)
+    //
+    // Only the Windows layout has been observed here; macOS follows Electron's
+    // user-data convention and says so.
+    desktop: {
+      win32: ["AppData", "Roaming", "Claude", "claude-code"],
+      darwin: ["Library", "Application Support", "Claude", "claude-code"],
+      verifiedOn: ["win32"],
+    },
+  },
+  codex: {
+    label: "OpenAI Codex",
+    binary: "codex",
+    vscode: { publisher: "openai.chatgpt", bundled: null },
+    // `codex app` launches a desktop build. Not installed on the machine this
+    // was written against — it conflicts with the VS Code extension over MCP
+    // definitions — so no layout is guessed at here rather than shipping a path
+    // nobody has verified.
+    desktop: null,
+  },
+  copilot: {
+    label: "GitHub Copilot",
+    binary: "copilot",
+    vscode: null, // Copilot Chat ships inside VS Code rather than as an extension
+    desktop: null,
+  },
+  // Spawnable with a model, unlike Antigravity, which is why it earns an entry
+  // even though its quota is not read separately: it shares Google's.
+  gemini: {
+    label: "Gemini CLI",
+    binary: "gemini",
+    vscode: null,
+    desktop: null,
+  },
+  antigravity: {
+    label: "Antigravity",
+    binary: "antigravity",
+    vscode: null,
+    desktop: null,
+  },
+};
+
+/**
+ * Where each CLI sits when PATH cannot be consulted.
+ *
+ * An MCP server is spawned by its client with a deliberately minimal
+ * environment — the official SDK passes only a small set of variables through —
+ * so `where` finds nothing and every PATH install disappears. Editor and
+ * desktop installs survive because they are found by absolute path; these give
+ * the CLIs the same footing.
+ *
+ * Every entry here was observed on a real machine rather than guessed.
+ */
+const KNOWN_LOCATIONS = {
+  win32: {
+    claude: ["AppData/Roaming/npm/node_modules/@anthropic-ai/claude-code/bin/claude.exe"],
+    codex: ["AppData/Local/Programs/OpenAI/Codex/bin/codex.exe"],
+    copilot: ["AppData/Roaming/npm/copilot.cmd"],
+    gemini: ["AppData/Roaming/npm/gemini.cmd"],
+    antigravity: ["AppData/Local/Programs/Antigravity/bin/antigravity.exe"],
+  },
+  // Unverified: this project has only ever run on Windows. The paths follow the
+  // usual global-npm and application conventions, and a miss simply yields no
+  // install rather than a wrong one.
+  darwin: {
+    claude: [".npm-global/bin/claude", "/usr/local/bin/claude"],
+    codex: [".codex/bin/codex", "/usr/local/bin/codex"],
+    copilot: [".npm-global/bin/copilot", "/usr/local/bin/copilot"],
+    gemini: [".npm-global/bin/gemini", "/usr/local/bin/gemini"],
+  },
+  linux: {
+    claude: [".npm-global/bin/claude", "/usr/local/bin/claude"],
+    codex: [".codex/bin/codex", "/usr/local/bin/codex"],
+    copilot: [".npm-global/bin/copilot", "/usr/local/bin/copilot"],
+    gemini: [".npm-global/bin/gemini", "/usr/local/bin/gemini"],
+  },
+};
+
+function knownLocation(agent, home, platform) {
+  for (const candidate of KNOWN_LOCATIONS[platform]?.[agent] ?? []) {
+    const file = path.isAbsolute(candidate) ? candidate : path.join(home, candidate);
+    if (fs.existsSync(file)) return file;
+  }
+  return null;
+}
+
+/**
+ * Resolve a binary on PATH without launching it.
+ *
+ * `where` returns every match, and the first is not always the usable one:
+ * `where codex` lists the real executable, an extensionless sh script and a
+ * .cmd launcher, and their order changes with PATH — under `npm run` the sh
+ * script came first, which Windows cannot spawn at all (EFTYPE). Rank by what
+ * can actually be executed rather than trusting the order.
+ */
+function onPath(binary) {
+  try {
+    const r = spawnSync(IS_WINDOWS ? "where" : "which", [binary], { ...SPAWN, timeout: 3000 });
+    if (r.status !== 0) return null;
+
+    const matches = (r.stdout ?? "").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    if (!IS_WINDOWS) return matches[0] ?? null;
+
+    const rank = (file) => (/\.exe$/i.test(file) ? 0 : /\.(cmd|bat)$/i.test(file) ? 1 : 2);
+    return [...matches].sort((a, b) => rank(a) - rank(b))[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * PATH usually hands back an npm shim, not the program.
+ *
+ * `where claude` returns a 308-byte shell script; the binary it launches is
+ * 337MB. Fingerprinting or scanning the shim would describe the wrong file
+ * entirely — and the shim never changes when the package is upgraded, so it is
+ * also useless as a cache key. The script names its target, so follow it.
+ */
+export function followShim(file) {
+  let size;
+  try {
+    size = fs.statSync(file).size;
+  } catch {
+    return file;
+  }
+  if (size > 64 * 1024) return file; // already a real binary
+
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return file;
+  }
+
+  const target = text.match(/node_modules[\/\\][^\s"'`]+?\.(?:exe|js|cjs|mjs)/)?.[0];
+  if (!target) return file;
+
+  const resolved = path.resolve(path.dirname(file), target.replace(/\\/g, "/"));
+  return fs.existsSync(resolved) ? resolved : file;
+}
+
+/**
+ * Identity of a file, cheap enough to call on every lookup.
+ *
+ * Used as the cache key for anything derived from a binary: size and mtime
+ * change on every upgrade, and also on a reinstall of the same version, which a
+ * reported version string would miss.
+ */
+export function fingerprint(file) {
+  try {
+    const s = fs.statSync(file);
+    return `${s.size}-${Math.round(s.mtimeMs)}`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * A version, cached against the file's fingerprint.
+ *
+ * Probing costs seconds — these binaries are hundreds of megabytes — but the
+ * answer only changes when the file does, whether that is a CLI upgrade or a
+ * new VS Code extension build. The fingerprint is the invalidation: a changed
+ * binary is a different key, so nothing expires and nothing goes stale.
+ */
+export function versionOf(file, { launcher = null, fp = fingerprint(file) } = {}) {
+  if (!fp) return probeVersion(launcher ?? file);
+
+  const key = `version-${path.basename(file)}-${fp}`;
+  const hit = cache.read(key, Infinity, Infinity);
+  if (hit) return hit.value;
+
+  // Probe through the launcher, because that is how the program is meant to be
+  // started — a loader script will not answer --version on its own — but key
+  // the result on the program, which is what actually changes on upgrade.
+  const version = probeVersion(launcher ?? file) ?? probeVersion(file);
+  // A null is cached too: without it, an agent that never reports a version
+  // would be re-probed on every call, which is the cost this exists to avoid.
+  cache.write(key, version ?? null);
+  return version;
+}
+
+/** Only spawn when a version is actually wanted: these binaries are hundreds of MB. */
+export function probeVersion(file) {
+  try {
+    const r = IS_WINDOWS
+      ? spawnSync(`"${file}" --version`, { ...SPAWN, shell: true })
+      : spawnSync(file, ["--version"], SPAWN);
+    if (r.status !== 0) return null;
+    return (r.stdout ?? "").trim().match(/(\d+\.\d+\.\d+)/)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+const vscodeDirs = (home) => {
+  const roots = [path.join(home, ".vscode", "extensions"), path.join(home, ".vscode-insiders", "extensions")];
+  const out = [];
+  for (const root of roots) {
+    try {
+      for (const entry of fs.readdirSync(root)) out.push({ root, entry });
+    } catch {
+      /* no such editor installed */
+    }
+  }
+  return out;
+};
+
+/**
+ * Desktop apps that keep one directory per version of the agent they embed.
+ *
+ * Claude Desktop does this under its user-data directory, which means a machine
+ * can carry several more copies than PATH and the editor extensions reveal —
+ * five for Claude here, against the three found before this was added.
+ */
+function desktopInstalls(spec, home, platform, binaryName) {
+  const segments = spec?.[platform];
+  if (!segments) return [];
+
+  const root = path.join(home, ...segments);
+  let versions;
+  try {
+    versions = fs.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory());
+  } catch {
+    return []; // app not installed, or a layout this has never seen
+  }
+
+  const exe = platform === "win32" ? `${binaryName}.exe` : binaryName;
+  const found = [];
+  for (const dir of versions) {
+    const file = path.join(root, dir.name, exe);
+    if (!fs.existsSync(file)) continue;
+    found.push({
+      path: file,
+      // The directory is named for the version, so no probe is needed.
+      version: /^\d+\.\d+\.\d+/.test(dir.name) ? dir.name : null,
+      verified: (spec.verifiedOn ?? []).includes(platform),
+    });
+  }
+  return found;
+}
+
+/** `anthropic.claude-code-2.1.269-win32-x64` -> "2.1.269" */
+function versionFromFolder(name, publisher) {
+  return name.startsWith(publisher + "-")
+    ? name.slice(publisher.length + 1).match(/^(\d+\.\d+\.\d+)/)?.[1] ?? null
+    : null;
+}
+
+function bundledBinary(dir, segments, binary) {
+  if (!segments) return null;
+  for (const name of [binary + ".exe", binary]) {
+    const candidate = path.join(dir, ...segments, name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/**
+ * The Codex extension ships per-platform binaries under bin/<target>/ with a
+ * manifest naming the version and entrypoint, which beats guessing at both.
+ * Its version is its own: 0.154.0-alpha.6.1 here, against 0.149.1 on PATH.
+ */
+function codexExtensionBinary(dir) {
+  const platforms = IS_WINDOWS ? ["windows-x86_64"] : ["linux-x86_64", "darwin-arm64", "darwin-x86_64"];
+  for (const platform of platforms) {
+    const base = path.join(dir, "bin", platform);
+    let manifest;
+    try {
+      manifest = JSON.parse(fs.readFileSync(path.join(base, "codex-package.json"), "utf8"));
+    } catch {
+      continue;
+    }
+    // The entrypoint is written as "bin/codex.exe" but the platform directory
+    // IS that bin: joining the two produced bin/windows-x86_64/bin/codex.exe,
+    // which does not exist, and made a binary that was present look missing.
+    // Resolve by filename inside the platform directory, keeping the literal
+    // join as a fallback in case a future layout means it.
+    const name = manifest.entrypoint ? path.basename(manifest.entrypoint) : null;
+    const entry = [
+      name ? path.join(base, name) : null,
+      manifest.entrypoint ? path.join(base, manifest.entrypoint) : null,
+    ].find((candidate) => candidate && fs.existsSync(candidate));
+
+    return {
+      path: entry ?? base,
+      version: manifest.version ?? null,
+      resolved: Boolean(entry),
+    };
+  }
+  return null;
+}
+
+/**
+ * @param {object} [options]
+ * @param {boolean} [options.withVersions] probe PATH binaries for a version string; costs seconds
+ * @returns {Array<{agent, label, kind, path, version, fingerprint}>}
+ */
+export function discoverInstalls({
+  home = os.homedir(),
+  platform = process.platform,
+  withVersions = false,
+  agents,
+} = {}) {
+  const wanted = agents?.length ? agents : Object.keys(AGENTS);
+  const found = [];
+
+  for (const id of wanted) {
+    const spec = AGENTS[id];
+    if (!spec) continue;
+
+    for (const app of desktopInstalls(spec.desktop, home, platform, spec.binary)) {
+      found.push({
+        agent: id,
+        label: spec.label,
+        kind: "desktop",
+        path: app.path,
+        version: app.version,
+        layoutVerified: app.verified,
+        fingerprint: fingerprint(app.path),
+      });
+    }
+
+    // A PATH match is not automatically usable. On Windows an extensionless
+    // entry is a POSIX shell script that Windows cannot spawn at all (EFTYPE),
+    // and `where codex` lists one alongside the real executable. Prefer a known
+    // location over a match that cannot be launched, rather than only falling
+    // back when PATH finds nothing.
+    const fromPath = onPath(spec.binary);
+    const launchable = !fromPath || platform !== "win32" || /\.(exe|cmd|bat)$/i.test(fromPath);
+    const shim = (launchable ? fromPath : null) ?? knownLocation(id, home, platform) ?? fromPath;
+
+    if (shim) {
+      // Fingerprint the program, not the launcher: the shim is unchanged by an
+      // upgrade, so keying a cache on it would never invalidate.
+      const real = followShim(shim);
+      found.push({
+        agent: id,
+        label: spec.label,
+        kind: "path",
+        path: real,
+        launcher: real === shim ? null : shim,
+        version: withVersions ? versionOf(real, { launcher: shim }) : null,
+        fingerprint: fingerprint(real),
+      });
+    }
+
+    if (!spec.vscode) continue;
+    for (const { root, entry } of vscodeDirs(home)) {
+      const version = versionFromFolder(entry, spec.vscode.publisher);
+      if (!version) continue;
+      const dir = path.join(root, entry);
+      const codex = id === "codex" ? codexExtensionBinary(dir) : null;
+      const binary = codex?.path ?? bundledBinary(dir, spec.vscode.bundled, spec.binary);
+      found.push({
+        agent: id,
+        label: spec.label,
+        kind: "vscode",
+        path: binary ?? dir,
+        // Free: the extension folder carries a version, and Codex's manifest
+        // carries the more precise one for the binary it actually ships.
+        version: codex?.version ?? version,
+        extensionVersion: version,
+        fingerprint: binary && codex?.resolved !== false ? fingerprint(binary) : null,
+      });
+    }
+  }
+
+  return found;
+}
+
+/** Group by agent, so a caller can see the disagreement at a glance. */
+export function byAgent(installs) {
+  const map = new Map();
+  for (const i of installs) {
+    if (!map.has(i.agent)) map.set(i.agent, []);
+    map.get(i.agent).push(i);
+  }
+  return map;
+}
+
+/** True when an agent has installs that do not agree on a version. */
+export function hasVersionSkew(installs) {
+  const versions = new Set(installs.map((i) => i.version).filter(Boolean));
+  return versions.size > 1;
+}

package/src/mcp.mjs

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+// MCP stdio server: the same three questions the CLI answers, exposed as tools
+// an agent can call for itself.
+//
+// Deliberately dependency-free: a Claude Code plugin installed from git is not
+// npm-installed, so anything imported here would have to be vendored. The
+// protocol surface needed is small, and scripts/smoke-mcp.mjs drives it with
+// the official SDK client so the hand-rolled framing stays honest.
+//
+// stdout carries the JSON-RPC stream. Nothing else may ever be written to it;
+// diagnostics go to stderr.
+
+import { createInterface } from "node:readline";
+
+import { VERSION } from "./core.mjs";
+
+const SUPPORTED_PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+const DEFAULT_PROTOCOL = SUPPORTED_PROTOCOLS[0];
+
+const PROVIDERS = ["claude", "codex", "copilot", "antigravity"];
+const SPAWNABLE_AGENTS = ["claude", "codex", "copilot"];
+
+// Permissive on purpose: these payloads describe undocumented upstreams that
+// can grow a field without warning, and a strict schema would turn that into a
+// client-side validation error rather than an extra key nobody reads.
+const LOOSE = { type: "object", additionalProperties: true };
+
+const TOOLS = [
+  {
+    name: "get_usage",
+    title: "Read remaining runway",
+    description:
+      "How much quota is left on each coding agent signed in on this machine: " +
+      "percentage consumed of every rate-limit window, and when each resets. " +
+      "Covers Claude, Codex, GitHub Copilot and Antigravity, each read with the " +
+      "credentials that agent already keeps. One provider failing never stops " +
+      "the others. Use before a long task or a fan-out of subagents. Returns no " +
+      "credentials.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: {
+          type: "string",
+          enum: [...PROVIDERS, "all"],
+          description: "Which agent to read. Defaults to all of them.",
+        },
+      },
+      additionalProperties: false,
+    },
+    outputSchema: {
+      type: "object",
+      properties: { providers: { type: "array", items: LOOSE } },
+      required: ["providers"],
+      additionalProperties: true,
+    },
+  },
+  {
+    name: "check_capacity",
+    title: "Decide whether there is room to work",
+    description:
+      "Answers whether work can start now, rather than reporting numbers to " +
+      "interpret. Each provider comes back as proceed, defer or unknown - three " +
+      "outcomes because an agent that cannot be read has not got room, it is " +
+      "simply unknown. Defer carries the time its binding window resets, which " +
+      "is when the window rolls over and not a promise that service resumes " +
+      "exactly then. The recommendation states its own rule and whether the " +
+      "candidates were comparable at all: 0% of a five-hour window is not 0% of " +
+      "a monthly allowance.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        threshold: {
+          type: "number",
+          minimum: 0,
+          maximum: 100,
+          description:
+            "Percent consumed above which to defer. A policy, not a fact: at 92% " +
+            "the provider is not blocked, your rule says do not start. Default 90.",
+        },
+      },
+      additionalProperties: false,
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        threshold: { type: "number" },
+        providers: { type: "array", items: LOOSE },
+        anyUnknown: { type: "boolean" },
+      },
+      required: ["threshold", "providers", "anyUnknown"],
+      additionalProperties: true,
+    },
+  },
+  {
+    name: "list_models",
+    title: "Which models an installed agent will accept",
+    description:
+      "Before spawning another agent, the slug its binary actually accepts. A " +
+      "machine carries several builds of the same agent - a CLI on PATH, one " +
+      "inside a VS Code extension, one inside a desktop app - and they disagree: " +
+      "a model offered by one is rejected by another. Each catalogue says how it " +
+      "was obtained, declared when the binary was asked and answered, inferred " +
+      "when identifiers were read out of it. Treat inferred as strong evidence " +
+      "rather than a contract, and be ready for a spawn to fail anyway. Also " +
+      "reports which installs disagree.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agent: {
+          type: "string",
+          enum: SPAWNABLE_AGENTS,
+          description:
+            "Restrict to one agent. Only agents that can be spawned with a model " +
+            "argument are covered; an IDE is not one of them.",
+        },
+      },
+      additionalProperties: false,
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        catalogues: { type: "array", items: LOOSE },
+        skew: { type: "array", items: LOOSE },
+      },
+      required: ["catalogues", "skew"],
+      additionalProperties: true,
+    },
+  },
+];
+
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+const reply = (id, result) => send({ jsonrpc: "2.0", id, result });
+const replyError = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
+
+const answer = (text, structuredContent) => ({ content: [{ type: "text", text }], structuredContent });
+
+// ------------------------------------------------------------------ handlers
+
+async function getUsage(args) {
+  const { readAll } = await import("./providers/index.mjs");
+  const { renderProviders } = await import("./render.mjs");
+
+  const wanted = args?.provider && args.provider !== "all" ? [args.provider] : undefined;
+  const providers = await readAll(wanted ? { providers: wanted } : {});
+
+  return answer(renderProviders(providers), { providers });
+}
+
+async function checkCapacity(args) {
+  const { readAll, capacity } = await import("./providers/index.mjs");
+  const decision = capacity(await readAll(), { threshold: args?.threshold ?? 90 });
+
+  const lines = decision.providers.map(
+    (p) => `${p.provider}: ${p.decision}${p.binding ? ` (${p.binding.label} ${p.binding.percentUsed}%)` : ""}` +
+      `${p.retryAt ? ` - retry at ${p.retryAt}` : ""}`
+  );
+  if (decision.recommended) {
+    lines.push("");
+    lines.push(
+      `recommended: ${decision.recommended.provider}, ${decision.recommended.percentUsed}% of ` +
+        `${decision.recommended.window}` +
+        (decision.recommended.comparable ? "" : " (candidates are not directly comparable)")
+    );
+  }
+  return answer(lines.join("\n"), decision);
+}
+
+async function listModels(args) {
+  const [{ discoverInstalls }, models, { renderModels }] = await Promise.all([
+    import("./installs.mjs"),
+    import("./models.mjs"),
+    import("./render.mjs"),
+  ]);
+
+  const installs = discoverInstalls({ withVersions: true }).filter(
+    (i) => models.SPAWNABLE.includes(i.agent) && (!args?.agent || i.agent === args.agent)
+  );
+  const catalogues = await models.modelsForAll(installs);
+  const skew = models.modelSkew(catalogues);
+
+  return answer(renderModels(catalogues, skew), { catalogues, skew });
+}
+
+const HANDLERS = { get_usage: getUsage, check_capacity: checkCapacity, list_models: listModels };
+
+async function callTool(params) {
+  const handler = HANDLERS[params?.name];
+  if (!handler) return null;
+
+  try {
+    return await handler(params.arguments ?? {});
+  } catch (error) {
+    // A failed lookup is a tool-level error, not a protocol one: the client
+    // should surface it to the model rather than tear down the connection.
+    return { content: [{ type: "text", text: `Failed: ${error?.message ?? error}` }], isError: true };
+  }
+}
+
+// ------------------------------------------------------------------ protocol
+
+async function handle(message) {
+  const { id, method, params } = message;
+  const isNotification = id === undefined || id === null;
+
+  switch (method) {
+    case "initialize": {
+      const requested = params?.protocolVersion;
+      const protocolVersion = SUPPORTED_PROTOCOLS.includes(requested) ? requested : DEFAULT_PROTOCOL;
+      reply(id, {
+        protocolVersion,
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: "agent-runway", version: VERSION },
+      });
+      return;
+    }
+
+    case "notifications/initialized":
+    case "notifications/cancelled":
+      return; // notifications take no response
+
+    case "ping":
+      reply(id, {});
+      return;
+
+    case "tools/list":
+      reply(id, { tools: TOOLS });
+      return;
+
+    case "tools/call": {
+      const result = await callTool(params);
+      if (!result) return replyError(id, -32602, `Unknown tool: ${params?.name}`);
+      reply(id, result);
+      return;
+    }
+
+    default:
+      if (!isNotification) replyError(id, -32601, `Method not found: ${method}`);
+  }
+}
+
+const input = createInterface({ input: process.stdin });
+
+// A tools/call does network and process work, so a request can still be in
+// flight when stdin closes. Track them and drain before exiting, otherwise
+// piped input loses the response.
+const inFlight = new Set();
+
+input.on("line", (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+
+  let message;
+  try {
+    message = JSON.parse(trimmed);
+  } catch {
+    send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+    return;
+  }
+
+  const pending = handle(message)
+    .catch((error) => {
+      process.stderr.write(`agent-runway-mcp: ${error?.stack ?? error}\n`);
+      if (message?.id != null) replyError(message.id, -32603, "Internal error");
+    })
+    .finally(() => inFlight.delete(pending));
+
+  inFlight.add(pending);
+});
+
+input.on("close", async () => {
+  await Promise.allSettled([...inFlight]);
+  // No process.exit() here: it tears down stdout mid-write, which aborts the
+  // process on Windows. With stdin closed and nothing pending, the event loop
+  // empties and Node exits once the last write has flushed.
+  process.exitCode = 0;
+});