@minhspark/codex-mcp-bridge 1.23.0 → 1.24.0

package/src/antigravity-outbound-bridge.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { resolveAntigravitySenderContext } from "./antigravity-sender-context.mjs";
+import { createAntigravityOutboundTargets } from "./antigravity-outbound-targets.mjs";
+import { AntigravityDeliveries } from "./antigravity-deliveries.mjs";
+import { antigravityBridgeDirectory } from "./antigravity-ipc.mjs";
+import { createHardenedRootPolicy } from "./hardened-root-policy.mjs";
+import { stopProcessInspectors } from "./claude-sender-context.mjs";
+import { exitForVersionRequest } from "./cli-version.mjs";
+import { assertAccountIdentity } from "./bridge-account-context.mjs";
+
+const { version } = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const result = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
+const targetSchema = { target: z.enum(["codex", "claude"]) };
+const taskSchema = { ...targetSchema, conversationId: z.string().uuid(), taskId: z.string().min(1).max(256).optional() };
+
+export function createAntigravityOutboundBridge({ resolveSender = resolveAntigravitySenderContext, targets = createAntigravityOutboundTargets(), deliveries = new AntigravityDeliveries(path.join(antigravityBridgeDirectory(), "outbound-deliveries")), rootPolicy = createHardenedRootPolicy() } = {}) {
+  const server = new McpServer({ name: "agent-bridge", version }, { instructions: "Send user-authorized work FROM the current Antigravity Desktop conversation to an exact existing Codex Desktop task or Claude Desktop Code session in the same project. Use list_agent_tasks first, verify title and identity, then send_to_agent_task with a fresh requestId. Keep requestId after uncertainty and read_agent_delivery; never automatically resend. Native permissions and sender identity are verified on every call. Do not launch a CLI substitute, impersonate Codex/Claude, or change permissions to overcome a rejection. Native acceptance is not task completion; read_agent_task for Codex or read_agent_delivery for a Claude reply. Independent new work requires a separate native conversation; this bridge only continues existing tasks. Agent-authored handoffs must be in English and name Antigravity as the author." });
+
+  function scope(expected, actual) {
+    if (!path.isAbsolute(expected) || !path.isAbsolute(actual)) throw new Error("An absolute project directory is required");
+    const canonical = fs.realpathSync.native(expected);
+    if (path.relative(canonical, fs.realpathSync.native(actual))) throw new Error("Destination must match the verified Antigravity sender's project");
+    rootPolicy.assert(canonical, "Antigravity sender project");
+    return canonical;
+  }
+
+  async function sender(extra) {
+    const identity = await resolveSender(extra?._meta);
+    if (identity.status !== "verified" || identity.provider !== "antigravity" || !identity.id || !["bypass", "prompting"].includes(identity.mode)) throw new Error(identity.reason ?? "Antigravity sender is not verified");
+    scope(identity.cwd, identity.cwd);
+    return identity;
+  }
+
+  function recheck(identity, extra) {
+    return async () => {
+      const current = await sender(extra);
+      if (JSON.stringify(current) !== JSON.stringify(identity)) throw Object.assign(new Error("Antigravity sender identity or permissions changed before delivery"), { deliveryState: "not_sent" });
+    };
+  }
+
+  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("agent_bridge_status", "Check this Antigravity caller's native identity and outbound bridge capabilities without sending work.", {}, true, async (_, extra) => {
+    const identity = await resolveSender(extra?._meta);
+    const metadataFields = Object.fromEntries(Object.entries(extra?._meta ?? {}).filter(([key]) => key.startsWith("antigravity.google/")).map(([key, value]) => [key, Array.isArray(value) ? "array" : typeof value]));
+    return { version, sender: identity, metadataFields, targets: ["codex-desktop", "claude-desktop"], permissions: "native-unchanged", createsConversations: false };
+  });
+
+  register("list_agent_tasks", "List exact existing native tasks in this Antigravity conversation's project before selecting a destination.", targetSchema, true, async (args, extra) => {
+    const identity = await sender(extra);
+    return targets.list({ ...args, sender: identity, beforeSend: recheck(identity, extra) });
+  });
+
+  register("send_to_agent_task", "Continue an exact existing Codex or Claude Desktop task with authorized work. Preserve requestId across retries; inspect the durable receipt.", { ...taskSchema, requestId: z.string().uuid(), cwd: z.string().min(1), prompt: z.string().min(1).max(30000) }, false, async (args, extra) => {
+    const identity = await sender(extra);
+    const cwd = scope(identity.cwd, args.cwd);
+    if (args.prompt.includes("\0")) throw new Error("Prompt must not contain NUL");
+    const prompt = `[From Antigravity Desktop · ${path.basename(cwd)} · Authorized task handoff]\n[Source conversation: ${identity.id}]\n\n${args.prompt}`;
+    return deliveries.dispatch({ ...args, cwd, surface: args.target, sender: { provider: identity.provider, id: identity.id }, prompt }, async () => {
+      await recheck(identity, extra)();
+      const sent = await targets.send({ ...args, cwd, prompt, sender: identity, ...(args.target === "codex" ? { threadId: args.conversationId } : { sessionId: args.conversationId }), beforeSend: recheck(identity, extra) });
+      return { ...sent, completed: false };
+    });
+  });
+
+  register("read_agent_delivery", "Read an owned delivery without resending. Accepted or pending does not prove a completed response.", { requestId: z.string().uuid() }, true, async ({ requestId }, extra) => {
+    const identity = await sender(extra);
+    const record = deliveries.read(requestId);
+    if (!record || record.sender?.provider !== "antigravity" || record.sender.id !== identity.id) throw new Error("Delivery does not belong to this Antigravity conversation");
+    scope(identity.cwd, record.cwd);
+    if (record.result?.accountContext) assertAccountIdentity(record.result.accountContext);
+    if (record.surface === "claude" && record.result?.msgId) {
+      try {
+        return { ...record, nativeReceipt: await targets.read({ target: "claude", msgId: record.result.msgId, sender: identity, beforeSend: recheck(identity, extra) }) };
+      } catch (error) {
+        if (error.code !== "ANTIGRAVITY_NATIVE_RECEIPT_UNAVAILABLE") throw error;
+        return { ...record, nativeReceipt: null, recovery: "The original native receipt is unavailable. Inspect the exact Claude Desktop task before further action; do not resend.", receiptError: error.message };
+      }
+    }
+    return record;
+  });
+
+  register("read_agent_task", "Read the exact destination task's current native state and available response in the same project.", taskSchema, true, async (args, extra) => {
+    const identity = await sender(extra);
+    return targets.read({ ...args, cwd: identity.cwd, sender: identity, ...(args.target === "codex" ? { threadId: args.conversationId } : { sessionId: args.conversationId }), beforeSend: recheck(identity, extra) });
+  });
+
+  return { server, close: async () => { await targets.close(); await server.close(); } };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  exitForVersionRequest(import.meta.url);
+  const bridge = createAntigravityOutboundBridge();
+  let stopping = false;
+  const stop = async () => {
+    if (stopping) return;
+    stopping = true;
+    await bridge.close();
+    await stopProcessInspectors();
+  };
+  for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => { void stop(); });
+  process.stdin.once("end", () => { void stop(); });
+  await bridge.server.connect(new StdioServerTransport());
+}

package/src/antigravity-outbound-targets.mjs

@@ -0,0 +1,244 @@
+import fs from "node:fs";
+import path from "node:path";
+import { NativeDesktopRelay, desktopTaskSocketPath, accountRelaySocketPath } from "./native-relay.mjs";
+import { readBridgeAccounts, requireBridgeAccounts, assertAccountIdentity } from "./bridge-account-context.mjs";
+import { PeerEndpoint, listClaudeSessions, assertClaudeSessionProcess } from "./peer-protocol.mjs";
+import { readClaudeDesktopContext } from "./claude-desktop-context.mjs";
+import { readClaudeInboundPolicy } from "./claude-inbound-policy.mjs";
+import { assertRecipientClass } from "./recipient-preflight.mjs";
+import { sameClaudeDesktopRecipient } from "./claude-session-router.mjs";
+import { createHardenedRootPolicy } from "./hardened-root-policy.mjs";
+import { protectCurrentUserPipe } from "./windows-pipe-acl.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;
+
+function blocked(message) {
+  return Object.assign(new Error(message), { deliveryState: "not_sent" });
+}
+
+function captureDirectory(value) {
+  if (typeof value !== "string" || !path.isAbsolute(value)) throw blocked("An absolute existing project directory is required");
+  const canonical = fs.realpathSync.native(value);
+  const stat = fs.statSync(canonical, { bigint: true });
+  if (!stat.isDirectory()) throw blocked("The project path must be a directory");
+  return { path: canonical, identity: `${stat.dev}:${stat.ino}:${stat.birthtimeNs}` };
+}
+
+function sameDirectory(left, right) {
+  return path.relative(left, right) === "";
+}
+
+function senderIdentity(sender) {
+  if (sender?.provider !== "antigravity" || !UUID.test(sender.id ?? "") || sender.conversationId !== sender.id
+      || !["bypass", "prompting"].includes(sender.mode) || typeof sender.permissionFingerprint !== "string" || !sender.permissionFingerprint) {
+    throw blocked("Verified Antigravity conversation identity and permission evidence are required");
+  }
+  return Object.freeze({ provider: sender.provider, id: sender.id, conversationId: sender.conversationId, cwd: sender.cwd, mode: sender.mode, permissionFingerprint: sender.permissionFingerprint });
+}
+
+export function createAntigravityOutboundTargets(options = {}) {
+  const env = options.env ?? process.env;
+  const relay = options.relay ?? new NativeDesktopRelay({ env, socketPath: desktopTaskSocketPath(env), accountSocketPath: accountRelaySocketPath(env) });
+  const readAccounts = options.readAccounts ?? readBridgeAccounts;
+  const assertAccounts = options.assertAccounts ?? ((identity) => assertAccountIdentity(identity, readAccounts()));
+  const listSessions = options.listSessions ?? listClaudeSessions;
+  const readContext = options.readContext ?? ((session, account) => readClaudeDesktopContext(session, { account }));
+  const readInbound = options.readInbound ?? readClaudeInboundPolicy;
+  const assertProcess = options.assertProcess ?? assertClaudeSessionProcess;
+  const roots = options.roots ?? createHardenedRootPolicy(env);
+  const peerFactory = options.peerFactory ?? ((settings) => new PeerEndpoint(settings));
+  const receipts = new Map();
+  let peer;
+  let closed = false;
+
+  function operation(sender, beforeSend, required = false) {
+    if (closed) throw blocked("Antigravity outbound targets have been closed");
+    if (required && typeof beforeSend !== "function") throw blocked("A live Antigravity sender revalidation callback is required");
+    const identity = senderIdentity(sender);
+    const cwd = captureDirectory(identity.cwd);
+    const root = roots.capture(cwd.path, "Antigravity sender project");
+    const accounts = readAccounts();
+    const accountContext = requireBridgeAccounts(accounts);
+    const check = async () => {
+      if (closed) throw blocked("Antigravity outbound targets have been closed");
+      assertAccounts(accountContext);
+      roots.recheck(root, "Antigravity sender project");
+      const current = captureDirectory(identity.cwd);
+      if (!sameDirectory(current.path, cwd.path) || current.identity !== cwd.identity) throw blocked("Antigravity sender project changed before delivery");
+      const refreshed = await beforeSend?.();
+      if (refreshed?.provider && JSON.stringify(senderIdentity(refreshed)) !== JSON.stringify(identity)) throw blocked("Antigravity sender identity or permissions changed before delivery");
+      assertAccounts(accountContext);
+    };
+    return { identity, cwd: cwd.path, accounts, accountContext, check };
+  }
+
+  async function request(context, name, args, beforeSend = context.check) {
+    const response = await relay.requestDesktop(name, args, { accountContext: context.accountContext, beforeSend });
+    try { await context.check(); }
+    catch (error) { if (name === "send_message_to_thread") error.deliveryState = "unknown"; throw error; }
+    return response.result;
+  }
+
+  async function projects(context) {
+    const result = await request(context, "list_projects", {});
+    if (!Array.isArray(result?.projects)) throw blocked("Native Codex saved projects are unavailable");
+    const matches = result.projects.filter((project) => {
+      try { return project.projectKind === "local" && project.hostId === "local" && typeof project.projectId === "string" && project.projectId && sameDirectory(captureDirectory(project.path).path, context.cwd); }
+      catch { return false; }
+    });
+    if (matches.length !== 1 || result.projects.filter((project) => project.projectId === matches[0].projectId).length !== 1) throw blocked("Sender project must match exactly one saved local Codex project");
+    return matches[0];
+  }
+
+  function threadRecord(thread, threadId, project, context, requireProjectId = true) {
+    if (thread?.id !== threadId || thread.kind !== "codex" || thread.hostId !== "local"
+        || (requireProjectId || thread.projectId !== undefined) && thread.projectId !== project.projectId
+        || !sameDirectory(captureDirectory(thread.cwd).path, context.cwd)) throw blocked("Exact Codex task does not belong to the current account's matching saved project");
+    return { threadId, projectId: project.projectId, cwd: context.cwd, title: thread.title ?? null, status: thread.status ?? null, hostId: "local", target: "codex" };
+  }
+
+  async function codexRecipient(context, threadId) {
+    if (!UUID.test(threadId ?? "")) throw blocked("An exact existing Codex task UUID is required");
+    const project = await projects(context);
+    const inventory = await request(context, "list_threads", { limit: 50 });
+    if (!Array.isArray(inventory?.threads) || !Array.isArray(inventory?.pinnedThreads ?? [])) throw blocked("Native Codex task inventory is unavailable");
+    const matches = [...(inventory.pinnedThreads ?? []), ...inventory.threads].filter((thread) => thread?.id === threadId);
+    if (!matches.length) throw blocked("Exact Codex task must be an existing recent or pinned task");
+    for (const thread of matches) threadRecord(thread, threadId, project, context);
+    const result = await request(context, "read_thread", { threadId, hostId: "local", turnLimit: 1, includeOutputs: false, maxOutputCharsPerItem: 1 });
+    return threadRecord(result?.thread, threadId, project, context, false);
+  }
+
+  function claudeRecipient(context, sessionId, taskId) {
+    if (typeof sessionId !== "string" || !sessionId || typeof taskId !== "string" || !taskId) throw blocked("Exact Claude sessionId and native taskId are required");
+    const candidates = listSessions().filter((session) => session.sessionId === sessionId);
+    if (candidates.length !== 1) throw blocked("Exact Claude session is missing or ambiguous");
+    const session = candidates[0];
+    if (!session.alive || session.entrypoint !== "claude-desktop" || !session.socket || !sameDirectory(captureDirectory(session.cwd).path, context.cwd)) throw blocked("Claude destination must be a live Desktop Code session in the sender project");
+    assertProcess(session);
+    const desktop = readContext(session, context.accounts.claude);
+    if (desktop?.status !== "matched" || desktop.taskId !== taskId || desktop.accountFingerprint !== context.accountContext.claude
+        || !sameDirectory(captureDirectory(desktop.cwd).path, context.cwd)) throw blocked("Claude native task identity or current account does not match");
+    return { ...session, desktop, inbound: readInbound(session.cwd) };
+  }
+
+  async function list({ target, sender, beforeSend } = {}) {
+    const context = operation(sender, beforeSend);
+    await context.check();
+    if (target === "codex") {
+      const project = await projects(context);
+      const result = await request(context, "list_threads", { limit: 50 });
+      if (!Array.isArray(result?.threads) || !Array.isArray(result?.pinnedThreads ?? [])) throw blocked("Native Codex task inventory is unavailable");
+      const records = [];
+      const seen = new Set();
+      for (const thread of [...(result.pinnedThreads ?? []), ...result.threads]) {
+        if (seen.has(thread?.id)) continue;
+        try {
+          const row = threadRecord(thread, thread.id, project, context);
+          if (!UUID.test(row.threadId)) continue;
+          records.push(row);
+          seen.add(thread.id);
+        } catch {}
+      }
+      return records;
+    }
+    if (target !== "claude") throw blocked("Target must be codex or claude");
+    const rows = [];
+    for (const session of listSessions()) {
+      try {
+        const desktop = readContext(session, context.accounts.claude);
+        const verified = claudeRecipient(context, session.sessionId, desktop?.taskId);
+        rows.push({ target: "claude", sessionId: verified.sessionId, taskId: verified.desktop.taskId, cwd: context.cwd, title: verified.desktop.title ?? null, permissionClass: verified.desktop.permissionClass ?? null, inboundPolicy: verified.inbound?.value ?? null });
+      } catch {}
+    }
+    await context.check();
+    return rows;
+  }
+
+  async function send({ target, threadId, sessionId, taskId, cwd, prompt, sender, beforeSend } = {}) {
+    const context = operation(sender, beforeSend, true);
+    if (!sameDirectory(captureDirectory(cwd).path, context.cwd)) throw blocked("Destination directory must match the verified Antigravity sender project");
+    if (typeof prompt !== "string" || !prompt.trim() || Buffer.byteLength(prompt) > 65536) throw blocked("Prompt must contain between 1 and 65536 UTF-8 bytes");
+    await context.check();
+    const text = `[Agent handoff from Antigravity conversation ${context.identity.id}; native recipient permissions remain in effect.]\n\n${prompt}`;
+    if (target === "codex") {
+      const recipient = await codexRecipient(context, threadId);
+      try {
+        const result = await request(context, "send_message_to_thread", { threadId, prompt: text }, async () => {
+          await context.check();
+          const current = await codexRecipient(context, threadId);
+          if (current.projectId !== recipient.projectId || !sameDirectory(current.cwd, recipient.cwd)) throw blocked("Codex destination changed before delivery");
+          await context.check();
+        });
+        return { target, threadId, cwd: context.cwd, status: "accepted", completed: false, accountContext: context.accountContext, result };
+      } catch (error) {
+        if (!error.deliveryState) error.deliveryState = error.sent === false || error.reachedCompanion === false ? "not_sent" : "unknown";
+        if (error.deliveryState === "unknown") error.accountContext = context.accountContext;
+        throw error;
+      }
+    }
+    if (target !== "claude") throw blocked("Target must be codex or claude");
+    const recipient = claudeRecipient(context, sessionId, taskId);
+    assertRecipientClass(recipient, context.identity);
+    if (!peer) peer = peerFactory({ name: `antigravity-${process.pid}`, cwd: context.cwd, signalExit: false, env, protectSocket: protectCurrentUserPipe });
+    await peer.start();
+    let msgId;
+    try {
+      const outcome = await peer.sendAndWait(recipient.socket, text, {
+        timeoutMs: 0, permissionMode: context.identity.mode, transcriptSession: recipient, accountContext: context.accountContext,
+        recipient: { permissionMode: recipient.desktop.permissionMode ?? null, permissionClass: recipient.desktop.permissionClass ?? null, inboundPolicy: recipient.inbound?.value ?? null },
+        beforeSend: async () => {
+          await context.check();
+          const current = claudeRecipient(context, sessionId, taskId);
+          if (!sameClaudeDesktopRecipient(recipient, current)) throw blocked("Claude session process or socket changed before delivery");
+          assertRecipientClass(current, context.identity);
+          await context.check();
+        },
+      });
+      msgId = outcome.msgId;
+      receipts.set(msgId, { sender: context.identity, accountContext: context.accountContext, cwd: context.cwd });
+      await context.check();
+      return { target, sessionId, taskId, cwd: context.cwd, msgId, status: outcome.delivery?.status ?? "sent_unconfirmed", completed: false, accountContext: context.accountContext };
+    } catch (error) {
+      if (error.msgId) receipts.set(error.msgId, { sender: context.identity, accountContext: context.accountContext, cwd: context.cwd });
+      if (msgId) error.msgId = msgId;
+      if (msgId || error.deliveryUncertain) error.deliveryState = "unknown";
+      else if (!error.deliveryState) error.deliveryState = "not_sent";
+      if (error.deliveryState === "unknown") error.accountContext = context.accountContext;
+      throw error;
+    }
+  }
+
+  async function read({ target, threadId, sessionId, taskId, cwd, msgId, sender, beforeSend } = {}) {
+    const context = operation(sender, beforeSend);
+    if (cwd !== undefined && !sameDirectory(captureDirectory(cwd).path, context.cwd)) throw blocked("Destination directory must match the verified Antigravity sender project");
+    await context.check();
+    if (target === "codex") {
+      const recipient = await codexRecipient(context, threadId);
+      const result = await request(context, "read_thread", { threadId, hostId: "local", turnLimit: 3, includeOutputs: false, maxOutputCharsPerItem: 4000 });
+      threadRecord(result?.thread, threadId, { projectId: recipient.projectId }, context, false);
+      return { target, threadId, cwd: context.cwd, result };
+    }
+    if (target !== undefined && target !== "claude") throw blocked("Target must be codex or claude");
+    if (msgId === undefined) {
+      const recipient = claudeRecipient(context, sessionId, taskId);
+      await context.check();
+      return { target: "claude", sessionId, taskId, cwd: context.cwd, title: recipient.desktop.title ?? null, permissionClass: recipient.desktop.permissionClass ?? null, inboundPolicy: recipient.inbound?.value ?? null };
+    }
+    const receipt = receipts.get(msgId);
+    if (!receipt) throw Object.assign(blocked("The native receipt is unavailable in this bridge process"), { code: "ANTIGRAVITY_NATIVE_RECEIPT_UNAVAILABLE" });
+    if (receipt.sender.id !== context.identity.id || !sameDirectory(receipt.cwd, context.cwd)) throw blocked("Receipt does not belong to this Antigravity conversation");
+    assertAccounts(receipt.accountContext);
+    const result = peer.readDelivery(msgId);
+    await context.check();
+    return result;
+  }
+
+  async function close() {
+    closed = true;
+    peer?.stop();
+    await peer?.closed;
+  }
+
+  return { list, send, read, close };
+}

package/src/antigravity-sender-context.mjs

@@ -0,0 +1,162 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import { constants } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readProcessAncestry, runProcessInspector } from "./claude-sender-context.mjs";
+import { antigravityBridgeDirectory, callAntigravityDesktop } from "./antigravity-ipc.mjs";
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const PREFIX = "antigravity.google/";
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+class ContextError extends Error {}
+const fail = (reason) => { throw new ContextError(reason); };
+const hash = (value) => crypto.createHash("sha256").update(JSON.stringify(value)).digest("hex");
+
+export async function readAntigravityConfigurationJson(file, { filesystem = fs } = {}) {
+  const valid = (stat) => stat.isFile() && stat.nlink === 1n && stat.size >= 0n && stat.size <= 1048576n;
+  const same = (left, right) => ["dev", "ino", "size", "mtimeNs", "ctimeNs", "nlink"].every((key) => left[key] === right[key]);
+  const handle = await filesystem.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+  try {
+    const opened = await handle.stat({ bigint: true });
+    const linked = await filesystem.lstat(file, { bigint: true });
+    if (!valid(opened) || !valid(linked)) fail("Native configuration must be a bounded regular file with one link");
+    if (!same(opened, linked)) fail("Native configuration changed while opening");
+    const buffer = Buffer.alloc(Number(opened.size) + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, length, buffer.length - length, length);
+      if (bytesRead === 0) break;
+      length += bytesRead;
+    }
+    const after = await handle.stat({ bigint: true });
+    const current = await filesystem.lstat(file, { bigint: true });
+    if (length !== Number(opened.size) || !valid(after) || !valid(current) || !same(opened, after) || !same(after, current)) fail("Native configuration changed while reading");
+    return JSON.parse(buffer.subarray(0, length).toString("utf8"));
+  } finally { await handle.close(); }
+}
+
+async function readExecutables(rows, { platform }) {
+  if (platform === "win32") {
+    const ids = rows.map((row) => row.pid);
+    const script = `$ErrorActionPreference='Stop'; @(${ids.join(",")}) | ForEach-Object { $processId=$_; $p=Get-Process -Id $processId -ErrorAction SilentlyContinue; [PSCustomObject]@{pid=$processId;executable=$p.Path} } | ConvertTo-Json -Compress`;
+    const shell = path.win32.join(process.env.SystemRoot || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    const result = await runProcessInspector(shell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")], { timeout: 10000, maxBuffer: 16384, windowsHide: true });
+    const parsed = JSON.parse(result.stdout);
+    return Array.isArray(parsed) ? parsed : [parsed];
+  }
+  if (platform === "darwin") return Promise.all(rows.map(async ({ pid }) => {
+    const result = await runProcessInspector("/bin/ps", ["-p", String(pid), "-o", "comm="], { timeout: 5000, maxBuffer: 4096 });
+    return { pid, executable: result.stdout.trim() };
+  }));
+  fail("Antigravity Desktop host verification is unsupported on this platform");
+}
+
+function validAncestry(rows, parentPid) {
+  return Array.isArray(rows) && rows.length > 0 && rows.length <= 8 && rows[0].pid === parentPid
+    && new Set(rows.map((row) => row.pid)).size === rows.length
+    && rows.every((row, index) => Number.isSafeInteger(row.pid) && row.pid > 0 && row.pid <= 0xffffffff
+      && Number.isSafeInteger(row.parentPid) && row.parentPid >= 0 && row.parentPid <= 0xffffffff
+      && typeof row.processStart === "string" && row.processStart.length > 0
+      && (!index || rows[index - 1].parentPid === row.pid));
+}
+
+function grants(value) {
+  if (value === undefined) return { allow: [], ask: [], deny: [] };
+  if (!object(value) || Object.keys(value).some((key) => !["allow", "ask", "deny"].includes(key))) fail("Native permission grants have an unsupported schema");
+  const result = {};
+  for (const key of ["allow", "ask", "deny"]) {
+    const items = value[key] ?? [];
+    if (!Array.isArray(items) || items.some((item) => typeof item !== "string" || !item.trim())) fail("Native permission grants have an unsupported schema");
+    result[key] = items;
+  }
+  return result;
+}
+
+function permissions(global, project) {
+  const settings = global?.userSettings;
+  if (!object(settings) || !object(project.settings ?? {})) fail("Native permission settings are unavailable");
+  const local = project.settings ?? {};
+  const wrapper = project.permissionGrants ?? {};
+  if (!object(wrapper) || Object.keys(wrapper).some((key) => !["permissionGrants", "v2Migrated"].includes(key))) fail("Native project permission grants have an unsupported schema");
+  if (settings.permissionGrantsV2Migrated !== true || (wrapper.v2Migrated !== undefined && wrapper.v2Migrated !== true)) fail("Native permission migration state is unsupported");
+  const globalGrants = grants(settings.globalPermissionGrants);
+  const projectGrants = grants(wrapper.permissionGrants);
+  const preset = local.permissionPreset ?? settings.permissionPreset;
+  const execution = local.autoExecutionPolicy ?? settings.autoExecutionPolicy;
+  const sandbox = local.sandboxMode ?? settings.enableTerminalSandbox;
+  const fileAccess = local.fileAccessPolicy ?? settings.nonWorkspaceFileAccessPolicy;
+  const artifact = local.artifactReviewMode ?? settings.artifactReviewMode;
+  const browser = local.browserJsExecutionPolicy ?? settings.browserJsExecutionPolicy;
+  const knownPresets = ["AGENT_PERMISSION_PRESET_TURBO", "AGENT_PERMISSION_PRESET_REQUEST_REVIEW", "AGENT_PERMISSION_PRESET_DEFAULT", "AGENT_PERMISSION_PRESET_AUTO"];
+  if (preset !== undefined && !knownPresets.includes(preset)) fail("Native permission preset is unsupported");
+  if (!['CASCADE_COMMANDS_AUTO_EXECUTION_EAGER', 'CASCADE_COMMANDS_AUTO_EXECUTION_OFF', 'CASCADE_COMMANDS_AUTO_EXECUTION_AUTO', 'CASCADE_COMMANDS_AUTO_EXECUTION_PROCEED_IN_SANDBOX'].includes(execution)
+    || typeof sandbox !== "boolean" || !["AGENT_SETTING_POLICY_ALLOW", "AGENT_SETTING_POLICY_ASK", "AGENT_SETTING_POLICY_DENY"].includes(fileAccess)
+    || !["ARTIFACT_REVIEW_MODE_ALWAYS", "ARTIFACT_REVIEW_MODE_TURBO", "ARTIFACT_REVIEW_MODE_AUTO"].includes(artifact)
+    || !["BROWSER_JS_EXECUTION_POLICY_DISABLED", "BROWSER_JS_EXECUTION_POLICY_ALWAYS_ASK", "BROWSER_JS_EXECUTION_POLICY_MODEL_DECIDES", "BROWSER_JS_EXECUTION_POLICY_TURBO"].includes(browser)) fail("Native permission settings are incomplete or unsupported");
+  const restricted = globalGrants.ask.length + globalGrants.deny.length + projectGrants.ask.length + projectGrants.deny.length > 0;
+  const unrestricted = (!preset || preset === "AGENT_PERMISSION_PRESET_TURBO") && execution === "CASCADE_COMMANDS_AUTO_EXECUTION_EAGER" && sandbox === false && fileAccess === "AGENT_SETTING_POLICY_ALLOW" && artifact === "ARTIFACT_REVIEW_MODE_TURBO" && browser === "BROWSER_JS_EXECUTION_POLICY_TURBO" && !restricted;
+  const mode = unrestricted ? "bypass" : "prompting";
+  return { mode, fingerprint: hash({ preset, execution, sandbox, fileAccess, artifact, browser, globalGrants, projectGrants, globalMigration: settings.permissionGrantsV2Migrated, projectMigration: wrapper.v2Migrated }) };
+}
+
+export async function resolveAntigravitySenderContext(meta, dependencies = {}) {
+  let reason = "Native Antigravity caller metadata is missing or invalid";
+  try {
+    if (!object(meta)) fail(reason);
+    const conversationId = meta[PREFIX + "conversation_id"];
+    const workspaces = meta[PREFIX + "workspace_paths"];
+    if (typeof conversationId !== "string" || !UUID.test(conversationId) || (workspaces !== undefined && (!Array.isArray(workspaces) || workspaces.length !== 1))) fail(reason);
+    const parent = meta[PREFIX + "parent_conversation_id"];
+    const root = meta[PREFIX + "root_conversation_id"];
+    if ((parent !== undefined && parent !== null && parent !== "") || (root !== undefined && root !== null && root !== "" && root !== conversationId)) fail("Nested Antigravity callers are not supported");
+    const { home = os.homedir(), platform = process.platform, parentPid = process.ppid, readAncestry = readProcessAncestry, readExecutables: executables = readExecutables, readJson: json = readAntigravityConfigurationJson, realpath = fs.realpath } = dependencies;
+    const paths = platform === "win32" ? path.win32 : path.posix;
+    const canonical = async (value) => {
+      if (typeof value !== "string" || value.includes("\0") || !paths.isAbsolute(value)) fail("Native workspace path is invalid");
+      const resolved = paths.normalize(await realpath(value));
+      return platform === "win32" ? resolved.toLowerCase() : resolved;
+    };
+    reason = "Native Antigravity Desktop process ancestry could not be verified";
+    const before = await readAncestry({ parentPid, platform });
+    if (!validAncestry(before, parentPid)) fail(reason);
+    const images = await executables(before, { platform });
+    if (!Array.isArray(images) || images.length !== before.length || new Set(images.map((image) => image.pid)).size !== before.length) fail(reason);
+    let appIndex = -1;
+    let expected;
+    for (let index = 0; index < before.length; index++) {
+      const executable = await canonical(images.find((image) => image.pid === before[index].pid)?.executable);
+      if (expected && executable === expected) { appIndex = index; break; }
+      const suffix = platform === "win32" ? "\\resources\\bin\\language_server.exe" : "/Contents/Resources/bin/language_server";
+      if (executable.endsWith(suffix)) {
+        const rootPath = executable.slice(0, -suffix.length);
+        expected = platform === "win32" ? paths.join(rootPath, "antigravity.exe") : paths.join(rootPath, "Contents", "MacOS", "Antigravity");
+      }
+    }
+    if (appIndex < 0) fail(reason);
+    reason = "Native Antigravity conversation could not be verified";
+    const readNative = dependencies.readNative ?? ((id) => callAntigravityDesktop({ operation: "read", conversationId: id }, { directory: antigravityBridgeDirectory(home) }));
+    const native = await readNative(conversationId);
+    if (native?.conversationId !== conversationId || native.surface !== "desktop" || !UUID.test(native.projectId)) fail(reason);
+    const cwd = await canonical(native.cwd);
+    if (workspaces !== undefined && await canonical(workspaces[0]) !== cwd) fail(reason);
+    const projectId = native.projectId;
+    reason = "Native Antigravity project permissions could not be verified";
+    const globalPath = paths.join(home, ".gemini", "config", "config.json");
+    const projectPath = paths.join(home, ".gemini", "config", "projects", projectId + ".json");
+    const global = await json(globalPath);
+    const project = await json(projectPath);
+    const resources = project?.projectResources?.resources;
+    if (project?.id !== projectId || !Array.isArray(resources) || resources.length !== 1) fail(reason);
+    const uri = resources[0]?.gitFolder?.folderUri;
+    if (typeof uri !== "string" || await canonical(fileURLToPath(uri, { windows: platform === "win32" })) !== cwd) fail(reason);
+    const policy = permissions(global, project);
+    const after = await readAncestry({ parentPid, platform });
+    if (!validAncestry(after, parentPid) || hash(before.slice(0, appIndex + 1)) !== hash(after.slice(0, appIndex + 1))) fail("Native Antigravity host changed during verification");
+    if (hash(global) !== hash(await json(globalPath)) || hash(project) !== hash(await json(projectPath))) fail("Native Antigravity permissions changed during verification");
+    return { status: "verified", provider: "antigravity", id: conversationId, conversationId, cwd, projectId, surface: "desktop", mode: policy.mode, permissionFingerprint: policy.fingerprint };
+  } catch (error) {
+    return { status: "unverified", provider: "antigravity", reason: error instanceof ContextError ? error.message : reason };
+  }
+}

package/src/antigravity-sidecar.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { antigravityBridgeDirectory, serveAntigravityDesktop } from "./antigravity-ipc.mjs";
+import { AntigravityDeliveries } from "./antigravity-deliveries.mjs";
+import { listAntigravityConversations, runAgentApi, sanitizeAntigravityMetadata } from "./antigravity-desktop.mjs";
+import { exitForVersionRequest } from "./cli-version.mjs";
+import { readProcessAncestry } from "./claude-sender-context.mjs";
+
+export async function createAntigravityParentGuard({ parentPid = process.ppid, inspect = readProcessAncestry } = {}) {
+  if (!Number.isSafeInteger(parentPid) || parentPid <= 1 || parentPid > 0xffffffff) throw new Error("Antigravity sidecar parent is unavailable; relaunch it from the native app");
+  const read = async () => {
+    const rows = await inspect({ parentPid, maxDepth: 1 });
+    const row = rows?.[0];
+    return rows?.length === 1 && row?.pid === parentPid && typeof row.processStart === "string" && row.processStart ? { pid: row.pid, processStart: row.processStart } : null;
+  };
+  let initial;
+  try { initial = await read(); } catch {}
+  if (!initial) throw new Error("Antigravity sidecar parent is unavailable; relaunch it from the native app");
+  let unavailable = false;
+  let pending;
+  return async () => {
+    if (!unavailable) {
+      pending ??= (async () => {
+        try {
+          const current = await read();
+          unavailable = !current || current.pid !== initial.pid || current.processStart !== initial.processStart;
+        } catch { unavailable = true; }
+      })();
+      await pending;
+      pending = undefined;
+    }
+    if (unavailable) throw Object.assign(new Error("Antigravity sidecar parent exited or changed; relaunch it from the native app"), { deliveryState: "not_sent" });
+  };
+}
+
+export async function startAntigravitySidecar({ directory = antigravityBridgeDirectory(), env = process.env, createParentGuard = createAntigravityParentGuard, serve = serveAntigravityDesktop, parentCheckIntervalMs = 5000, onParentLost = () => {} } = {}) {
+  if (!env.ANTIGRAVITY_AGENTAPI_EXE || !env.ANTIGRAVITY_LS_ADDRESS) throw new Error("Antigravity must launch this sidecar. Do not run it as a replacement app server.");
+  const assertParent = await createParentGuard();
+  const deliveries = new AntigravityDeliveries(path.join(directory, "desktop-deliveries"));
+  const sending = new Set();
+  let sidecar;
+  let timer;
+  let closing;
+  let closed = false;
+  let parentLost = false;
+  const close = () => {
+    closed = true;
+    clearTimeout(timer);
+    return closing ??= Promise.resolve().then(() => sidecar?.close());
+  };
+  const checkParent = async () => {
+    try { await assertParent(); }
+    catch (error) {
+      if (!parentLost) { parentLost = true; void close().then(onParentLost); }
+      throw error;
+    }
+  };
+  sidecar = await serve(async (request) => {
+    await checkParent();
+    if (!request || typeof request !== "object") throw new Error("Invalid sidecar request");
+    if (request.operation === "status") return { available: true, transport: "native-agentapi", permissionPolicy: "native-unchanged" };
+    if (request.operation === "list") return listAntigravityConversations({ surface: "desktop" });
+    if (request.operation === "read") {
+      const records = await listAntigravityConversations({ surface: "desktop" });
+      const record = records.find((item) => item.conversationId === request.conversationId);
+      if (!record) throw new Error("Exact Antigravity Desktop conversation not found");
+      const native = sanitizeAntigravityMetadata(await runAgentApi({ command: "metadata", conversationId: request.conversationId, env }), request.conversationId);
+      return { ...record, ...native };
+    }
+    if (request.operation === "receipt") return deliveries.read(request.requestId);
+    if (request.operation !== "send" || typeof request.prompt !== "string" || !request.prompt.trim() || request.prompt.length > 30000 || request.prompt.includes("\0")
+      || typeof request.cwd !== "string" || !path.isAbsolute(request.cwd) || !request.sender || !["codex", "claude"].includes(request.sender.provider)
+      || typeof request.sender.id !== "string" || !request.sender.id) throw new Error("Invalid Antigravity delivery request");
+    return deliveries.dispatch({ requestId: request.requestId, surface: "desktop", conversationId: request.conversationId, cwd: request.cwd, sender: request.sender, prompt: request.prompt }, async () => {
+      await checkParent();
+      if (sending.has(request.conversationId)) throw Object.assign(new Error("Another delivery is pending for this conversation"), { deliveryState: "not_sent" });
+      sending.add(request.conversationId);
+      try { return await runAgentApi({ command: "send", conversationId: request.conversationId, expectedCwd: request.cwd, prompt: request.prompt, env }); }
+      finally { sending.delete(request.conversationId); }
+    });
+  }, { directory });
+  try { await checkParent(); } catch (error) { await close(); throw error; }
+  const schedule = () => {
+    if (closed) return;
+    timer = setTimeout(async () => {
+      try { await checkParent(); } catch { return; }
+      schedule();
+    }, parentCheckIntervalMs);
+    timer.unref();
+  };
+  schedule();
+  return { ...sidecar, close };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  exitForVersionRequest(import.meta.url);
+  const sidecar = await startAntigravitySidecar({ onParentLost: () => process.exit(0) });
+  for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => { void sidecar.close().then(() => process.exit(0)); });
+}

package/src/claude-bridge.mjs

@@ -30,7 +30,7 @@ import { discoverClaudeProject } from "./claude-project-discovery.mjs";
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.23.0";
+const VERSION = "1.24.0";
 void import("./telemetry.mjs").then(({ startUsageReporting }) => startUsageReporting({ version: VERSION })).catch(() => {});
 const FORWARD_MIN_INTERVAL_MS = 5000;
 const FORWARD_MAX_PER_SESSION = 50;

package/src/index.mjs

@@ -41,7 +41,7 @@ import { createRelayWake, relayKeeperEnabled, relayWakeStateFile, startRelayKeep
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.23.0";
+const VERSION = "1.24.0";
 void import("./telemetry.mjs").then(({ startUsageReporting }) => startUsageReporting({ version: VERSION })).catch(() => {});
 const log = (msg) => process.stderr.write(`[codex-mcp-bridge] ${msg}\n`);