@raysonmeng/agentbridge 0.1.9 → 0.1.11

package/dist/cli.js

@@ -120,7 +120,7 @@ function parsePositiveIntEnv(name, fallback, log = () => {}, env = process.env)
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@raysonmeng/agentbridge",
-    version: "0.1.9",
+    version: "0.1.11",
     description: "Bridge between Claude Code and Codex \u2014 bidirectional agent communication via MCP Channel + JSON-RPC",
     type: "module",
     packageManager: "bun@1.3.11",
@@ -1165,15 +1165,173 @@ function formatBuildInfo(build) {
 var BUILD_INFO;
 var init_build_info = __esm(() => {
   BUILD_INFO = Object.freeze({
-    version: defineString("0.1.9", "0.0.0-source"),
-    commit: defineString("10dfd58", "source"),
+    version: defineString("0.1.11", "0.0.0-source"),
+    commit: defineString("48eb0ed", "source"),
     bundle: defineBundle("dist"),
     contractVersion: defineNumber(1, CONTRACT_VERSION)
   });
 });
 
+// src/process-lifecycle.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { basename } from "path";
+function parsePsProcessList(output) {
+  const entries = [];
+  for (const line of output.split(/\r?\n/)) {
+    const match = line.match(/^\s*(\d+)\s+(.+?)\s*$/);
+    if (!match)
+      continue;
+    const pid = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(pid))
+      continue;
+    entries.push({ pid, command: match[2] });
+  }
+  return entries;
+}
+function invokesCodexBinary(command) {
+  const tokens = command.trim().split(/\s+/);
+  const exe = tokens[0] ? basename(tokens[0]) : "";
+  if (exe === "codex")
+    return true;
+  if ((exe === "node" || exe === "bun") && tokens[1]) {
+    return basename(tokens[1]) === "codex";
+  }
+  return false;
+}
+function commandMatchesManagedCodexTui(command, proxyUrl) {
+  if (!invokesCodexBinary(command))
+    return false;
+  if (!command.includes("tui_app_server"))
+    return false;
+  const remoteUrl = extractRemoteUrl(command);
+  if (!remoteUrl)
+    return false;
+  if (!proxyUrl)
+    return true;
+  return remoteTargetsProxy(remoteUrl, proxyUrl);
+}
+function findManagedCodexTuiProcessesFromList(processes, proxyUrl) {
+  return processes.filter((entry) => commandMatchesManagedCodexTui(entry.command, proxyUrl));
+}
+function findManagedCodexTuiProcesses(proxyUrl) {
+  try {
+    const output = execFileSync4("ps", ["-axo", "pid=,command="], { encoding: "utf-8" });
+    return findManagedCodexTuiProcessesFromList(parsePsProcessList(output), proxyUrl).filter((entry) => entry.pid !== process.pid);
+  } catch {
+    return [];
+  }
+}
+function listManagedCodexTuiProcessesFromList(processes) {
+  return processes.filter((entry) => commandMatchesManagedCodexTui(entry.command)).map((entry) => ({ ...entry, remoteUrl: extractRemoteUrl(entry.command) }));
+}
+function listManagedCodexTuiProcesses() {
+  try {
+    const output = execFileSync4("ps", ["-axo", "pid=,command="], { encoding: "utf-8" });
+    return listManagedCodexTuiProcessesFromList(parsePsProcessList(output)).filter((entry) => entry.pid !== process.pid);
+  } catch {
+    return [];
+  }
+}
+function listBridgeFrontendProcessesFromList(processes) {
+  return processes.filter((entry) => /(?:^|[\s/\\])bridge-server\.js(?:\s|$)/.test(entry.command) && (entry.command.includes("agentbridge") || entry.command.includes("agent_bridge")));
+}
+function listBridgeFrontendProcesses() {
+  try {
+    const output = execFileSync4("ps", ["-axo", "pid=,command="], { encoding: "utf-8" });
+    return listBridgeFrontendProcessesFromList(parsePsProcessList(output)).filter((entry) => entry.pid !== process.pid);
+  } catch {
+    return [];
+  }
+}
+function commandForPid(pid) {
+  try {
+    return execFileSync4("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function pidLooksAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function isAgentBridgeDaemon(pid, lookup = commandForPid) {
+  const cmd = lookup(pid);
+  if (cmd === null)
+    return false;
+  const hasDaemonEntry = /(?:^|[\s/\\])[\w.-]*-?daemon\.(?:ts|js)(?:\s|$)/.test(cmd);
+  const hasAgentbridge = cmd.includes("agentbridge") || cmd.includes("agent_bridge");
+  return hasDaemonEntry && hasAgentbridge;
+}
+function isAgentBridgeProcess(pid, lookup = commandForPid) {
+  const cmd = lookup(pid);
+  if (cmd === null)
+    return false;
+  return cmd.includes("agentbridge") || cmd.includes("agent_bridge");
+}
+function terminateProcessSync(pid, options = {}) {
+  const gracefulTimeoutMs = options.gracefulTimeoutMs ?? 2000;
+  const target = options.processGroup && process.platform !== "win32" ? -pid : pid;
+  const label = options.processGroup && process.platform !== "win32" ? `process group ${pid}` : `pid ${pid}`;
+  try {
+    process.kill(target, "SIGTERM");
+    options.log?.(`Sent SIGTERM to ${label}`);
+  } catch {
+    return !isProcessAlive(pid);
+  }
+  if (waitForExitSync(pid, gracefulTimeoutMs))
+    return true;
+  try {
+    process.kill(target, "SIGKILL");
+    options.log?.(`Sent SIGKILL to ${label}`);
+  } catch {}
+  return waitForExitSync(pid, 500);
+}
+function waitForExitSync(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid))
+      return true;
+    sleepSync(50);
+  }
+  return !isProcessAlive(pid);
+}
+function sleepSync(ms) {
+  const buffer = new SharedArrayBuffer(4);
+  const view = new Int32Array(buffer);
+  Atomics.wait(view, 0, 0, ms);
+}
+function extractRemoteUrl(command) {
+  const equals = command.match(/(?:^|\s)--remote=([^\s]+)/);
+  if (equals)
+    return equals[1];
+  const separate = command.match(/(?:^|\s)--remote\s+([^\s]+)/);
+  return separate?.[1] ?? null;
+}
+function remoteTargetsProxy(remoteUrl, proxyUrl) {
+  try {
+    const remote = new URL(remoteUrl);
+    const proxy = new URL(proxyUrl);
+    return remote.protocol === proxy.protocol && remote.hostname === proxy.hostname && remote.port === proxy.port && normalizePath(remote.pathname) === normalizePath(proxy.pathname);
+  } catch {
+    return remoteUrl === proxyUrl;
+  }
+}
+function normalizePath(pathname) {
+  return pathname === "" ? "/" : pathname;
+}
+var isProcessAlive;
+var init_process_lifecycle = __esm(() => {
+  isProcessAlive = pidLooksAlive;
+});
+
 // src/daemon-lifecycle.ts
-import { spawn, execFileSync as execFileSync4 } from "child_process";
+import { spawn } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync4, statSync, unlinkSync, writeFileSync as writeFileSync4, openSync, closeSync, constants } from "fs";
 import { fileURLToPath } from "url";
 
@@ -1267,7 +1425,7 @@ class DaemonLifecycle {
     const existingPid = this.readPid();
     if (existingPid) {
       if (isProcessAlive(existingPid)) {
-        if (this.isDaemonProcess(existingPid)) {
+        if (isAgentBridgeDaemon(existingPid)) {
           try {
             await this.waitForReady(REUSE_READY_RETRIES, REUSE_READY_DELAY_MS);
             return;
@@ -1478,7 +1636,7 @@ class DaemonLifecycle {
             this.releaseLock();
             return this.acquireLockStrict(true);
           }
-          if (Number.isFinite(holderPid) && this.lockAgeMs() > LOCK_IDENTITY_GRACE_MS && !this.isAgentBridgeProcess(holderPid)) {
+          if (Number.isFinite(holderPid) && this.lockAgeMs() > LOCK_IDENTITY_GRACE_MS && !isAgentBridgeProcess(holderPid)) {
             this.log(`Startup lock is ${Math.round(this.lockAgeMs() / 1000)}s old and holder pid ${holderPid} ` + `is an unrelated process (pid recycled), reclaiming`);
             this.releaseLock();
             return this.acquireLockStrict(true);
@@ -1499,14 +1657,6 @@ class DaemonLifecycle {
       return 0;
     }
   }
-  isAgentBridgeProcess(pid) {
-    try {
-      const cmd = execFileSync4("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
-      return cmd.includes("agentbridge") || cmd.includes("agent_bridge");
-    } catch {
-      return false;
-    }
-  }
   releaseLock() {
     try {
       unlinkSync(this.stateDir.lockFile);
@@ -1524,7 +1674,7 @@ class DaemonLifecycle {
       this.cleanup();
       return false;
     }
-    if (!this.isDaemonProcess(pid)) {
+    if (!isAgentBridgeDaemon(pid)) {
       this.log(`Pid ${pid} is alive but is NOT an AgentBridge daemon \u2014 refusing to kill. Cleaning up stale pid file.`);
       this.cleanup();
       return false;
@@ -1552,16 +1702,6 @@ class DaemonLifecycle {
     this.cleanup();
     return true;
   }
-  isDaemonProcess(pid) {
-    try {
-      const cmd = execFileSync4("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
-      const hasDaemonEntry = /(?:^|[\s/\\])[\w.-]*-?daemon\.(?:ts|js)(?:\s|$)/.test(cmd);
-      const hasAgentbridge = cmd.includes("agentbridge") || cmd.includes("agent_bridge");
-      return hasDaemonEntry && hasAgentbridge;
-    } catch {
-      return false;
-    }
-  }
   cleanup() {
     this.removePidFile();
     this.removeStatusFile();
@@ -1576,17 +1716,10 @@ async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
     clearTimeout(timer);
   }
 }
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
 var DEFAULT_DAEMON_ENTRY, DAEMON_ENTRY, DAEMON_PATH, REUSE_READY_RETRIES, REUSE_READY_DELAY_MS = 250, HEALTH_FETCH_TIMEOUT_MS = 500, LOCK_IDENTITY_GRACE_MS;
 var init_daemon_lifecycle = __esm(() => {
   init_build_info();
+  init_process_lifecycle();
   DEFAULT_DAEMON_ENTRY = import.meta.url.endsWith(".ts") ? "./daemon.ts" : "./daemon.js";
   DAEMON_ENTRY = process.env.AGENTBRIDGE_DAEMON_ENTRY || DEFAULT_DAEMON_ENTRY;
   DAEMON_PATH = fileURLToPath(new URL(DAEMON_ENTRY, import.meta.url));
@@ -1616,7 +1749,7 @@ import {
 import { createServer } from "net";
 import { createHash, randomUUID } from "crypto";
 import { hostname, userInfo } from "os";
-import { basename, join as join5, resolve as resolve2, sep } from "path";
+import { basename as basename2, join as join5, resolve as resolve2, sep } from "path";
 function portsForSlot(slot) {
   if (!Number.isInteger(slot) || slot < 0) {
     throw new PairError("PAIR_ID_INVALID", `Invalid slot: ${slot}`);
@@ -1723,16 +1856,6 @@ function readLockOwner(lockFile) {
     return null;
   }
 }
-function pidLooksAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err?.code === "EPERM";
-  }
-}
 function lockFileAgeMs(lockFile) {
   try {
     return Date.now() - statSync2(lockFile).mtimeMs;
@@ -1866,14 +1989,6 @@ async function withRegistryLock(base, fn) {
     await sleep(25 + Math.floor(Math.random() * 50));
   }
 }
-function isDaemonProcess(pid) {
-  try {
-    const cmd = execFileSync5("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
-    return cmd.includes("daemon") && (cmd.includes("agentbridge") || cmd.includes("agent_bridge"));
-  } catch {
-    return false;
-  }
-}
 function detectLegacyRootDaemon(base) {
   const rootPidFile = join5(base, "daemon.pid");
   if (!existsSync6(rootPidFile))
@@ -1885,7 +2000,7 @@ function detectLegacyRootDaemon(base) {
   } catch {
     return null;
   }
-  if (!Number.isFinite(pid) || !pidLooksAlive(pid) || !isDaemonProcess(pid))
+  if (!Number.isFinite(pid) || !pidLooksAlive(pid) || !isAgentBridgeDaemon(pid))
     return null;
   return { pid, controlPort: LEGACY_ROOT_CONTROL_PORT };
 }
@@ -2071,6 +2186,7 @@ async function removeUnregisteredPairDir(base, pairId) {
 }
 var PAIR_BASE_PORT = 4500, PAIR_SLOT_STRIDE = 10, PAIR_ID_REGEX, DEFAULT_PAIR_NAME = "main", LOCK_FILE_NAME = ".registry.lock", REGISTRY_FILE_NAME = "registry.json", LOCK_DEADLINE_MS = 1e4, ORPHAN_GRACE_MS = 3000, LEGACY_ROOT_CONTROL_PORT = 4502, WINDOWS_RESERVED_RE, PairError, MAX_PAIR_SLOT;
 var init_pair_registry = __esm(() => {
+  init_process_lifecycle();
   PAIR_ID_REGEX = /^[A-Za-z0-9._-]{1,64}$/;
   WINDOWS_RESERVED_RE = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
   PairError = class PairError extends Error {
@@ -2441,6 +2557,46 @@ var init_trace_log = __esm(() => {
   RELEVANT_ENV_RE = /^(AGENTBRIDGE_|CODEX_)/;
 });
 
+// src/cli/max-permissions.ts
+function planMaxPermissions(args, suppressors, env = process.env) {
+  let safeFlag = false;
+  const rest = [];
+  for (const a of args) {
+    if (a === "--safe") {
+      safeFlag = true;
+      continue;
+    }
+    rest.push(a);
+  }
+  const safeMode = safeFlag || env.AGENTBRIDGE_SAFE === "1";
+  const userExpressedPreference = rest.some((a) => suppressors.some((s) => matchesSuppressor(a, s)));
+  return { args: rest, inject: !safeMode && !userExpressedPreference, safeMode };
+}
+function matchesSuppressor(token, suppressor) {
+  if (token === suppressor || token.startsWith(`${suppressor}=`))
+    return true;
+  if (/^-[A-Za-z]$/.test(suppressor) && !token.startsWith("--") && token.startsWith(suppressor) && token.length > suppressor.length) {
+    return true;
+  }
+  return false;
+}
+var CLAUDE_MAX_PERMISSION_FLAG = "--dangerously-skip-permissions", CLAUDE_MAX_PERMISSION_SUPPRESSORS, CODEX_MAX_PERMISSION_FLAG = "--yolo", CODEX_MAX_PERMISSION_SUPPRESSORS;
+var init_max_permissions = __esm(() => {
+  CLAUDE_MAX_PERMISSION_SUPPRESSORS = [
+    CLAUDE_MAX_PERMISSION_FLAG,
+    "--allow-dangerously-skip-permissions",
+    "--permission-mode"
+  ];
+  CODEX_MAX_PERMISSION_SUPPRESSORS = [
+    CODEX_MAX_PERMISSION_FLAG,
+    "--dangerously-bypass-approvals-and-sandbox",
+    "-a",
+    "--ask-for-approval",
+    "-s",
+    "--sandbox"
+  ];
+});
+
 // src/cli/claude.ts
 var exports_claude = {};
 __export(exports_claude, {
@@ -2457,7 +2613,9 @@ async function runClaude(args) {
     allowStrict: true,
     log: (msg) => console.error(msg)
   });
-  const { pairFlag, rest } = parsePairFlag(args);
+  const { pairFlag, rest: pairRest } = parsePairFlag(args);
+  const permissionPlan = planMaxPermissions(pairRest, CLAUDE_MAX_PERMISSION_SUPPRESSORS);
+  const rest = permissionPlan.args;
   checkOwnedFlagConflicts(rest, "agentbridge claude", OWNED_FLAGS);
   let pair;
   try {
@@ -2484,9 +2642,13 @@ async function runClaude(args) {
   await assertPairNotLive(lifecycle, pair);
   lifecycle.clearKilled();
   const channelEntry = `plugin:${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+  if (permissionPlan.inject) {
+    console.error(`[agentbridge] running with ${CLAUDE_MAX_PERMISSION_FLAG} (default; opt out with --safe or AGENTBRIDGE_SAFE=1)`);
+  }
   const fullArgs = [
     "--dangerously-load-development-channels",
     channelEntry,
+    ...permissionPlan.inject ? [CLAUDE_MAX_PERMISSION_FLAG] : [],
     ...rest
   ];
   const child = spawn2("claude", fullArgs, {
@@ -2588,6 +2750,7 @@ var init_claude = __esm(() => {
   init_env_guard();
   init_pair_resolver();
   init_trace_log();
+  init_max_permissions();
   OWNED_FLAGS = ["--channels", "--dangerously-load-development-channels"];
 });
 
@@ -2650,16 +2813,6 @@ function readTurnInProgress(statusFilePath, read = (p) => readFileSync7(p, "utf-
     return null;
   }
 }
-function defaultIsPidAlive(pid) {
-  if (pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
 function refineCleanExitClassification(turnInProgress) {
   if (turnInProgress === true)
     return "exit_0_during_turn";
@@ -2706,7 +2859,11 @@ function captureTuiLogTail(options) {
     return `(tui log tail capture failed: ${err instanceof Error ? err.message : String(err)})`;
   }
 }
-var init_wrapper_exit_observability = () => {};
+var defaultIsPidAlive;
+var init_wrapper_exit_observability = __esm(() => {
+  init_process_lifecycle();
+  defaultIsPidAlive = pidLooksAlive;
+});
 
 // src/pair-command.ts
 function pairScopedCommand(cmd) {
@@ -2829,7 +2986,7 @@ import {
   writeFileSync as writeFileSync6
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename2, dirname as dirname3, join as join10 } from "path";
+import { basename as basename3, dirname as dirname3, join as join10 } from "path";
 function nowIso() {
   return new Date().toISOString();
 }
@@ -2876,7 +3033,7 @@ function findCodexRolloutFile(threadId, env = process.env, maxEntries = 20000) {
       }
       if (!entry.isFile())
         continue;
-      const name = basename2(entry.name);
+      const name = basename3(entry.name);
       if (name === exactName || name.startsWith("rollout-") && name.endsWith(".jsonl") && name.includes(threadId)) {
         return path;
       }
@@ -2910,145 +3067,6 @@ function readUsableCurrentThread(identity, env = process.env) {
 }
 var init_thread_state = () => {};
 
-// src/process-lifecycle.ts
-import { execFileSync as execFileSync6 } from "child_process";
-import { basename as basename3 } from "path";
-function parsePsProcessList(output) {
-  const entries = [];
-  for (const line of output.split(/\r?\n/)) {
-    const match = line.match(/^\s*(\d+)\s+(.+?)\s*$/);
-    if (!match)
-      continue;
-    const pid = Number.parseInt(match[1], 10);
-    if (!Number.isFinite(pid))
-      continue;
-    entries.push({ pid, command: match[2] });
-  }
-  return entries;
-}
-function invokesCodexBinary(command) {
-  const tokens = command.trim().split(/\s+/);
-  const exe = tokens[0] ? basename3(tokens[0]) : "";
-  if (exe === "codex")
-    return true;
-  if ((exe === "node" || exe === "bun") && tokens[1]) {
-    return basename3(tokens[1]) === "codex";
-  }
-  return false;
-}
-function commandMatchesManagedCodexTui(command, proxyUrl) {
-  if (!invokesCodexBinary(command))
-    return false;
-  if (!command.includes("tui_app_server"))
-    return false;
-  const remoteUrl = extractRemoteUrl(command);
-  if (!remoteUrl)
-    return false;
-  if (!proxyUrl)
-    return true;
-  return remoteTargetsProxy(remoteUrl, proxyUrl);
-}
-function findManagedCodexTuiProcessesFromList(processes, proxyUrl) {
-  return processes.filter((entry) => commandMatchesManagedCodexTui(entry.command, proxyUrl));
-}
-function findManagedCodexTuiProcesses(proxyUrl) {
-  try {
-    const output = execFileSync6("ps", ["-axo", "pid=,command="], { encoding: "utf-8" });
-    return findManagedCodexTuiProcessesFromList(parsePsProcessList(output), proxyUrl).filter((entry) => entry.pid !== process.pid);
-  } catch {
-    return [];
-  }
-}
-function listManagedCodexTuiProcessesFromList(processes) {
-  return processes.filter((entry) => commandMatchesManagedCodexTui(entry.command)).map((entry) => ({ ...entry, remoteUrl: extractRemoteUrl(entry.command) }));
-}
-function listManagedCodexTuiProcesses() {
-  try {
-    const output = execFileSync6("ps", ["-axo", "pid=,command="], { encoding: "utf-8" });
-    return listManagedCodexTuiProcessesFromList(parsePsProcessList(output)).filter((entry) => entry.pid !== process.pid);
-  } catch {
-    return [];
-  }
-}
-function listBridgeFrontendProcessesFromList(processes) {
-  return processes.filter((entry) => /(?:^|[\s/\\])bridge-server\.js(?:\s|$)/.test(entry.command) && (entry.command.includes("agentbridge") || entry.command.includes("agent_bridge")));
-}
-function listBridgeFrontendProcesses() {
-  try {
-    const output = execFileSync6("ps", ["-axo", "pid=,command="], { encoding: "utf-8" });
-    return listBridgeFrontendProcessesFromList(parsePsProcessList(output)).filter((entry) => entry.pid !== process.pid);
-  } catch {
-    return [];
-  }
-}
-function isProcessAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function commandForPid(pid) {
-  try {
-    return execFileSync6("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
-  } catch {
-    return null;
-  }
-}
-function terminateProcessSync(pid, options = {}) {
-  const gracefulTimeoutMs = options.gracefulTimeoutMs ?? 2000;
-  const target = options.processGroup && process.platform !== "win32" ? -pid : pid;
-  const label = options.processGroup && process.platform !== "win32" ? `process group ${pid}` : `pid ${pid}`;
-  try {
-    process.kill(target, "SIGTERM");
-    options.log?.(`Sent SIGTERM to ${label}`);
-  } catch {
-    return !isProcessAlive2(pid);
-  }
-  if (waitForExitSync(pid, gracefulTimeoutMs))
-    return true;
-  try {
-    process.kill(target, "SIGKILL");
-    options.log?.(`Sent SIGKILL to ${label}`);
-  } catch {}
-  return waitForExitSync(pid, 500);
-}
-function waitForExitSync(pid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!isProcessAlive2(pid))
-      return true;
-    sleepSync(50);
-  }
-  return !isProcessAlive2(pid);
-}
-function sleepSync(ms) {
-  const buffer = new SharedArrayBuffer(4);
-  const view = new Int32Array(buffer);
-  Atomics.wait(view, 0, 0, ms);
-}
-function extractRemoteUrl(command) {
-  const equals = command.match(/(?:^|\s)--remote=([^\s]+)/);
-  if (equals)
-    return equals[1];
-  const separate = command.match(/(?:^|\s)--remote\s+([^\s]+)/);
-  return separate?.[1] ?? null;
-}
-function remoteTargetsProxy(remoteUrl, proxyUrl) {
-  try {
-    const remote = new URL(remoteUrl);
-    const proxy = new URL(proxyUrl);
-    return remote.protocol === proxy.protocol && remote.hostname === proxy.hostname && remote.port === proxy.port && normalizePath(remote.pathname) === normalizePath(proxy.pathname);
-  } catch {
-    return remoteUrl === proxyUrl;
-  }
-}
-function normalizePath(pathname) {
-  return pathname === "" ? "/" : pathname;
-}
-var init_process_lifecycle = () => {};
-
 // src/cli/codex.ts
 var exports_codex = {};
 __export(exports_codex, {
@@ -3057,7 +3075,7 @@ __export(exports_codex, {
   parseAgentBridgeCodexArgs: () => parseAgentBridgeCodexArgs,
   buildCodexArgs: () => buildCodexArgs
 });
-import { spawn as spawn3, execSync as execSync2, execFileSync as execFileSync7 } from "child_process";
+import { spawn as spawn3, execSync as execSync2, execFileSync as execFileSync6 } from "child_process";
 import {
   openSync as openSync3,
   writeSync,
@@ -3145,8 +3163,14 @@ function resolveCodexResumeArgs(parsed, pair, env = process.env) {
   }
   return { rest: parsed.rest, mode: "passthrough" };
 }
-function buildCodexArgs(userArgs, proxyUrl) {
-  const bridgeFlags = ["--enable", "tui_app_server", "--remote", proxyUrl];
+function buildCodexArgs(userArgs, proxyUrl, opts = {}) {
+  const bridgeFlags = [
+    "--enable",
+    "tui_app_server",
+    "--remote",
+    proxyUrl,
+    ...opts.yolo ? [CODEX_MAX_PERMISSION_FLAG] : []
+  ];
   const first = userArgs[0];
   if (!first || first.startsWith("-")) {
     return { fullArgs: [...bridgeFlags, ...userArgs], injectedBridgeFlags: true };
@@ -3172,7 +3196,8 @@ async function runCodex(args) {
     log: (msg) => console.error(msg)
   });
   const { pairFlag, rest } = parsePairFlag(args);
-  const wrapperArgs = parseAgentBridgeCodexArgs(rest);
+  const permissionPlan = planMaxPermissions(rest, CODEX_MAX_PERMISSION_SUPPRESSORS);
+  const wrapperArgs = parseAgentBridgeCodexArgs(permissionPlan.args);
   const agentsContract = checkAgentsMdContract(process.cwd());
   if (!agentsContract.fresh) {
     console.error(`[agentbridge] ${agentsContract.message}`);
@@ -3297,7 +3322,12 @@ async function runCodex(args) {
   if (resumeArgs.mode === "auto-resume" || resumeArgs.mode === "resume-current") {
     console.error(`[agentbridge] Resuming current Codex thread ${resumeArgs.thread.threadId}`);
   }
-  const { fullArgs } = buildCodexArgs(resumeArgs.rest, proxyUrl);
+  const { fullArgs, injectedBridgeFlags } = buildCodexArgs(resumeArgs.rest, proxyUrl, {
+    yolo: permissionPlan.inject
+  });
+  if (permissionPlan.inject && injectedBridgeFlags) {
+    console.error(`[agentbridge] running with ${CODEX_MAX_PERMISSION_FLAG} (default; opt out with --safe or AGENTBRIDGE_SAFE=1)`);
+  }
   const stderrTail = new StderrRingBuffer;
   const wrapperLogPath = stateDir.codexWrapperLogFile;
   const startedAt = Date.now();
@@ -3318,7 +3348,7 @@ async function runCodex(args) {
     let attempts = 0;
     const discover = () => {
       attempts += 1;
-      nativeChildPid = discoverNativeChildPid(launcherPid, (cmd, args2) => execFileSync7(cmd, args2, { encoding: "utf-8", timeout: 2000 }));
+      nativeChildPid = discoverNativeChildPid(launcherPid, (cmd, args2) => execFileSync6(cmd, args2, { encoding: "utf-8", timeout: 2000 }));
       if (nativeChildPid !== null) {
         appendWrapperLog(wrapperLogPath, `native child pid=${nativeChildPid} (launcher pid=${launcherPid})`);
         return;
@@ -3424,7 +3454,7 @@ async function runCodex(args) {
     const tuiLogTail = captureTuiLogTail({
       codexHome: join11(homedir4(), ".codex"),
       nativePid: nativeChildPid,
-      run: (cmd, args2) => execFileSync7(cmd, args2, { encoding: "utf-8", timeout: 2000 })
+      run: (cmd, args2) => execFileSync6(cmd, args2, { encoding: "utf-8", timeout: 2000 })
     });
     appendWrapperLog(wrapperLogPath, [
       `exit: code=${code ?? "null"} signal=${signal ?? "null"} runtime_ms=${runtimeMs} pid=${child.pid ?? "unknown"} native_pid=${nativeChildPid ?? "unknown"} classification=${classification}`,
@@ -3476,7 +3506,7 @@ function traceCliStart2(event, args, originalEnv, envGuardAction, pair) {
 function guardNoLiveManagedTui(stateDir, proxyUrl) {
   const pid = readTuiPid(stateDir);
   if (pid) {
-    if (!isProcessAlive2(pid)) {
+    if (!isProcessAlive(pid)) {
       try {
         unlinkSync4(stateDir.tuiPidFile);
       } catch {}
@@ -3550,6 +3580,7 @@ var init_codex = __esm(() => {
   init_trace_log();
   init_process_lifecycle();
   init_claude();
+  init_max_permissions();
   OWNED_FLAGS2 = ["--remote"];
   TUI_SUBCOMMANDS = new Set(["resume", "fork"]);
   NON_TUI_SUBCOMMANDS = new Set([
@@ -3577,6 +3608,130 @@ var init_codex = __esm(() => {
   ]);
 });
 
+// src/claude-session.ts
+import { readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join12 } from "path";
+function encodeClaudeProjectDir(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function findLatestClaudeSession(cwd, claudeHome = process.env.CLAUDE_CONFIG_DIR || join12(homedir5(), ".claude")) {
+  const dir = join12(claudeHome, "projects", encodeClaudeProjectDir(cwd));
+  let entries;
+  try {
+    entries = readdirSync4(dir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of entries) {
+    if (!name.endsWith(".jsonl"))
+      continue;
+    const sessionId = name.slice(0, -".jsonl".length);
+    if (!SESSION_ID_PATTERN.test(sessionId))
+      continue;
+    const file = join12(dir, name);
+    let mtimeMs;
+    try {
+      const st = statSync5(file);
+      if (!st.isFile())
+        continue;
+      mtimeMs = st.mtimeMs;
+    } catch {
+      continue;
+    }
+    if (!best || mtimeMs > best.mtimeMs) {
+      best = { sessionId, file, mtimeMs };
+    }
+  }
+  return best;
+}
+var SESSION_ID_PATTERN;
+var init_claude_session = __esm(() => {
+  SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+});
+
+// src/cli/resume.ts
+var exports_resume = {};
+__export(exports_resume, {
+  runResume: () => runResume,
+  resolveResumeTargets: () => resolveResumeTargets
+});
+function resolveResumeTargets(opts = {}) {
+  const cwd = process.cwd();
+  const { pair } = resolvePairReadOnly(opts.pairFlag);
+  const claude = findLatestClaudeSession(cwd, opts.claudeHome);
+  const codex = readUsableCurrentThread({
+    stateDir: pair.stateDir,
+    pairId: pair.manual ? null : pair.pairId,
+    pairName: pair.name,
+    cwd
+  }, opts.env ?? process.env);
+  return {
+    pairName: pair.name,
+    claudeSessionId: claude?.sessionId ?? null,
+    codexThreadId: codex?.threadId ?? null
+  };
+}
+async function runResume(args) {
+  const { pairFlag, rest } = parsePairFlag(args);
+  const target = rest[0];
+  const extra = rest.slice(1);
+  const pairPrefix = pairFlag !== undefined ? ["--pair", pairFlag] : [];
+  if (target === "claude") {
+    const session = findLatestClaudeSession(process.cwd());
+    if (!session) {
+      console.error("[agentbridge] No Claude Code session found for this directory.");
+      console.error("[agentbridge] Start one with: abg claude");
+      process.exit(1);
+    }
+    console.error(`[agentbridge] Resuming Claude Code session ${session.sessionId}`);
+    const { runClaude: runClaude2 } = await Promise.resolve().then(() => (init_claude(), exports_claude));
+    await runClaude2([...pairPrefix, "--resume", session.sessionId, ...extra]);
+    return;
+  }
+  if (target === "codex") {
+    const { runCodex: runCodex2 } = await Promise.resolve().then(() => (init_codex(), exports_codex));
+    await runCodex2([...pairPrefix, "resume-current", ...extra]);
+    return;
+  }
+  if (target !== undefined) {
+    console.error(`Error: unknown resume target "${target}".`);
+    console.error("");
+    console.error("Usage:");
+    console.error("  abg resume           # print resume commands for this directory");
+    console.error("  abg resume claude    # resume the last Claude Code session here");
+    console.error("  abg resume codex     # resume this pair's current Codex thread");
+    process.exit(1);
+  }
+  const targets = resolveResumeTargets({ pairFlag });
+  const pairArg = pairFlag ? `--pair ${pairFlag} ` : "";
+  const lines = [];
+  if (targets.claudeSessionId) {
+    lines.push(`abg ${pairArg}claude --resume ${targets.claudeSessionId}`);
+  } else {
+    lines.push(`# no Claude Code session found for this directory (start one: abg ${pairArg}claude)`);
+  }
+  if (targets.codexThreadId) {
+    lines.push(`abg ${pairArg}codex resume ${targets.codexThreadId}`);
+  } else {
+    lines.push(`# no verified Codex thread for pair "${targets.pairName}" (start one: abg ${pairArg}codex --new)`);
+  }
+  console.log(lines.join(`
+`));
+  console.error("");
+  console.error("Tip: `abg resume claude` / `abg resume codex` runs these directly.");
+  console.error("(max-permission flags are applied by default; opt out with --safe or AGENTBRIDGE_SAFE=1)");
+  if (!targets.claudeSessionId && !targets.codexThreadId) {
+    process.exit(1);
+  }
+}
+var init_resume = __esm(() => {
+  init_claude_session();
+  init_pair_resolver();
+  init_thread_state();
+});
+
 // src/cli/kill.ts
 var exports_kill = {};
 __export(exports_kill, {
@@ -3585,7 +3740,7 @@ __export(exports_kill, {
   formatKillReport: () => formatKillReport
 });
 import { readFileSync as readFileSync10, unlinkSync as unlinkSync5 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 async function runKill(args = []) {
   const argError = validateKillArgs(args);
   if (argError === "help") {
@@ -3637,7 +3792,7 @@ async function runKill(args = []) {
     for (const dirName of listPairDirsSafe(base)) {
       if (registeredIds.has(dirName))
         continue;
-      const stateDir = new StateDirResolver(join12(base, "pairs", dirName));
+      const stateDir = new StateDirResolver(join13(base, "pairs", dirName));
       results.push(await stopStateDir(`${dirName} (unregistered)`, stateDir, portsFromStateDir(stateDir)));
     }
     const legacy = detectLegacyRootDaemon(base);
@@ -3722,7 +3877,7 @@ No arguments stop this directory's registered pairs and any legacy-root daemon.
 }
 async function stopPairEntry(base, pair) {
   const ports = portsForEntry(pair);
-  const stateDir = new StateDirResolver(join12(base, "pairs", pair.pairId));
+  const stateDir = new StateDirResolver(join13(base, "pairs", pair.pairId));
   return stopStateDir(pair.pairId, stateDir, ports);
 }
 function listPairDirsSafe(base) {
@@ -3857,7 +4012,7 @@ async function killManagedCodexTui(stateDir, proxyUrl, log, gracefulTimeoutMs =
   if (!pid) {
     log("No Codex TUI pid file found");
     removeTuiPidFile(stateDir);
-  } else if (!isProcessAlive2(pid)) {
+  } else if (!isProcessAlive(pid)) {
     log(`Codex TUI pid ${pid} is not alive, cleaning up stale pid file`);
     removeTuiPidFile(stateDir);
   } else if (!isManagedCodexTuiProcess2(pid, proxyUrl)) {
@@ -3911,7 +4066,7 @@ var exports_pairs = {};
 __export(exports_pairs, {
   runPairs: () => runPairs
 });
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function runPairs(args = []) {
   const [command, ...rest] = args;
   if (command === "rm") {
@@ -4077,7 +4232,7 @@ async function collectRows() {
 }
 async function rowForPair(base, pair) {
   const ports = portsForEntry(pair);
-  const stateDir = new StateDirResolver(join13(base, "pairs", pair.pairId));
+  const stateDir = new StateDirResolver(join14(base, "pairs", pair.pairId));
   const lifecycle = new DaemonLifecycle({
     stateDir,
     controlPort: ports.controlPort,
@@ -4188,7 +4343,7 @@ import {
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync11
 } from "fs";
-import { dirname as dirname5, join as join14 } from "path";
+import { dirname as dirname5, join as join15 } from "path";
 function isKickoffText(text) {
   if (!text)
     return false;
@@ -4219,7 +4374,7 @@ function extractFirstRealUserMessage(rolloutPath) {
 }
 function scanResumePollution(options = {}) {
   const codexHome2 = options.codexHome ?? codexHome();
-  const dbPath = options.dbPath ?? join14(codexHome2, "state_5.sqlite");
+  const dbPath = options.dbPath ?? join15(codexHome2, "state_5.sqlite");
   if (!existsSync11(dbPath)) {
     return { codexHome: codexHome2, dbPath, scanned: 0, candidates: [], applied: 0, renamed: 0, deleted: 0 };
   }
@@ -4313,12 +4468,12 @@ function scanResumePollution(options = {}) {
 }
 function backupCodexStateFiles(dbPath, now = new Date().toISOString()) {
   const safeStamp = now.replace(/[:.]/g, "-");
-  const base = join14(dirname5(dbPath), "agentbridge-backups", `resume-pollution-${safeStamp}`);
+  const base = join15(dirname5(dbPath), "agentbridge-backups", `resume-pollution-${safeStamp}`);
   mkdirSync7(base, { recursive: true });
   for (const path of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
     if (!existsSync11(path))
       continue;
-    const target = join14(base, path.split("/").pop());
+    const target = join15(base, path.split("/").pop());
     mkdirSync7(dirname5(target), { recursive: true });
     copyFileSync(path, target);
   }
@@ -4366,9 +4521,9 @@ __export(exports_doctor, {
   runDoctor: () => runDoctor,
   formatDoctorReport: () => formatDoctorReport
 });
-import { existsSync as existsSync12, readFileSync as readFileSync12, readdirSync as readdirSync4, realpathSync as realpathSync3, statSync as statSync5 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join15 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, readdirSync as readdirSync5, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join16 } from "path";
 async function runDoctor(args = []) {
   if (args[0] === "resume-pollution") {
     runResumePollution(args.slice(1));
@@ -4557,15 +4712,15 @@ function artifactAlignmentCheck() {
         stamps.push({ label: "global-cli", commit });
     } catch {}
   }
-  const cacheRoot = join15(homedir5(), ".claude", "plugins", "cache", "agentbridge", "agentbridge");
+  const cacheRoot = join16(homedir6(), ".claude", "plugins", "cache", "agentbridge", "agentbridge");
   try {
-    for (const version of readdirSync4(cacheRoot)) {
-      const commit = extractBundleCommit(join15(cacheRoot, version, "server", "daemon.js"));
+    for (const version of readdirSync5(cacheRoot)) {
+      const commit = extractBundleCommit(join16(cacheRoot, version, "server", "daemon.js"));
       if (commit)
         stamps.push({ label: `plugin-cache@${version}`, commit });
     }
   } catch {}
-  const repoBundle = join15(process.cwd(), "plugins", "agentbridge", "server", "daemon.js");
+  const repoBundle = join16(process.cwd(), "plugins", "agentbridge", "server", "daemon.js");
   if (existsSync12(repoBundle)) {
     const commit = extractBundleCommit(repoBundle);
     if (commit)
@@ -4607,7 +4762,7 @@ function logCheck(name, path) {
       hint: "\u65E5\u5FD7\u4F1A\u5728\u76F8\u5E94\u8FDB\u7A0B\u9996\u6B21\u542F\u52A8\u65F6\u521B\u5EFA\uFF1B\u8FDB\u7A0B\u4ECE\u672A\u542F\u52A8\u8FC7\u65F6\u8FD9\u662F\u6B63\u5E38\u7684\u3002"
     };
   }
-  const stat = statSync5(path);
+  const stat = statSync6(path);
   if (stat.size > LARGE_LOG_WARN_BYTES) {
     return {
       name,
@@ -4844,6 +4999,10 @@ async function main(command, restArgs) {
       const { runCodex: runCodex2 } = await Promise.resolve().then(() => (init_codex(), exports_codex));
       await runCodex2(restArgs);
       break;
+    case "resume":
+      const { runResume: runResume2 } = await Promise.resolve().then(() => (init_resume(), exports_resume));
+      await runResume2(restArgs);
+      break;
     case "kill":
       const { runKill: runKill2 } = await Promise.resolve().then(() => (init_kill(), exports_kill));
       await runKill2(restArgs);
@@ -4889,6 +5048,10 @@ Commands:
   claude [args...]   Start Claude Code with push channel enabled
   codex [args...]    Start Codex TUI connected to AgentBridge daemon
                      (bare command auto-resumes the last thread; --new starts fresh)
+  resume [claude|codex]
+                     No target: print resume commands for this directory's last
+                     Claude session + this pair's current Codex thread.
+                     With target: resume that side directly.
   pairs [rm <name|id> | prune [--dry-run]]
                      List pairs; remove one (rm), or delete orphan state dirs (prune)
   doctor [--json]    Diagnose env, daemon, build drift, logs, and current thread
@@ -4898,10 +5061,17 @@ Commands:
                      Stop this directory's pairs (default), every pair (all/--all), or one (--pair)
 
 Options:
-  --pair <name>      Run claude/codex/kill in a named pair. The name is scoped to
+  --pair <name>      Run claude/codex/resume/kill/doctor/budget in a named pair. The name is scoped to
                      the current directory, so the same name in another directory
                      is a separate pair. Goes BEFORE the command. Without it, the
                      pair name defaults to "main" for the current directory.
+  --safe             Disable the max-permission defaults for this launch.
+                     Goes AFTER the command (abg claude --safe); also auto-
+                     suppressed when you pass any explicit permission flag
+                     (-a/--sandbox for codex, --permission-mode for claude).
+                     (abg claude runs with --dangerously-skip-permissions and
+                     abg codex with --yolo by default; AGENTBRIDGE_SAFE=1 also
+                     disables both.)
   --help, -h         Show this help message
   --version, -v      Show version
 
@@ -4915,6 +5085,10 @@ Examples:
   abg init                     # First-time setup
   abg claude                   # Start the "main" pair for this directory
   abg codex                    # Connect Codex to this directory's "main" pair
+  abg resume                   # Print resume commands for both sides
+  abg resume claude            # Resume the last Claude Code session here
+  abg resume codex             # Resume this pair's current Codex thread
+  abg claude --safe            # One launch without the max-permission default
   abg --pair work claude       # Start a named pair "work" (this directory)
   abg --pair work codex        # Connect Codex to the "work" pair
   abg --pair review claude     # A second, parallel pair
@@ -4940,9 +5114,9 @@ function printVersion() {
 }
 var MARKETPLACE_NAME = "agentbridge", PLUGIN_NAME = "agentbridge", REFRESH_COMMANDS, NOTIFY_COMMANDS, PAIR_AWARE_COMMANDS;
 var init_cli = __esm(() => {
-  REFRESH_COMMANDS = new Set(["claude", "codex"]);
-  NOTIFY_COMMANDS = new Set(["claude", "codex", "init", "dev"]);
-  PAIR_AWARE_COMMANDS = new Set(["claude", "codex", "kill", "doctor", "budget"]);
+  REFRESH_COMMANDS = new Set(["claude", "codex", "resume"]);
+  NOTIFY_COMMANDS = new Set(["claude", "codex", "init", "dev", "resume"]);
+  PAIR_AWARE_COMMANDS = new Set(["claude", "codex", "kill", "doctor", "budget", "resume"]);
   if (import.meta.main) {
     const { command, restArgs } = parseTopLevel(process.argv.slice(2));
     main(command, restArgs).catch((err) => {