@minhspark/codex-mcp-bridge 1.23.0 → 1.24.1

package/src/antigravity-bridge.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { resolveCodexSenderContext } from "./codex-sender-context.mjs";
+import { readClaudeSenderContext, requireClaudeSenderContext, stopProcessInspectors } from "./claude-sender-context.mjs";
+import { readClaudeAccountContext } from "./desktop-account-context.mjs";
+import { createHardenedRootPolicy } from "./hardened-root-policy.mjs";
+import { antigravityBridgeDirectory, callAntigravityDesktop } from "./antigravity-ipc.mjs";
+import { AntigravityDeliveries } from "./antigravity-deliveries.mjs";
+import { AntigravityCliSession } from "./antigravity-cli.mjs";
+import { exitForVersionRequest } from "./cli-version.mjs";
+import { NativeDesktopRelay, desktopTaskSocketPath, accountRelaySocketPath } from "./native-relay.mjs";
+import { requireBridgeAccounts, readBridgeAccounts, assertAccountIdentity } from "./bridge-account-context.mjs";
+
+exitForVersionRequest(import.meta.url);
+
+const { version } = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const rootPolicy = createHardenedRootPolicy();
+const directory = antigravityBridgeDirectory();
+const deliveries = new AntigravityDeliveries(path.join(directory, "cli-deliveries"));
+const sessions = new Map();
+let startingSessions = 0;
+const caller = process.env.ANTIGRAVITY_BRIDGE_CALLER;
+const senderRelay = new NativeDesktopRelay({ socketPath: desktopTaskSocketPath(), accountSocketPath: accountRelaySocketPath() });
+const result = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
+const schema = { requestId: z.string().uuid(), cwd: z.string().min(1), prompt: z.string().min(1).max(65536) };
+
+async function sender(extra) {
+  if (caller === "codex") {
+    const context = await resolveCodexSenderContext(extra?._meta, { inspectDesktopTask: async (threadId) => {
+      const accounts = requireBridgeAccounts(readBridgeAccounts());
+      const { result } = await senderRelay.requestDesktop("read_thread", { threadId, hostId: "local", turnLimit: 1, includeOutputs: false, maxOutputCharsPerItem: 1 }, { accountContext: accounts, beforeSend: () => assertAccountIdentity(accounts) });
+      assertAccountIdentity(accounts);
+      return { thread: result?.thread, latestTurnId: result?.turns?.[0]?.id ?? null };
+    } });
+    if (context.status !== "verified") throw new Error(context.reason ?? "Unverified Codex sender");
+    return { provider: "codex", id: context.threadId, cwd: context.cwd };
+  }
+  if (caller === "claude") {
+    const context = requireClaudeSenderContext(await readClaudeSenderContext({ account: readClaudeAccountContext() }));
+    return { provider: "claude", id: context.sessionId, cwd: context.cwd };
+  }
+  throw new Error("Install this bridge for Codex or Claude; unknown callers cannot read conversations or send work");
+}
+
+function sameCwd(expected, actual) {
+  if (!path.isAbsolute(expected) || !path.isAbsolute(actual)) throw new Error("Expected an absolute project directory");
+  const left = fs.realpathSync.native(expected);
+  const right = fs.realpathSync.native(actual);
+  if (path.relative(left, right)) throw new Error("Antigravity destination must match the verified sender's project directory");
+  rootPolicy.assert(left, "Antigravity project");
+  return left;
+}
+
+function owns(record, identity) {
+  if (!record || record.sender?.provider !== identity.provider || record.sender?.id !== identity.id) throw new Error("Delivery does not belong to this sending conversation");
+  sameCwd(identity.cwd, record.cwd);
+  return record;
+}
+
+function handoff(prompt, identity) {
+  return `[Agent handoff from ${identity.provider} conversation ${identity.id}. Native Antigravity permissions remain in effect.]\n\n${prompt}`;
+}
+
+const server = new McpServer({ name: "antigravity-bridge", version }, { instructions: "Send authorized work to Antigravity Desktop through its native sidecar or to an explicitly created CLI streaming session. Always select the requested surface; never substitute CLI for Desktop. The exact destination directory must match the verified sending conversation. Desktop delivery acceptance is not an agent reply. CLI sessions are bridge-owned headless sessions, not attached interactive terminals. Preserve requestId across retries and read_antigravity_delivery after pending or unknown outcomes; never resend automatically. Native tool approvals remain in force. Do not claim support for Antigravity-origin handoffs into Codex or Claude; this server receives from those hosts." });
+
+function register(name, description, inputSchema, readOnly, handler) {
+  server.registerTool(name, { description, inputSchema, annotations: { readOnlyHint: readOnly, destructiveHint: !readOnly, idempotentHint: true, openWorldHint: !readOnly } }, async (args, extra) => {
+    try { return result(await handler(args, extra)); }
+    catch (error) { return { ...result({ error: error.message, deliveryState: error.deliveryState ?? "not_sent" }), isError: true }; }
+  });
+}
+
+register("antigravity_bridge_status", "Inspect connection capabilities without sending prompts.", {}, true, async () => {
+  let desktop;
+  try { desktop = await callAntigravityDesktop({ operation: "status" }, { timeoutMs: 5000 }); }
+  catch { desktop = { available: false, reason: "Open Antigravity with the installed codex-bridge sidecar enabled" }; }
+  return { version, caller: caller ?? "unconfigured", desktop, cli: { transport: "stream-json", activeSessions: sessions.size, permissionPolicy: "native-unchanged", interactiveTerminalAttachment: false } };
+});
+
+register("list_antigravity_conversations", "List native Desktop conversations and bridge-owned CLI sessions in the sending project.", { surface: z.enum(["desktop", "cli"]) }, true, async ({ surface }, extra) => {
+  const identity = await sender(extra);
+  const records = surface === "desktop" ? await callAntigravityDesktop({ operation: "list" }) : [...sessions.values()].map((entry) => ({ ...entry.session.read(), sender: entry.sender }));
+  return records.filter((record) => {
+    try { sameCwd(identity.cwd, record.cwd); return surface !== "cli" || record.sender.id === identity.id && record.sender.provider === identity.provider; }
+    catch { return false; }
+  });
+});
+
+register("send_to_antigravity_conversation", "Send one authorized prompt to an exact existing Desktop conversation or a bridge-owned CLI session. Retain requestId and poll the delivery receipt.", { ...schema, surface: z.enum(["desktop", "cli"]), conversationId: z.string().uuid() }, false, async (args, extra) => {
+  const identity = await sender(extra);
+  const cwd = sameCwd(identity.cwd, args.cwd);
+  const prompt = handoff(args.prompt, identity);
+  if (args.surface === "desktop" && (prompt.length > 30000 || prompt.includes("\0"))) throw new Error("Desktop handoff must fit within 30000 characters and contain no NUL");
+  if (args.surface === "desktop") return callAntigravityDesktop({ operation: "send", ...args, cwd, prompt, sender: identity });
+  const entry = sessions.get(args.conversationId);
+  if (!entry || entry.sender.id !== identity.id || entry.sender.provider !== identity.provider) throw new Error("CLI session is not owned by this sender and bridge process");
+  sameCwd(cwd, entry.session.read().cwd);
+  return deliveries.dispatch({ ...args, cwd, sender: identity, prompt }, async () => {
+    const current = await sender(extra);
+    sameCwd(cwd, current.cwd);
+    if (current.id !== identity.id) throw Object.assign(new Error("Sender changed before delivery"), { deliveryState: "not_sent" });
+    return entry.session.send(prompt);
+  });
+});
+
+register("start_antigravity_cli_session", "Create a new bridge-owned Antigravity CLI streaming session for explicitly authorized new work; sends the initial prompt and returns a durable delivery receipt.", schema, false, async (args, extra) => {
+  const identity = await sender(extra);
+  const cwd = sameCwd(identity.cwd, args.cwd);
+  if (sessions.size + startingSessions >= 4) throw new Error("At most four CLI sessions may be open in one bridge");
+  return deliveries.dispatch({ ...args, cwd, sender: identity, surface: "cli" }, async () => {
+    if (sessions.size + startingSessions >= 4) throw Object.assign(new Error("CLI session capacity reached"), { deliveryState: "not_sent" });
+    startingSessions++;
+    let reserved = true;
+    let session;
+    try {
+      const env = Object.fromEntries(Object.entries(process.env).filter(([name]) => !/^(?:CODEX_|CLAUDE|ANTHROPIC_|MCP_)/i.test(name)));
+      session = new AntigravityCliSession({ cwd, env });
+      const started = await session.start();
+      deliveries.identify(args.requestId, started.conversationId);
+      sessions.set(started.conversationId, { session, sender: identity });
+      startingSessions--;
+      reserved = false;
+      const current = await sender(extra);
+      sameCwd(cwd, current.cwd);
+      if (current.id !== identity.id) throw Object.assign(new Error("Sender changed before delivery"), { deliveryState: "not_sent" });
+      return await session.send(handoff(args.prompt, identity));
+    } catch (error) {
+      if (error.deliveryState !== "unknown") {
+        for (const [id, entry] of sessions) if (entry.session === session) sessions.delete(id);
+        await session?.close();
+      }
+      throw error;
+    } finally {
+      if (reserved) startingSessions--;
+    }
+  });
+});
+
+register("read_antigravity_delivery", "Read the original receipt without resending. Desktop accepted means the native API accepted it, not that the agent completed a turn.", { surface: z.enum(["desktop", "cli"]), requestId: z.string().uuid() }, true, async (args, extra) => {
+  const identity = await sender(extra);
+  const record = args.surface === "desktop" ? await callAntigravityDesktop({ operation: "receipt", requestId: args.requestId }) : deliveries.read(args.requestId);
+  return owns(record, identity);
+});
+
+register("close_antigravity_cli_session", "Close an idle bridge-owned CLI session belonging to the caller.", { conversationId: z.string().uuid() }, false, async ({ conversationId }, extra) => {
+  const identity = await sender(extra);
+  const entry = sessions.get(conversationId);
+  if (!entry || entry.sender.id !== identity.id || entry.sender.provider !== identity.provider) throw new Error("CLI session is not owned by this sender");
+  sameCwd(identity.cwd, entry.session.read().cwd);
+  if (["running", "starting"].includes(entry.session.read().status)) throw new Error("Wait for the active CLI delivery before closing");
+  const closed = await entry.session.close();
+  if (closed.status !== "closing") sessions.delete(conversationId);
+  return { closed: closed.status !== "closing", conversationId, status: closed.status };
+});
+
+let stopping = false;
+async function stop() {
+  if (stopping) return;
+  stopping = true;
+  await Promise.allSettled([...sessions.values()].map(({ session }) => session.close()));
+  await stopProcessInspectors();
+  await server.close();
+}
+for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => { void stop(); });
+process.stdin.once("end", () => { void stop(); });
+await server.connect(new StdioServerTransport());

package/src/antigravity-cli.mjs

@@ -0,0 +1,248 @@
+import { spawn as spawnProcess } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function failure(message, code, deliveryState = "not-sent") {
+  return Object.assign(new Error(message), { code, deliveryState });
+}
+
+function directory(value) {
+  if (typeof value !== "string" || !path.isAbsolute(value)) throw new Error("Antigravity CLI cwd must be an absolute directory");
+  const resolved = fs.realpathSync.native(value);
+  if (!fs.statSync(resolved).isDirectory()) throw new Error("Antigravity CLI cwd must be a directory");
+  return resolved;
+}
+
+function positive(value, fallback, name) {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result < 1) throw new Error(`${name} must be a positive integer`);
+  return result;
+}
+
+export function resolveAntigravityCliBinary({ binary, env = process.env, platform = process.platform } = {}) {
+  const selected = binary ?? env.ANTIGRAVITY_CLI_BIN;
+  const windows = platform === "win32";
+  const name = windows ? "agy.exe" : "agy";
+  const home = env.HOME ?? env.USERPROFILE ?? os.homedir();
+  const candidates = selected !== undefined ? [selected] : [
+    ...(windows ? [path.join(env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "agy", "bin", name)] : [path.join(home, ".local", "bin", name)]),
+    ...(env.PATH ?? env.Path ?? "").split(path.delimiter).filter((item) => path.isAbsolute(item)).map((item) => path.join(item, name)),
+  ];
+  if (selected !== undefined && (typeof selected !== "string" || !path.isAbsolute(selected))) throw new Error("Antigravity CLI binary must be an absolute executable path");
+  for (const candidate of candidates) {
+    try {
+      const resolved = fs.realpathSync.native(candidate);
+      if (!fs.statSync(resolved).isFile() || windows && !/\.exe$/i.test(resolved)) continue;
+      fs.accessSync(resolved, windows ? fs.constants.R_OK : fs.constants.X_OK);
+      return resolved;
+    } catch {}
+  }
+  throw new Error("Antigravity CLI executable was not found; set ANTIGRAVITY_CLI_BIN to its absolute path");
+}
+
+export class AntigravityCliSession {
+  constructor(options = {}) {
+    this.cwd = directory(options.cwd);
+    this.env = { ...(options.env ?? process.env) };
+    this.binary = resolveAntigravityCliBinary({ binary: options.binary, env: this.env });
+    this.spawn = options.spawn ?? spawnProcess;
+    this.requestedConversationId = options.conversationId ?? null;
+    if (this.requestedConversationId !== null && !UUID.test(this.requestedConversationId)) throw new Error("Invalid Antigravity conversation ID");
+    this.startupTimeoutMs = positive(options.startupTimeoutMs, 30000, "startupTimeoutMs");
+    this.turnTimeoutMs = positive(options.turnTimeoutMs, 600000, "turnTimeoutMs");
+    this.closeTimeoutMs = positive(options.closeTimeoutMs, 3000, "closeTimeoutMs");
+    this.maxFrameBytes = positive(options.maxFrameBytes, 2 * 1024 * 1024, "maxFrameBytes");
+    this.maxTurnBytes = positive(options.maxTurnBytes, 16 * 1024 * 1024, "maxTurnBytes");
+    this.status = "new";
+    this.conversationId = null;
+    this.permissionMode = null;
+    this.child = null;
+    this.pending = null;
+    this.awaitingResult = false;
+    this.lastResult = null;
+    this.lastError = null;
+    this.deliveryState = "not-sent";
+    this.turnBytes = 0;
+    this.buffer = "";
+    this.decoder = new StringDecoder("utf8");
+    this.exited = false;
+  }
+
+  read() {
+    return {
+      conversationId: this.conversationId,
+      cwd: this.cwd,
+      permissionMode: this.permissionMode,
+      pid: this.child?.pid ?? null,
+      status: this.status,
+      deliveryState: this.deliveryState,
+      result: this.lastResult ? structuredClone(this.lastResult) : null,
+      error: this.lastError ? { code: this.lastError.code, message: this.lastError.message } : null,
+    };
+  }
+
+  start() {
+    if (this.startPromise) return this.startPromise;
+    if (this.status !== "new") return Promise.reject(failure("Antigravity CLI session cannot be started", "SESSION_CLOSED"));
+    this.status = "starting";
+    this.startPromise = new Promise((resolve, reject) => {
+      this.startResolve = resolve;
+      this.startReject = reject;
+    });
+    this.startTimer = setTimeout(() => this.fail(failure("Antigravity CLI did not emit a valid init event before the deadline", "STARTUP_TIMEOUT")), this.startupTimeoutMs);
+    const args = ["--input-format", "stream-json", "--output-format", "stream-json"];
+    if (this.requestedConversationId) args.push("--conversation", this.requestedConversationId);
+    try {
+      this.child = this.spawn(this.binary, args, { cwd: this.cwd, env: this.env, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+      this.child.on("error", () => this.fail(failure("Antigravity CLI process failed", "PROCESS_ERROR", this.pending ? "unknown" : this.deliveryState)));
+      this.child.stdin.on("error", () => this.fail(failure("Antigravity CLI input pipe failed", "STDIN_ERROR", this.pending ? "unknown" : this.deliveryState)));
+      this.child.stdout.on("error", () => this.fail(failure("Antigravity CLI output pipe failed", "STDOUT_ERROR", this.pending ? "unknown" : this.deliveryState)));
+      this.child.stderr.on("error", () => this.fail(failure("Antigravity CLI diagnostic pipe failed", "STDERR_ERROR", this.pending ? "unknown" : this.deliveryState)));
+      this.child.stderr.resume();
+      this.child.stdout.on("data", (chunk) => this.consume(chunk));
+      this.child.on("close", (code, signal) => {
+        this.exited = true;
+        this.exitCode = code;
+        this.exitSignal = signal;
+        if (this.status === "starting" || this.pending) this.fail(failure("Antigravity CLI exited before completing the operation", "PROCESS_EXIT", this.pending ? "unknown" : this.deliveryState));
+        else if (!["failed", "unknown"].includes(this.status)) this.status = "closed";
+        this.closeResolve?.();
+      });
+    } catch {
+      this.fail(failure("Antigravity CLI could not be launched", "SPAWN_FAILED"));
+    }
+    return this.startPromise;
+  }
+
+  consume(chunk) {
+    if (["failed", "closed"].includes(this.status)) return;
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    this.turnBytes += bytes.length;
+    if (this.turnBytes > this.maxTurnBytes) return this.fail(failure("Antigravity CLI output exceeds its per-turn limit", "OUTPUT_LIMIT", this.pending ? "unknown" : this.deliveryState));
+    this.buffer += this.decoder.write(bytes);
+    let newline;
+    while ((newline = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, newline).replace(/\r$/, "");
+      this.buffer = this.buffer.slice(newline + 1);
+      if (Buffer.byteLength(line) > this.maxFrameBytes) return this.fail(failure("Antigravity CLI frame exceeds its limit", "FRAME_LIMIT", this.pending ? "unknown" : this.deliveryState));
+      if (!line.trim()) continue;
+      try { this.event(JSON.parse(line)); }
+      catch (error) { return this.fail(failure(error.message === "Invalid Antigravity event" ? error.message : "Antigravity CLI emitted invalid protocol data", "INVALID_PROTOCOL", this.pending ? "unknown" : this.deliveryState)); }
+      if (["failed", "closed"].includes(this.status)) return;
+    }
+    if (Buffer.byteLength(this.buffer) > this.maxFrameBytes) this.fail(failure("Antigravity CLI frame exceeds its limit", "FRAME_LIMIT", this.pending ? "unknown" : this.deliveryState));
+  }
+
+  event(event) {
+    if (!event || typeof event !== "object" || Array.isArray(event) || typeof event.event !== "string") throw new Error("Invalid Antigravity event");
+    if (event.event === "init") {
+      if (this.status !== "starting" || !UUID.test(event.conversation_id ?? "")
+          || this.requestedConversationId && event.conversation_id.toLowerCase() !== this.requestedConversationId.toLowerCase()
+          || directory(event.init?.cwd) !== this.cwd
+          || typeof event.init?.permission_mode !== "string" || !event.init.permission_mode || event.init.permission_mode.length > 128) throw new Error("Invalid Antigravity event");
+      this.conversationId = event.conversation_id;
+      this.permissionMode = event.init.permission_mode;
+      this.status = "idle";
+      clearTimeout(this.startTimer);
+      this.startResolve(this.read());
+      this.startResolve = null;
+      this.startReject = null;
+      return;
+    }
+    if (!this.conversationId) throw new Error("Invalid Antigravity event");
+    if (event.event !== "result") return;
+    const result = event.result;
+    if (!this.awaitingResult || !result || result.conversation_id !== this.conversationId
+        || typeof result.status !== "string" || !/^[A-Z][A-Z_]{0,127}$/.test(result.status)
+        || typeof result.response !== "string" || result.error !== undefined && typeof result.error !== "string") throw new Error("Invalid Antigravity event");
+    this.lastResult = { conversation_id: result.conversation_id, status: result.status, response: result.response, ...(result.error === undefined ? {} : { error: result.error }) };
+    this.awaitingResult = false;
+    this.deliveryState = "completed";
+    if (this.pending) {
+      const pending = this.pending;
+      this.pending = null;
+      clearTimeout(pending.timer);
+      this.status = "idle";
+      pending.resolve(structuredClone(this.lastResult));
+    }
+  }
+
+  async send(prompt) {
+    if (typeof prompt !== "string" || !prompt.trim()) throw failure("Antigravity prompt must be non-empty text", "INVALID_PROMPT");
+    const frame = `${JSON.stringify({ event: "user", message: { content: prompt } })}\n`;
+    if (Buffer.byteLength(frame) > this.maxFrameBytes) throw failure("Antigravity prompt exceeds its frame limit", "PROMPT_LIMIT");
+    await this.start();
+    if (this.status !== "idle" || this.pending) throw failure("Antigravity CLI session is busy, closed, or has an uncertain delivery; inspect its receipt instead of resending", "SESSION_UNAVAILABLE", this.deliveryState);
+    if (directory(this.cwd) !== this.cwd) throw failure("Antigravity CLI working directory changed", "CWD_CHANGED");
+    this.status = "running";
+    this.awaitingResult = true;
+    this.deliveryState = "unknown";
+    this.turnBytes = 0;
+    this.lastResult = null;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const pending = this.pending;
+        if (!pending) return;
+        this.pending = null;
+        this.status = "unknown";
+        this.lastError = failure("Antigravity CLI turn exceeded the observation deadline; it may still be running. Do not resend.", "TURN_TIMEOUT", "unknown");
+        pending.reject(this.lastError);
+      }, this.turnTimeoutMs);
+      this.pending = { resolve, reject, timer };
+      try {
+        this.child.stdin.write(frame, (error) => {
+          if (error) this.fail(failure("Antigravity CLI input write failed; delivery may have started", "STDIN_ERROR", "unknown"));
+        });
+      } catch {
+        this.fail(failure("Antigravity CLI input write failed; delivery may have started", "STDIN_ERROR", "unknown"));
+      }
+    });
+  }
+
+  fail(error) {
+    this.lastError = error;
+    this.deliveryState = error.deliveryState;
+    this.status = error.deliveryState === "unknown" ? "unknown" : "failed";
+    clearTimeout(this.startTimer);
+    this.startReject?.(error);
+    this.startResolve = null;
+    this.startReject = null;
+    if (this.pending) {
+      const pending = this.pending;
+      this.pending = null;
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    try { this.child?.kill(); } catch {}
+  }
+
+  close() {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.finishClose();
+    return this.closePromise;
+  }
+
+  async finishClose() {
+    if (!this.child || this.exited) {
+      this.status = "closed";
+      return this.read();
+    }
+    const closed = new Promise((resolve) => { this.closeResolve = resolve; });
+    try { this.child.stdin.end(); } catch {}
+    let timer;
+    await Promise.race([closed, new Promise((resolve) => { timer = setTimeout(resolve, this.closeTimeoutMs); })]);
+    clearTimeout(timer);
+    if (!this.exited) {
+      if (this.pending || this.status === "starting") this.fail(failure("Antigravity CLI session was closed before its operation completed", "SESSION_CLOSED", this.pending ? "unknown" : this.deliveryState));
+      else try { this.child.kill(); } catch {}
+      await Promise.race([closed, new Promise((resolve) => { timer = setTimeout(resolve, this.closeTimeoutMs); })]);
+      clearTimeout(timer);
+    }
+    this.status = this.exited ? "closed" : "closing";
+    return this.read();
+  }
+}

package/src/antigravity-deliveries.mjs

@@ -0,0 +1,93 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { ensureBridgeDirectory } from "./antigravity-ipc.mjs";
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+export class AntigravityDeliveries {
+  constructor(directory) {
+    this.directory = ensureBridgeDirectory(directory);
+    this.active = new Set();
+  }
+
+  file(requestId) {
+    if (!UUID.test(requestId)) throw new Error("requestId must be a UUID");
+    return path.join(this.directory, `${requestId}.json`);
+  }
+
+  read(requestId) {
+    const file = this.file(requestId);
+    let descriptor;
+    try { descriptor = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0)); }
+    catch (error) { if (error.code === "ENOENT") return null; throw error; }
+    let record;
+    try {
+      const stat = fs.lstatSync(file, { bigint: true });
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1n || stat.size > 4n * 1024n * 1024n) throw new Error("Invalid delivery record");
+      const opened = fs.fstatSync(descriptor, { bigint: true });
+      if (!opened.isFile() || opened.nlink !== 1n || opened.dev !== stat.dev || opened.ino !== stat.ino || opened.size !== stat.size || opened.mtimeNs !== stat.mtimeNs) throw new Error("Delivery record changed before reading");
+      const buffer = Buffer.alloc(Number(opened.size) + 1);
+      let bytes = 0;
+      while (bytes < buffer.length) {
+        const count = fs.readSync(descriptor, buffer, bytes, buffer.length - bytes, bytes);
+        if (!count) break;
+        bytes += count;
+      }
+      const after = fs.fstatSync(descriptor, { bigint: true });
+      if (bytes !== Number(opened.size) || after.size !== opened.size || after.mtimeNs !== opened.mtimeNs || after.ctimeNs !== opened.ctimeNs) throw new Error("Delivery record changed while reading");
+      record = JSON.parse(buffer.subarray(0, bytes).toString("utf8"));
+    } finally { fs.closeSync(descriptor); }
+    if (record.requestId !== requestId) throw new Error("Delivery identity mismatch");
+    if (record.status === "pending" && !this.active.has(requestId)) return { ...record, status: "unknown", reason: "This process cannot observe the original worker. Inspect the exact destination; do not resend." };
+    return record;
+  }
+
+  identify(requestId, conversationId) {
+    if (!UUID.test(conversationId) || !this.active.has(requestId)) throw new Error("Cannot bind inactive delivery");
+    const record = this.read(requestId);
+    record.conversationId = conversationId;
+    this.write(record);
+  }
+
+  write(record) {
+    const temporary = `${this.file(record.requestId)}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(record), { flag: "wx", mode: 0o600 });
+    fs.renameSync(temporary, this.file(record.requestId));
+  }
+
+  async dispatch(request, operation) {
+    const { requestId, ...identity } = request;
+    const digest = crypto.createHash("sha256").update(JSON.stringify(identity)).digest("hex");
+    const existing = this.read(requestId);
+    if (existing) {
+      if (existing.digest !== digest) throw new Error("requestId was already used for a different delivery");
+      return existing;
+    }
+    const record = { requestId, digest, status: "pending", cwd: request.cwd, sender: request.sender, conversationId: request.conversationId ?? null, surface: request.surface, createdAt: new Date().toISOString() };
+    try { fs.writeFileSync(this.file(requestId), JSON.stringify(record), { flag: "wx", mode: 0o600 }); }
+    catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      throw new Error("Delivery is owned by another process. Inspect requestId; do not resend.");
+    }
+    this.active.add(requestId);
+    void Promise.resolve().then(operation).then((result) => {
+      record.status = ["accepted", "sent_unconfirmed", "held", "refused"].includes(result?.status) ? result.status : result?.status && result.status !== "SUCCESS" ? "failed" : "completed";
+      record.result = result;
+      record.conversationId = result?.conversationId ?? result?.conversation_id ?? record.conversationId;
+    }, (error) => {
+      record.status = ["not_sent", "not-sent"].includes(error.deliveryState) ? "failed" : "unknown";
+      record.reason = error.message;
+      if (typeof error.msgId === "string" && UUID.test(error.msgId)) record.result = { msgId: error.msgId, completed: false };
+      if (error.accountContext) record.result = { ...record.result, accountContext: error.accountContext };
+    }).finally(() => {
+      record.finishedAt = new Date().toISOString();
+      try {
+        record.conversationId ??= this.read(requestId)?.conversationId;
+        this.write(record);
+      } catch (error) { process.stderr.write(`Could not persist Antigravity delivery outcome: ${error.code ?? "WRITE_FAILED"}\n`); }
+      this.active.delete(requestId);
+    });
+    return record;
+  }
+}