@raysonmeng/agentbridge 0.1.0

package/dist/cli.js

@@ -0,0 +1,1158 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/config-service.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+
+class ConfigService {
+  configDir;
+  configPath;
+  collaborationPath;
+  constructor(projectRoot) {
+    const root = projectRoot ?? process.cwd();
+    this.configDir = join(root, CONFIG_DIR);
+    this.configPath = join(this.configDir, CONFIG_FILE);
+    this.collaborationPath = join(this.configDir, COLLABORATION_FILE);
+  }
+  hasConfig() {
+    return existsSync(this.configPath);
+  }
+  load() {
+    try {
+      const raw = readFileSync(this.configPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  loadOrDefault() {
+    return this.load() ?? structuredClone(DEFAULT_CONFIG);
+  }
+  save(config) {
+    this.ensureConfigDir();
+    writeFileSync(this.configPath, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+  }
+  loadCollaboration() {
+    try {
+      return readFileSync(this.collaborationPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  saveCollaboration(content) {
+    this.ensureConfigDir();
+    writeFileSync(this.collaborationPath, content, "utf-8");
+  }
+  initDefaults() {
+    this.ensureConfigDir();
+    const created = [];
+    if (!existsSync(this.configPath)) {
+      this.save(DEFAULT_CONFIG);
+      created.push(this.configPath);
+    }
+    if (!existsSync(this.collaborationPath)) {
+      this.saveCollaboration(DEFAULT_COLLABORATION_MD);
+      created.push(this.collaborationPath);
+    }
+    return created;
+  }
+  get configFilePath() {
+    return this.configPath;
+  }
+  get collaborationFilePath() {
+    return this.collaborationPath;
+  }
+  ensureConfigDir() {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true });
+    }
+  }
+}
+var DEFAULT_CONFIG, DEFAULT_COLLABORATION_MD = `# Collaboration Rules
+
+## Roles
+- Claude: Reviewer, Planner, Hypothesis Challenger
+- Codex: Implementer, Executor, Reproducer/Verifier
+
+## Thinking Patterns
+- Analytical/review tasks: Independent Analysis & Convergence
+- Implementation tasks: Architect -> Builder -> Critic
+- Debugging tasks: Hypothesis -> Experiment -> Interpretation
+
+## Communication
+- Use explicit phrases: "My independent view is:", "I agree on:", "I disagree on:", "Current consensus:"
+- Tag messages with [IMPORTANT], [STATUS], or [FYI]
+
+## Review Process
+- Cross-review: author never reviews their own code
+- All changes go through feature/fix branches + PR
+- Merge via squash merge
+
+## Custom Rules
+<!-- Add your project-specific collaboration rules here -->
+`, CONFIG_DIR = ".agentbridge", CONFIG_FILE = "config.json", COLLABORATION_FILE = "collaboration.md";
+var init_config_service = __esm(() => {
+  DEFAULT_CONFIG = {
+    version: "1.0",
+    daemon: {
+      port: 4500,
+      proxyPort: 4501
+    },
+    agents: {
+      claude: {
+        role: "Reviewer, Planner",
+        mode: "push"
+      },
+      codex: {
+        role: "Implementer, Executor"
+      }
+    },
+    markers: ["IMPORTANT", "STATUS", "FYI"],
+    turnCoordination: {
+      attentionWindowSeconds: 15,
+      busyGuard: true
+    },
+    idleShutdownSeconds: 30
+  };
+});
+
+// src/cli/pkg-root.ts
+import { dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { execFileSync } from "child_process";
+function findPackageRoot() {
+  let dir = import.meta.dir;
+  while (true) {
+    if (existsSync2(join2(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      throw new Error("Could not find package.json in any parent directory");
+    }
+    dir = parent;
+  }
+}
+function registerMarketplace(marketplaceRoot) {
+  execFileSync("claude", ["plugin", "marketplace", "add", marketplaceRoot], {
+    stdio: "inherit"
+  });
+}
+var init_pkg_root = () => {};
+
+// src/cli/init.ts
+var exports_init = {};
+__export(exports_init, {
+  runInit: () => runInit,
+  compareVersions: () => compareVersions
+});
+import { execSync, execFileSync as execFileSync2 } from "child_process";
+async function runInit() {
+  console.log(`AgentBridge Init
+`);
+  console.log("Checking dependencies...");
+  checkBun();
+  checkClaude();
+  checkCodex();
+  console.log("");
+  console.log("Generating project config...");
+  const configService = new ConfigService;
+  const created = configService.initDefaults();
+  if (created.length > 0) {
+    for (const file of created) {
+      console.log(`  Created: ${file}`);
+    }
+  } else {
+    console.log("  Project config already exists, skipping.");
+  }
+  console.log("");
+  console.log("Installing AgentBridge plugin...");
+  try {
+    registerMarketplace(findPackageRoot());
+    execFileSync2("claude", ["plugin", "install", `${PLUGIN_NAME}@${MARKETPLACE_NAME}`], {
+      stdio: "inherit"
+    });
+    console.log("  Plugin installed successfully.");
+  } catch {
+    console.log("  Plugin install skipped (marketplace registration or install failed).");
+    console.log("  You can install it later with:");
+    console.log(`    abg dev   # registers marketplace and installs plugin`);
+  }
+  console.log("");
+  console.log(`Setup complete!
+`);
+  console.log("Next steps:");
+  console.log("  1. If Claude Code is already running, execute /reload-plugins in your session");
+  console.log("  2. Start Claude Code:  agentbridge claude");
+  console.log("  3. Start Codex TUI:    agentbridge codex");
+}
+function checkBun() {
+  try {
+    const version = execSync("bun --version", { encoding: "utf-8" }).trim();
+    console.log(`  bun: ${version}`);
+  } catch {
+    console.error("  ERROR: bun not found in PATH.");
+    console.error("  Install Bun: https://bun.sh");
+    process.exit(1);
+  }
+}
+function checkClaude() {
+  try {
+    const versionOutput = execSync("claude --version", { encoding: "utf-8" }).trim();
+    const match = versionOutput.match(/(\d+\.\d+\.\d+)/);
+    if (match) {
+      const version = match[1];
+      console.log(`  claude: ${version}`);
+      if (compareVersions(version, MIN_CLAUDE_VERSION) < 0) {
+        console.error(`  ERROR: Claude Code version ${version} is too old.`);
+        console.error(`  Channels require >= ${MIN_CLAUDE_VERSION}.`);
+        console.error("  Update: npm update -g @anthropic-ai/claude-code");
+        process.exit(1);
+      }
+    } else {
+      console.log(`  claude: ${versionOutput} (version check skipped)`);
+    }
+  } catch {
+    console.error("  ERROR: claude not found in PATH.");
+    console.error("  Install Claude Code: npm install -g @anthropic-ai/claude-code");
+    process.exit(1);
+  }
+}
+function checkCodex() {
+  try {
+    const version = execSync("codex --version", { encoding: "utf-8" }).trim();
+    console.log(`  codex: ${version}`);
+  } catch {
+    console.error("  ERROR: codex not found in PATH.");
+    console.error("  Install Codex: https://github.com/openai/codex");
+    process.exit(1);
+  }
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const va = pa[i] ?? 0;
+    const vb = pb[i] ?? 0;
+    if (va < vb)
+      return -1;
+    if (va > vb)
+      return 1;
+  }
+  return 0;
+}
+var MIN_CLAUDE_VERSION = "2.1.80";
+var init_init = __esm(() => {
+  init_config_service();
+  init_cli();
+  init_pkg_root();
+});
+
+// src/cli/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  runDev: () => runDev
+});
+import { execFileSync as execFileSync3 } from "child_process";
+import { resolve } from "path";
+import { existsSync as existsSync3, cpSync, rmSync } from "fs";
+import { homedir } from "os";
+async function runDev() {
+  console.log(`AgentBridge Dev Setup
+`);
+  const projectRoot = findPackageRoot();
+  const marketplacePath = resolve(projectRoot, ".claude-plugin", "marketplace.json");
+  const pluginDir = resolve(projectRoot, "plugins", "agentbridge");
+  const pluginManifest = resolve(pluginDir, ".claude-plugin", "plugin.json");
+  if (!existsSync3(pluginManifest)) {
+    console.error(`  ERROR: Plugin manifest not found at ${pluginManifest}`);
+    console.error("  Run 'bun run build:plugin' first, or check your working tree.");
+    process.exit(1);
+  }
+  if (!existsSync3(marketplacePath)) {
+    console.error(`  ERROR: Marketplace manifest not found at ${marketplacePath}`);
+    process.exit(1);
+  }
+  console.log(`  Plugin source: ${pluginDir}`);
+  console.log(`
+Registering local marketplace...`);
+  try {
+    registerMarketplace(projectRoot);
+  } catch (e) {
+    console.error(`  ERROR: Failed to register marketplace: ${e.message}`);
+    process.exit(1);
+  }
+  const pluginRef = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+  console.log(`
+Installing plugin...`);
+  try {
+    const listOutput = execFileSync3("claude", ["plugin", "list"], { encoding: "utf-8" });
+    if (!listOutput.includes(pluginRef)) {
+      execFileSync3("claude", ["plugin", "install", pluginRef], { stdio: "inherit" });
+    } else {
+      console.log(`  Plugin '${pluginRef}' already installed.`);
+    }
+  } catch (e) {
+    console.error(`  ERROR: Failed to install plugin: ${e.message}`);
+    process.exit(1);
+  }
+  console.log(`
+Syncing local plugin to cache...`);
+  const cacheDir = resolve(homedir(), ".claude", "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME);
+  if (existsSync3(cacheDir)) {
+    const versionDirs = Bun.spawnSync(["ls", cacheDir]).stdout.toString().trim().split(`
+`).filter(Boolean);
+    for (const ver of versionDirs) {
+      const targetDir = resolve(cacheDir, ver);
+      rmSync(targetDir, { recursive: true, force: true });
+      cpSync(pluginDir, targetDir, { recursive: true });
+      console.log(`  Synced to ${targetDir}`);
+    }
+  } else {
+    console.log("  Cache directory not found, plugin install should have created it.");
+  }
+  console.log(`
+\u2705 Dev setup complete!
+`);
+  console.log("Next steps:");
+  console.log("  agentbridge claude    # Start Claude Code (plugin auto-loaded)");
+  console.log("  agentbridge codex     # Start Codex TUI");
+  console.log("");
+  console.log("Code changed? Run 'agentbridge dev' again, then restart Claude Code or /reload-plugins.");
+}
+var init_dev = __esm(() => {
+  init_cli();
+  init_pkg_root();
+});
+
+// src/daemon-lifecycle.ts
+import { spawn, execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2, openSync, closeSync, constants } from "fs";
+import { fileURLToPath } from "url";
+
+class DaemonLifecycle {
+  stateDir;
+  controlPort;
+  log;
+  constructor(opts) {
+    this.stateDir = opts.stateDir;
+    this.controlPort = opts.controlPort;
+    this.log = opts.log;
+  }
+  get healthUrl() {
+    return `http://127.0.0.1:${this.controlPort}/healthz`;
+  }
+  get readyUrl() {
+    return `http://127.0.0.1:${this.controlPort}/readyz`;
+  }
+  get controlWsUrl() {
+    return `ws://127.0.0.1:${this.controlPort}/ws`;
+  }
+  async ensureRunning() {
+    if (await this.isHealthy()) {
+      await this.waitForReady();
+      return;
+    }
+    const existingPid = this.readPid();
+    if (existingPid) {
+      if (isProcessAlive(existingPid)) {
+        if (this.isDaemonProcess(existingPid)) {
+          try {
+            await this.waitForReady(12, 250);
+            return;
+          } catch {
+            throw new Error(`Found existing daemon process ${existingPid}, but control port ${this.controlPort} never became ready.`);
+          }
+        }
+        this.log(`Pid ${existingPid} is alive but not an AgentBridge daemon, removing stale pid file`);
+      }
+      this.removeStalePidFile();
+    }
+    const lockAcquired = this.acquireLock();
+    if (!lockAcquired) {
+      this.log("Another process is starting the daemon, waiting for readiness...");
+      await this.waitForReady();
+      return;
+    }
+    try {
+      this.launch();
+      await this.waitForReady();
+    } finally {
+      this.releaseLock();
+    }
+  }
+  async isHealthy() {
+    try {
+      const response = await fetch(this.healthUrl);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async waitForHealthy(maxRetries = 40, delayMs = 250) {
+    for (let attempt = 0;attempt < maxRetries; attempt++) {
+      if (await this.isHealthy())
+        return;
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+    }
+    throw new Error(`Timed out waiting for AgentBridge daemon health on ${this.healthUrl}`);
+  }
+  async isReady() {
+    try {
+      const response = await fetch(this.readyUrl);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async waitForReady(maxRetries = 40, delayMs = 250) {
+    for (let attempt = 0;attempt < maxRetries; attempt++) {
+      if (await this.isReady())
+        return;
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+    }
+    throw new Error(`Timed out waiting for AgentBridge daemon readiness on ${this.readyUrl}`);
+  }
+  readStatus() {
+    try {
+      const raw = readFileSync2(this.stateDir.statusFile, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  writeStatus(status) {
+    this.stateDir.ensure();
+    writeFileSync2(this.stateDir.statusFile, JSON.stringify(status, null, 2) + `
+`, "utf-8");
+  }
+  readPid() {
+    try {
+      const raw = readFileSync2(this.stateDir.pidFile, "utf-8").trim();
+      if (!raw)
+        return null;
+      const pid = Number.parseInt(raw, 10);
+      return Number.isFinite(pid) ? pid : null;
+    } catch {
+      return null;
+    }
+  }
+  writePid(pid) {
+    this.stateDir.ensure();
+    writeFileSync2(this.stateDir.pidFile, `${pid ?? process.pid}
+`, "utf-8");
+  }
+  removePidFile() {
+    try {
+      unlinkSync(this.stateDir.pidFile);
+    } catch {}
+  }
+  removeStatusFile() {
+    try {
+      unlinkSync(this.stateDir.statusFile);
+    } catch {}
+  }
+  markKilled() {
+    this.stateDir.ensure();
+    writeFileSync2(this.stateDir.killedFile, `${Date.now()}
+`, "utf-8");
+  }
+  clearKilled() {
+    try {
+      unlinkSync(this.stateDir.killedFile);
+    } catch {}
+  }
+  wasKilled() {
+    return existsSync4(this.stateDir.killedFile);
+  }
+  launch() {
+    this.stateDir.ensure();
+    this.log(`Launching detached daemon on control port ${this.controlPort}`);
+    const daemonProc = spawn(process.execPath, ["run", DAEMON_PATH], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        AGENTBRIDGE_CONTROL_PORT: String(this.controlPort),
+        AGENTBRIDGE_STATE_DIR: this.stateDir.dir
+      },
+      detached: true,
+      stdio: "ignore"
+    });
+    daemonProc.unref();
+  }
+  removeStalePidFile() {
+    this.log("Removing stale pid file");
+    this.removePidFile();
+  }
+  acquireLock(depth = 0) {
+    if (depth > 1) {
+      this.log("Lock acquisition failed after retry, proceeding without lock");
+      return true;
+    }
+    this.stateDir.ensure();
+    try {
+      const fd = openSync(this.stateDir.lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      writeFileSync2(fd, `${process.pid}
+`);
+      closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        try {
+          const holderPid = Number.parseInt(readFileSync2(this.stateDir.lockFile, "utf-8").trim(), 10);
+          if (Number.isFinite(holderPid) && !isProcessAlive(holderPid)) {
+            this.log(`Stale lock file from dead process ${holderPid}, removing`);
+            this.releaseLock();
+            return this.acquireLock(depth + 1);
+          }
+        } catch {
+          this.log("Cannot read lock file, removing stale lock");
+          this.releaseLock();
+          return this.acquireLock(depth + 1);
+        }
+        return false;
+      }
+      this.log(`Warning: could not acquire startup lock: ${err.message}`);
+      return true;
+    }
+  }
+  releaseLock() {
+    try {
+      unlinkSync(this.stateDir.lockFile);
+    } catch {}
+  }
+  async kill(gracefulTimeoutMs = 3000) {
+    const pid = this.readPid();
+    if (!pid) {
+      this.log("No daemon pid file found");
+      this.cleanup();
+      return false;
+    }
+    if (!isProcessAlive(pid)) {
+      this.log(`Daemon pid ${pid} is not alive, cleaning up stale files`);
+      this.cleanup();
+      return false;
+    }
+    if (!this.isDaemonProcess(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;
+    }
+    this.log(`Sending SIGTERM to daemon pid ${pid}`);
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      this.cleanup();
+      return false;
+    }
+    const deadline = Date.now() + gracefulTimeoutMs;
+    while (Date.now() < deadline) {
+      if (!isProcessAlive(pid)) {
+        this.log(`Daemon pid ${pid} stopped gracefully`);
+        this.cleanup();
+        return true;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 200));
+    }
+    this.log(`Daemon pid ${pid} did not stop gracefully, sending SIGKILL`);
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+    this.cleanup();
+    return true;
+  }
+  isDaemonProcess(pid) {
+    try {
+      const cmd = execFileSync4("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
+      return cmd.includes("daemon") && (cmd.includes("agentbridge") || cmd.includes("agent_bridge"));
+    } catch {
+      return false;
+    }
+  }
+  cleanup() {
+    this.removePidFile();
+    this.removeStatusFile();
+    this.releaseLock();
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var DAEMON_ENTRY, DAEMON_PATH;
+var init_daemon_lifecycle = __esm(() => {
+  DAEMON_ENTRY = process.env.AGENTBRIDGE_DAEMON_ENTRY ?? "./daemon.ts";
+  DAEMON_PATH = fileURLToPath(new URL(DAEMON_ENTRY, import.meta.url));
+});
+
+// src/state-dir.ts
+import { mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2, platform } from "os";
+
+class StateDirResolver {
+  stateDir;
+  constructor(envOverride) {
+    const override = envOverride ?? process.env.AGENTBRIDGE_STATE_DIR;
+    if (override) {
+      this.stateDir = override;
+    } else if (platform() === "darwin") {
+      this.stateDir = join3(homedir2(), "Library", "Application Support", "AgentBridge");
+    } else {
+      const xdgState = process.env.XDG_STATE_HOME ?? join3(homedir2(), ".local", "state");
+      this.stateDir = join3(xdgState, "agentbridge");
+    }
+  }
+  ensure() {
+    if (!existsSync5(this.stateDir)) {
+      mkdirSync2(this.stateDir, { recursive: true });
+    }
+  }
+  get dir() {
+    return this.stateDir;
+  }
+  get pidFile() {
+    return join3(this.stateDir, "daemon.pid");
+  }
+  get tuiPidFile() {
+    return join3(this.stateDir, "codex-tui.pid");
+  }
+  get lockFile() {
+    return join3(this.stateDir, "daemon.lock");
+  }
+  get statusFile() {
+    return join3(this.stateDir, "status.json");
+  }
+  get portsFile() {
+    return join3(this.stateDir, "ports.json");
+  }
+  get logFile() {
+    return join3(this.stateDir, "agentbridge.log");
+  }
+  get killedFile() {
+    return join3(this.stateDir, "killed");
+  }
+}
+var init_state_dir = () => {};
+
+// src/cli/claude.ts
+var exports_claude = {};
+__export(exports_claude, {
+  runClaude: () => runClaude,
+  checkOwnedFlagConflicts: () => checkOwnedFlagConflicts
+});
+import { spawn as spawn2 } from "child_process";
+async function runClaude(args) {
+  checkOwnedFlagConflicts(args, "agentbridge claude", OWNED_FLAGS);
+  const stateDir = new StateDirResolver;
+  const controlPort = parseInt(process.env.AGENTBRIDGE_CONTROL_PORT ?? "4502", 10);
+  const lifecycle = new DaemonLifecycle({
+    stateDir,
+    controlPort,
+    log: (msg) => console.error(`[agentbridge] ${msg}`)
+  });
+  lifecycle.clearKilled();
+  const channelEntry = `plugin:${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+  const fullArgs = [
+    "--dangerously-load-development-channels",
+    channelEntry,
+    ...args
+  ];
+  const child = spawn2("claude", fullArgs, {
+    stdio: "inherit",
+    env: process.env
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+  child.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      console.error("Error: claude not found in PATH.");
+      console.error("Install Claude Code: npm install -g @anthropic-ai/claude-code");
+      process.exit(1);
+    }
+    console.error(`Error starting Claude Code: ${err.message}`);
+    process.exit(1);
+  });
+}
+function checkOwnedFlagConflicts(args, commandName, ownedFlags) {
+  for (const flag of ownedFlags) {
+    if (args.some((a) => a === flag || a.startsWith(`${flag}=`))) {
+      console.error(`Error: "${flag}" is automatically set by ${commandName}.`);
+      console.error("");
+      console.error("AgentBridge automatically injects these flags:");
+      for (const f of ownedFlags) {
+        console.error(`  ${f}`);
+      }
+      console.error("");
+      const nativeCmd = commandName.includes("codex") ? "codex" : "claude";
+      console.error("If you need full control over these flags, use the native command directly:");
+      console.error(`  ${nativeCmd} [your flags here]`);
+      process.exit(1);
+    }
+  }
+}
+var OWNED_FLAGS;
+var init_claude = __esm(() => {
+  init_cli();
+  init_daemon_lifecycle();
+  init_state_dir();
+  OWNED_FLAGS = ["--channels", "--dangerously-load-development-channels"];
+});
+
+// src/cli/codex.ts
+var exports_codex = {};
+__export(exports_codex, {
+  runCodex: () => runCodex
+});
+import { spawn as spawn3, execSync as execSync2 } from "child_process";
+import { openSync as openSync2, writeSync, closeSync as closeSync2, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
+async function runCodex(args) {
+  checkOwnedFlagConflicts(args, "agentbridge codex", OWNED_FLAGS2);
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "--enable" && args[i + 1] === "tui_app_server") {
+      console.error(`Error: "--enable tui_app_server" is automatically set by agentbridge codex.`);
+      console.error("");
+      console.error("If you need full control over these flags, use the native command directly:");
+      console.error("  codex [your flags here]");
+      process.exit(1);
+    }
+    if (args[i] === "--enable=tui_app_server") {
+      console.error(`Error: "--enable=tui_app_server" is automatically set by agentbridge codex.`);
+      console.error("");
+      console.error("If you need full control over these flags, use the native command directly:");
+      console.error("  codex [your flags here]");
+      process.exit(1);
+    }
+  }
+  const stateDir = new StateDirResolver;
+  const configService = new ConfigService;
+  const config = configService.loadOrDefault();
+  const controlPort = parseInt(process.env.AGENTBRIDGE_CONTROL_PORT ?? "4502", 10);
+  const lifecycle = new DaemonLifecycle({
+    stateDir,
+    controlPort,
+    log: (msg) => console.error(`[agentbridge] ${msg}`)
+  });
+  console.error("[agentbridge] Ensuring daemon is running...");
+  try {
+    lifecycle.clearKilled();
+    await lifecycle.ensureRunning();
+    console.error("[agentbridge] Daemon is ready.");
+  } catch (err) {
+    console.error(`[agentbridge] Failed to start daemon: ${err.message}`);
+    console.error("[agentbridge] Try: agentbridge kill && agentbridge claude");
+    process.exit(1);
+  }
+  let proxyUrl;
+  const status = lifecycle.readStatus();
+  if (status?.proxyUrl) {
+    proxyUrl = status.proxyUrl;
+  } else {
+    proxyUrl = `ws://127.0.0.1:${config.daemon.proxyPort}`;
+    console.error(`[agentbridge] No daemon status found, using config default: ${proxyUrl}`);
+  }
+  try {
+    await waitForProxyReady(proxyUrl);
+  } catch (err) {
+    console.error(`[agentbridge] ${err.message}`);
+    process.exit(1);
+  }
+  console.log(`Connecting Codex TUI to AgentBridge at ${proxyUrl}...`);
+  let savedStty = null;
+  if (process.stdin.isTTY) {
+    try {
+      savedStty = execSync2("stty -g", { encoding: "utf-8", stdio: ["inherit", "pipe", "pipe"] }).trim();
+    } catch {}
+  }
+  function restoreTerminal() {
+    if (savedStty && process.stdin.isTTY) {
+      try {
+        execSync2(`stty ${savedStty}`, { stdio: ["inherit", "ignore", "ignore"] });
+      } catch {
+        try {
+          execSync2("stty sane", { stdio: ["inherit", "ignore", "ignore"] });
+        } catch {}
+      }
+    }
+    let ttyFd = null;
+    try {
+      ttyFd = openSync2("/dev/tty", "w");
+    } catch {
+      if (process.stdout.isTTY) {
+        ttyFd = 1;
+      }
+    }
+    if (ttyFd !== null) {
+      const sequences = [
+        "\x1B[<u",
+        "\x1B[?2004l",
+        "\x1B[?1004l",
+        "\x1B[?1049l",
+        "\x1B[?25h",
+        "\x1B[0m"
+      ];
+      for (const seq of sequences) {
+        try {
+          writeSync(ttyFd, seq);
+        } catch {}
+      }
+      if (ttyFd !== 1) {
+        try {
+          closeSync2(ttyFd);
+        } catch {}
+      }
+    }
+  }
+  const fullArgs = [
+    "--enable",
+    "tui_app_server",
+    "--remote",
+    proxyUrl,
+    ...args
+  ];
+  const child = spawn3("codex", fullArgs, {
+    stdio: "inherit",
+    env: process.env
+  });
+  if (typeof child.pid === "number") {
+    writeFileSync3(stateDir.tuiPidFile, `${child.pid}
+`, "utf-8");
+  }
+  let cleanedTuiPid = false;
+  function cleanupTuiPidFile() {
+    if (cleanedTuiPid)
+      return;
+    cleanedTuiPid = true;
+    try {
+      unlinkSync2(stateDir.tuiPidFile);
+    } catch {}
+  }
+  process.on("exit", () => {
+    restoreTerminal();
+    cleanupTuiPidFile();
+  });
+  process.on("SIGINT", () => {
+    restoreTerminal();
+    cleanupTuiPidFile();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    restoreTerminal();
+    cleanupTuiPidFile();
+    process.exit(143);
+  });
+  child.on("exit", (code) => {
+    cleanupTuiPidFile();
+    process.exit(code ?? 0);
+  });
+  child.on("error", (err) => {
+    cleanupTuiPidFile();
+    if (err.code === "ENOENT") {
+      console.error("Error: codex not found in PATH.");
+      console.error("Install Codex: https://github.com/openai/codex");
+      process.exit(1);
+    }
+    console.error(`Error starting Codex: ${err.message}`);
+    process.exit(1);
+  });
+}
+function proxyHealthUrl(proxyUrl) {
+  const url = new URL(proxyUrl);
+  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+  url.pathname = "/healthz";
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+async function waitForProxyReady(proxyUrl, maxRetries = 20, delayMs = 100) {
+  const healthUrl = proxyHealthUrl(proxyUrl);
+  for (let attempt = 0;attempt < maxRetries; attempt++) {
+    try {
+      const response = await fetch(healthUrl);
+      if (response.ok) {
+        return;
+      }
+    } catch {}
+    await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+  }
+  throw new Error(`Timed out waiting for Codex proxy readiness on ${healthUrl}`);
+}
+var OWNED_FLAGS2;
+var init_codex = __esm(() => {
+  init_state_dir();
+  init_config_service();
+  init_daemon_lifecycle();
+  init_claude();
+  OWNED_FLAGS2 = ["--remote"];
+});
+
+// src/cli/kill.ts
+var exports_kill = {};
+__export(exports_kill, {
+  runKill: () => runKill
+});
+import { execFileSync as execFileSync5 } from "child_process";
+import { readFileSync as readFileSync3, unlinkSync as unlinkSync3 } from "fs";
+async function runKill() {
+  console.log(`AgentBridge Kill \u2014 stopping daemon and managed Codex TUI
+`);
+  const stateDir = new StateDirResolver;
+  const controlPort = parseInt(process.env.AGENTBRIDGE_CONTROL_PORT ?? "4502", 10);
+  const lifecycle = new DaemonLifecycle({
+    stateDir,
+    controlPort,
+    log: (msg) => console.log(`  ${msg}`)
+  });
+  lifecycle.markKilled();
+  const tuiKilled = await killManagedCodexTui(stateDir, (msg) => console.log(`  ${msg}`));
+  const killed = await lifecycle.kill();
+  if (killed || tuiKilled) {
+    console.log(`
+AgentBridge stopped.`);
+    console.log("Please restart Claude Code (`agentbridge claude`), switch to a new conversation, or run `/resume` to fully disconnect.");
+  } else {
+    console.log(`
+No running AgentBridge daemon or managed Codex TUI found.`);
+    console.log("Stale state files cleaned up (if any).");
+  }
+}
+async function killManagedCodexTui(stateDir, log, gracefulTimeoutMs = 3000) {
+  const pid = readTuiPid(stateDir);
+  if (!pid) {
+    log("No Codex TUI pid file found");
+    removeTuiPidFile(stateDir);
+    return false;
+  }
+  if (!isProcessAlive(pid)) {
+    log(`Codex TUI pid ${pid} is not alive, cleaning up stale pid file`);
+    removeTuiPidFile(stateDir);
+    return false;
+  }
+  if (!isManagedCodexTuiProcess(pid)) {
+    log(`Pid ${pid} is alive but is NOT a managed AgentBridge Codex TUI \u2014 refusing to kill. Cleaning up stale pid file.`);
+    removeTuiPidFile(stateDir);
+    return false;
+  }
+  log(`Sending SIGTERM to Codex TUI pid ${pid}`);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    removeTuiPidFile(stateDir);
+    return false;
+  }
+  const deadline = Date.now() + gracefulTimeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) {
+      log(`Codex TUI pid ${pid} stopped gracefully`);
+      removeTuiPidFile(stateDir);
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 200));
+  }
+  log(`Codex TUI pid ${pid} did not stop gracefully, sending SIGKILL`);
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {}
+  removeTuiPidFile(stateDir);
+  return true;
+}
+function readTuiPid(stateDir) {
+  try {
+    const raw = readFileSync3(stateDir.tuiPidFile, "utf-8").trim();
+    if (!raw)
+      return null;
+    const pid = Number.parseInt(raw, 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function removeTuiPidFile(stateDir) {
+  try {
+    unlinkSync3(stateDir.tuiPidFile);
+  } catch {}
+}
+function isManagedCodexTuiProcess(pid) {
+  try {
+    const cmd = execFileSync5("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
+    return cmd.includes("codex") && cmd.includes("--enable") && cmd.includes("tui_app_server") && cmd.includes("--remote");
+  } catch {
+    return false;
+  }
+}
+var init_kill = __esm(() => {
+  init_state_dir();
+  init_daemon_lifecycle();
+});
+
+// package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "@raysonmeng/agentbridge",
+    version: "0.1.0",
+    description: "Bridge between Claude Code and Codex \u2014 bidirectional agent communication via MCP Channel + JSON-RPC",
+    type: "module",
+    bin: {
+      agentbridge: "dist/cli.js",
+      abg: "dist/cli.js"
+    },
+    files: [
+      "dist/",
+      "plugins/",
+      ".claude-plugin/",
+      "scripts/postinstall.cjs",
+      "README.md",
+      "LICENSE"
+    ],
+    scripts: {
+      start: "bun run src/bridge.ts",
+      "build:cli": "mkdir -p dist && bun build src/cli.ts --outfile dist/cli.js --target bun && chmod +x dist/cli.js",
+      "build:plugin": "mkdir -p plugins/agentbridge/server && bun build src/bridge.ts --outfile plugins/agentbridge/server/bridge-server.js --target bun && bun build src/daemon.ts --outfile plugins/agentbridge/server/daemon.js --target bun",
+      postinstall: "node scripts/postinstall.cjs",
+      prepublishOnly: "bun run build:cli && bun run build:plugin",
+      "validate:plugin": "claude plugin validate plugins/agentbridge && claude plugin validate .claude-plugin/marketplace.json",
+      test: "bun test src",
+      typecheck: "tsc --noEmit",
+      "validate:plugin-versions": "bun scripts/check-plugin-versions.js",
+      check: "tsc --noEmit && bun test src && bun run build:plugin && bun scripts/check-plugin-versions.js"
+    },
+    repository: {
+      type: "git",
+      url: "https://github.com/raysonmeng/agent-bridge.git"
+    },
+    homepage: "https://github.com/raysonmeng/agent-bridge#readme",
+    bugs: {
+      url: "https://github.com/raysonmeng/agent-bridge/issues"
+    },
+    keywords: [
+      "claude-code",
+      "codex",
+      "mcp",
+      "agent",
+      "bridge",
+      "multi-agent",
+      "channels"
+    ],
+    author: "AgentBridge Contributors",
+    license: "MIT",
+    devDependencies: {
+      "@modelcontextprotocol/sdk": "^1.27.1",
+      "@types/bun": "^1.3.11",
+      typescript: "^5.8.0"
+    }
+  };
+});
+
+// src/cli.ts
+async function main() {
+  switch (command) {
+    case "init":
+      const { runInit: runInit2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+      await runInit2();
+      break;
+    case "dev":
+      const { runDev: runDev2 } = await Promise.resolve().then(() => (init_dev(), exports_dev));
+      await runDev2();
+      break;
+    case "claude":
+      const { runClaude: runClaude2 } = await Promise.resolve().then(() => (init_claude(), exports_claude));
+      await runClaude2(restArgs);
+      break;
+    case "codex":
+      const { runCodex: runCodex2 } = await Promise.resolve().then(() => (init_codex(), exports_codex));
+      await runCodex2(restArgs);
+      break;
+    case "kill":
+      const { runKill: runKill2 } = await Promise.resolve().then(() => (init_kill(), exports_kill));
+      await runKill2();
+      break;
+    case "--help":
+    case "-h":
+    case undefined:
+      printHelp();
+      break;
+    case "--version":
+    case "-v":
+      printVersion();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.error(`Run "agentbridge --help" (or "abg --help") for usage.`);
+      process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+AgentBridge \u2014 Multi-agent collaboration bridge
+
+Usage:
+  agentbridge <command> [args...]
+  abg <command> [args...]
+
+Commands:
+  init              Install plugin, check dependencies, generate project config
+  dev               Register local marketplace + install plugin (for local dev)
+  claude [args...]  Start Claude Code with push channel enabled
+  codex [args...]   Start Codex TUI connected to AgentBridge daemon
+  kill              Force kill all AgentBridge processes
+
+Options:
+  --help, -h        Show this help message
+  --version, -v     Show version
+
+Examples:
+  abg init                     # First-time setup
+  abg claude                   # Start Claude Code
+  abg claude --resume          # Start Claude Code and resume session
+  abg codex                    # Start Codex TUI
+  abg codex --model o3         # Start Codex with specific model
+  abg kill                     # Emergency: kill all processes
+`.trim());
+}
+function printVersion() {
+  try {
+    const pkg = require_package();
+    console.log(`agentbridge v${pkg.version}`);
+  } catch {
+    console.log("agentbridge (version unknown)");
+  }
+}
+var args, command, restArgs, MARKETPLACE_NAME = "agentbridge", PLUGIN_NAME = "agentbridge";
+var init_cli = __esm(() => {
+  args = process.argv.slice(2);
+  command = args[0];
+  restArgs = args.slice(1);
+  main().catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+});
+init_cli();
+
+export {
+  PLUGIN_NAME,
+  MARKETPLACE_NAME
+};