@agentconnect/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3020 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path12 from "path";
+import { promises as fs7 } from "fs";
+import { createPrivateKey, createPublicKey as createPublicKey2, sign as signData } from "crypto";
+
+// src/host.ts
+import http from "http";
+import { WebSocketServer } from "ws";
+import { spawn as spawn4 } from "child_process";
+import fs2 from "fs";
+import { promises as fsp } from "fs";
+import net from "net";
+import path5 from "path";
+
+// src/providers/claude.ts
+import { spawn as spawn2 } from "child_process";
+import { access, mkdir, readFile, rm, writeFile } from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+
+// src/providers/utils.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import os from "os";
+import path from "path";
+var DEBUG_ENABLED = Boolean(process.env.AGENTCONNECT_DEBUG?.trim());
+function debugLog(scope, message, details) {
+  if (!DEBUG_ENABLED) return;
+  let suffix = "";
+  if (details) {
+    try {
+      suffix = ` ${JSON.stringify(details)}`;
+    } catch {
+      suffix = "";
+    }
+  }
+  console.log(`[AgentConnect][${scope}] ${message}${suffix}`);
+}
+function splitCommand(value) {
+  if (!value) return { command: "", args: [] };
+  if (Array.isArray(value)) return { command: value[0] ?? "", args: value.slice(1) };
+  const input = String(value).trim();
+  const parts = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i];
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === " ") {
+      if (current) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) parts.push(current);
+  return { command: parts[0] ?? "", args: parts.slice(1) };
+}
+function resolveWindowsCommand(command2) {
+  if (process.platform !== "win32") return command2;
+  if (!command2) return command2;
+  if (command2.endsWith(".cmd") || command2.endsWith(".exe") || command2.includes("\\")) {
+    return command2;
+  }
+  return `${command2}.cmd`;
+}
+function getCommonBinPaths() {
+  const home = os.homedir();
+  const bunInstall = process.env.BUN_INSTALL || path.join(home, ".bun");
+  const pnpmHome = process.env.PNPM_HOME || path.join(home, "Library", "pnpm");
+  const npmPrefix = process.env.NPM_CONFIG_PREFIX;
+  const npmBin = npmPrefix ? path.join(npmPrefix, "bin") : "";
+  const claudeLocal = process.env.CLAUDE_CONFIG_DIR ? path.join(process.env.CLAUDE_CONFIG_DIR, "local") : path.join(home, ".claude", "local");
+  return [
+    path.join(bunInstall, "bin"),
+    pnpmHome,
+    path.join(home, ".local", "bin"),
+    claudeLocal,
+    path.join(home, ".claude", "bin"),
+    npmBin,
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ].filter(Boolean);
+}
+function getCommandCandidates(command2) {
+  if (process.platform !== "win32") return [command2];
+  if (command2.endsWith(".cmd") || command2.endsWith(".exe") || command2.endsWith(".bat")) {
+    return [command2];
+  }
+  return [command2, `${command2}.cmd`, `${command2}.exe`, `${command2}.bat`];
+}
+function resolveCommandPath(command2) {
+  if (!command2) return null;
+  if (command2.includes("/") || command2.includes("\\")) {
+    return existsSync(command2) ? command2 : null;
+  }
+  const candidates = getCommandCandidates(command2);
+  const searchPaths = /* @__PURE__ */ new Set();
+  const pathEntries = process.env.PATH ? process.env.PATH.split(path.delimiter) : [];
+  for (const entry of pathEntries) {
+    if (entry) searchPaths.add(entry);
+  }
+  for (const entry of getCommonBinPaths()) {
+    if (entry) searchPaths.add(entry);
+  }
+  for (const dir of searchPaths) {
+    for (const candidate of candidates) {
+      const fullPath = path.join(dir, candidate);
+      if (existsSync(fullPath)) return fullPath;
+    }
+  }
+  return null;
+}
+function commandExists(command2) {
+  return Boolean(resolveCommandPath(command2));
+}
+function runCommand(command2, args2, options = {}) {
+  return new Promise((resolve) => {
+    const { input, timeoutMs, ...spawnOptions } = options;
+    if (!command2) {
+      resolve({ code: -1, stdout: "", stderr: "Command is empty" });
+      return;
+    }
+    const resolved = resolveCommandPath(command2);
+    if (!resolved) {
+      resolve({ code: 127, stdout: "", stderr: `Executable not found in PATH: "${command2}"` });
+      return;
+    }
+    const child = spawn(resolved, args2, {
+      ...spawnOptions,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timeout;
+    if (typeof timeoutMs === "number" && timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        child.kill();
+        resolve({ code: -1, stdout, stderr: `${stderr}Command timed out` });
+      }, timeoutMs);
+    }
+    if (input) {
+      child.stdin?.write(input);
+    }
+    child.stdin?.end();
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      if (timeout) clearTimeout(timeout);
+      resolve({ code: -1, stdout, stderr: `${stderr}${err.message}` });
+    });
+    child.on("close", (code) => {
+      if (timeout) clearTimeout(timeout);
+      resolve({ code: code ?? 0, stdout, stderr });
+    });
+  });
+}
+function createLineParser(onLine) {
+  let buffer = "";
+  return (chunk) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    buffer += text;
+    let idx;
+    while ((idx = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (line) onLine(line);
+    }
+  };
+}
+async function checkCommandVersion(command2, argsList) {
+  for (const args2 of argsList) {
+    const result = await runCommand(command2, args2);
+    if (result.code === 0) {
+      const version = result.stdout.trim().split("\n")[0] ?? "";
+      return { ok: true, version };
+    }
+  }
+  return { ok: false, version: "" };
+}
+var packageManagerCache = { detected: null };
+async function isCommandAvailable(command2) {
+  const result = await runCommand(command2, ["--version"]);
+  return result.code === 0;
+}
+async function detectPackageManager() {
+  if (packageManagerCache.detected) {
+    return packageManagerCache.detected;
+  }
+  if (await isCommandAvailable("bun")) {
+    packageManagerCache.detected = "bun";
+    return "bun";
+  }
+  if (await isCommandAvailable("pnpm")) {
+    packageManagerCache.detected = "pnpm";
+    return "pnpm";
+  }
+  if (await isCommandAvailable("npm")) {
+    packageManagerCache.detected = "npm";
+    return "npm";
+  }
+  if (process.platform === "darwin" && await isCommandAvailable("brew")) {
+    packageManagerCache.detected = "brew";
+    return "brew";
+  }
+  packageManagerCache.detected = "unknown";
+  return "unknown";
+}
+function getInstallCommand(packageManager, packageName) {
+  switch (packageManager) {
+    case "bun":
+      return { command: "bun", args: ["add", "-g", packageName] };
+    case "pnpm":
+      return { command: "pnpm", args: ["add", "-g", packageName] };
+    case "npm":
+      return { command: "npm", args: ["install", "-g", packageName] };
+    case "brew":
+      return { command: "brew", args: ["install", packageName] };
+    default:
+      return { command: "", args: [] };
+  }
+}
+async function buildInstallCommandAuto(packageName) {
+  const pm = await detectPackageManager();
+  const cmd = getInstallCommand(pm, packageName);
+  return { ...cmd, packageManager: pm };
+}
+function buildInstallCommand(envVar, fallback) {
+  const value = process.env[envVar] || fallback;
+  return splitCommand(value);
+}
+function buildLoginCommand(envVar, fallback) {
+  const value = process.env[envVar] || fallback;
+  return splitCommand(value);
+}
+function buildStatusCommand(envVar, fallback) {
+  const value = process.env[envVar] || fallback;
+  return splitCommand(value);
+}
+
+// src/providers/claude.ts
+var CLAUDE_PACKAGE = "@anthropic-ai/claude-code";
+var INSTALL_UNIX = "curl -fsSL https://claude.ai/install.sh | bash";
+var INSTALL_WINDOWS_PS = "irm https://claude.ai/install.ps1 | iex";
+var INSTALL_WINDOWS_CMD = "curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd";
+var DEFAULT_LOGIN = "";
+var DEFAULT_STATUS = "";
+var CLAUDE_MODELS_CACHE_TTL_MS = 6e4;
+var CLAUDE_RECENT_MODELS_CACHE_TTL_MS = 6e4;
+var claudeModelsCache = null;
+var claudeModelsCacheAt = 0;
+var claudeRecentModelsCache = null;
+var claudeRecentModelsCacheAt = 0;
+var DEFAULT_CLAUDE_MODELS = [
+  {
+    id: "default",
+    displayName: "Default \xB7 Opus 4.5"
+  },
+  {
+    id: "sonnet",
+    displayName: "Sonnet 4.5"
+  },
+  {
+    id: "haiku",
+    displayName: "Haiku 4.5"
+  },
+  {
+    id: "opus",
+    displayName: "Opus"
+  }
+];
+function getClaudeCommand() {
+  const override = process.env.AGENTCONNECT_CLAUDE_COMMAND;
+  const base = override || "claude";
+  const resolved = resolveCommandPath(base);
+  return resolved || resolveWindowsCommand(base);
+}
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path2.join(os2.homedir(), ".claude");
+}
+function formatClaudeDisplayName(modelId) {
+  const value = modelId.trim();
+  if (!value.startsWith("claude-")) return value;
+  const parts = value.replace(/^claude-/, "").split("-").filter(Boolean);
+  if (!parts.length) return value;
+  const family = parts[0];
+  const numeric = parts.slice(1).filter((entry) => /^\d+$/.test(entry));
+  let version = "";
+  if (numeric.length >= 2) {
+    version = `${numeric[0]}.${numeric[1]}`;
+  } else if (numeric.length === 1) {
+    version = numeric[0];
+  }
+  const familyLabel = family.charAt(0).toUpperCase() + family.slice(1);
+  return `Claude ${familyLabel}${version ? ` ${version}` : ""}`;
+}
+async function readClaudeStatsModels() {
+  const statsPath = path2.join(getClaudeConfigDir(), "stats-cache.json");
+  try {
+    const raw = await readFile(statsPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const usage = parsed?.modelUsage;
+    if (!usage || typeof usage !== "object") return [];
+    return Object.keys(usage).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function listClaudeModels() {
+  if (claudeModelsCache && Date.now() - claudeModelsCacheAt < CLAUDE_MODELS_CACHE_TTL_MS) {
+    return claudeModelsCache;
+  }
+  const list = DEFAULT_CLAUDE_MODELS.map((entry) => ({
+    id: entry.id,
+    provider: "claude",
+    displayName: entry.displayName
+  }));
+  claudeModelsCache = list;
+  claudeModelsCacheAt = Date.now();
+  return list;
+}
+async function listClaudeRecentModels() {
+  if (claudeRecentModelsCache && Date.now() - claudeRecentModelsCacheAt < CLAUDE_RECENT_MODELS_CACHE_TTL_MS) {
+    return claudeRecentModelsCache;
+  }
+  const discovered = await readClaudeStatsModels();
+  const mapped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const modelId of discovered) {
+    const id = modelId.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    mapped.push({
+      id,
+      provider: "claude",
+      displayName: formatClaudeDisplayName(id)
+    });
+  }
+  claudeRecentModelsCache = mapped;
+  claudeRecentModelsCacheAt = Date.now();
+  return mapped;
+}
+function getClaudeAuthPaths() {
+  const home = os2.homedir();
+  return [
+    path2.join(home, ".claude.json"),
+    path2.join(home, ".claude", "settings.json"),
+    path2.join(home, ".config", "claude", "auth.json")
+  ];
+}
+function resolveClaudeTheme() {
+  const raw = process.env.AGENTCONNECT_CLAUDE_THEME;
+  return raw && raw.trim() ? raw.trim() : "dark";
+}
+function resolveClaudeLoginMethod(options) {
+  const raw = options?.loginMethod ?? process.env.AGENTCONNECT_CLAUDE_LOGIN_METHOD;
+  if (!raw) return "claudeai";
+  const normalized = String(raw).trim().toLowerCase();
+  if (normalized === "console") return "console";
+  if (normalized === "claudeai" || normalized === "claude") return "claudeai";
+  return "claudeai";
+}
+function resolveClaudeLoginExperience(options) {
+  const raw = options?.loginExperience ?? process.env.AGENTCONNECT_CLAUDE_LOGIN_EXPERIENCE ?? process.env.AGENTCONNECT_LOGIN_EXPERIENCE;
+  if (raw) {
+    const normalized = String(raw).trim().toLowerCase();
+    if (normalized === "terminal" || normalized === "manual") return "terminal";
+    if (normalized === "embedded" || normalized === "pty") return "embedded";
+  }
+  if (process.env.AGENTCONNECT_HOST_MODE === "dev") return "terminal";
+  return "embedded";
+}
+async function createClaudeLoginSettingsFile(loginMethod) {
+  if (!loginMethod) return null;
+  const fileName = `agentconnect-claude-login-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
+  const filePath = path2.join(os2.tmpdir(), fileName);
+  const theme = resolveClaudeTheme();
+  const payload = {
+    forceLoginMethod: loginMethod,
+    theme,
+    hasCompletedOnboarding: true
+  };
+  await writeFile(filePath, JSON.stringify(payload), "utf8");
+  return filePath;
+}
+async function ensureClaudeOnboardingSettings() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path2.join(os2.homedir(), ".claude");
+  const settingsPath = path2.join(configDir, "settings.json");
+  let settings = {};
+  try {
+    const raw = await readFile(settingsPath, "utf8");
+    try {
+      settings = JSON.parse(raw);
+    } catch {
+      return;
+    }
+  } catch (err) {
+    const code = err?.code;
+    if (code && code !== "ENOENT") return;
+  }
+  let updated = false;
+  if (!settings.theme) {
+    settings.theme = resolveClaudeTheme();
+    updated = true;
+  }
+  if (settings.hasCompletedOnboarding !== true) {
+    settings.hasCompletedOnboarding = true;
+    updated = true;
+  }
+  if (!updated) return;
+  await mkdir(configDir, { recursive: true });
+  await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+}
+async function loadPtyModule() {
+  try {
+    const mod = await import("node-pty");
+    if (typeof mod.spawn === "function") return mod;
+    if (mod.default && typeof mod.default.spawn === "function") return mod.default;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function shellEscape(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function cmdEscape(value) {
+  if (!value) return '""';
+  const escaped = value.replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+function buildClaudeCommand(command2, args2, includeLogin = false) {
+  const parts = includeLogin ? [command2, ...args2, "/login"] : [command2, ...args2];
+  return parts.map(shellEscape).join(" ");
+}
+function buildClaudeCmd(command2, args2, includeLogin = false) {
+  const parts = includeLogin ? [command2, ...args2, "/login"] : [command2, ...args2];
+  return parts.map(cmdEscape).join(" ");
+}
+async function openClaudeLoginTerminal(command2, args2, includeLogin = false) {
+  const message = "AgentConnect: complete Claude login in this terminal. If login does not start automatically, run /login.";
+  if (process.platform === "win32") {
+    const cmdLine = `echo ${message} & ${buildClaudeCmd(command2, args2, includeLogin)}`;
+    await runCommand("cmd", ["/c", "start", "", "cmd", "/k", cmdLine], { shell: true });
+    return;
+  }
+  const loginCommand = buildClaudeCommand(command2, args2, includeLogin);
+  const shellCommand = `printf "%s\\n\\n" ${shellEscape(message)}; ${loginCommand}`;
+  if (process.platform === "darwin") {
+    const script = `tell application "Terminal"
+activate
+do script "${shellCommand.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"
+end tell`;
+    await runCommand("osascript", ["-e", script]);
+    return;
+  }
+  if (commandExists("x-terminal-emulator")) {
+    await runCommand("x-terminal-emulator", ["-e", "bash", "-lc", shellCommand]);
+    return;
+  }
+  if (commandExists("gnome-terminal")) {
+    await runCommand("gnome-terminal", ["--", "bash", "-lc", shellCommand]);
+    return;
+  }
+  if (commandExists("konsole")) {
+    await runCommand("konsole", ["-e", "bash", "-lc", shellCommand]);
+    return;
+  }
+  if (commandExists("xterm")) {
+    await runCommand("xterm", ["-e", "bash", "-lc", shellCommand]);
+    return;
+  }
+  throw new Error("No terminal emulator found to launch Claude login.");
+}
+function maybeAdvanceClaudeOnboarding(output, loginMethod, write) {
+  const text = output.toLowerCase();
+  if (text.includes("select login method") || text.includes("claude account with subscription")) {
+    if (loginMethod === "console") {
+      write("\x1B[B");
+    }
+    write("\r");
+    return true;
+  }
+  if (text.includes("choose the text style") || text.includes("text style that looks best")) {
+    write("\r");
+    return true;
+  }
+  if (text.includes("press enter") || text.includes("enter to confirm")) {
+    write("\r");
+    return true;
+  }
+  return false;
+}
+async function hasClaudeAuth() {
+  if (typeof process.env.CLAUDE_CODE_OAUTH_TOKEN === "string") {
+    return process.env.CLAUDE_CODE_OAUTH_TOKEN.trim().length > 0;
+  }
+  for (const filePath of getClaudeAuthPaths()) {
+    try {
+      await access(filePath);
+      const raw = await readFile(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const auth = parsed?.claudeAiOauth;
+      if (typeof auth?.accessToken === "string" && auth.accessToken.trim()) {
+        return true;
+      }
+      if (typeof parsed.primaryApiKey === "string" && parsed.primaryApiKey.trim()) {
+        return true;
+      }
+      if (typeof parsed.accessToken === "string" && parsed.accessToken.trim()) {
+        return true;
+      }
+      if (typeof parsed.token === "string" && parsed.token.trim()) {
+        return true;
+      }
+      const oauthAccount = parsed.oauthAccount;
+      if (typeof oauthAccount?.emailAddress === "string" && oauthAccount.emailAddress.trim()) {
+        return true;
+      }
+      if (typeof oauthAccount?.accountUuid === "string" && oauthAccount.accountUuid.trim()) {
+        return true;
+      }
+      const oauth = parsed.oauth;
+      if (typeof oauth?.access_token === "string" && oauth.access_token.trim()) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function checkClaudeCliStatus() {
+  const command2 = resolveWindowsCommand(getClaudeCommand());
+  const result = await runCommand(command2, ["--print"], {
+    env: { ...process.env, CI: "1" },
+    input: "/status\n",
+    timeoutMs: 4e3
+  });
+  const output = `${result.stdout}
+${result.stderr}`.toLowerCase();
+  if (!output.trim()) {
+    return null;
+  }
+  if (output.includes("not logged in") || output.includes("not authenticated") || output.includes("please log in") || output.includes("please login") || output.includes("run /login") || output.includes("sign in") || output.includes("invalid api key")) {
+    return false;
+  }
+  if (output.includes("logged in") || output.includes("authenticated") || output.includes("signed in") || output.includes("account") || output.includes("@")) {
+    return true;
+  }
+  return null;
+}
+async function ensureClaudeInstalled() {
+  const command2 = getClaudeCommand();
+  const versionCheck = await checkCommandVersion(command2, [["--version"], ["-V"]]);
+  if (versionCheck.ok) {
+    return { installed: true, version: versionCheck.version || void 0 };
+  }
+  if (commandExists(command2)) {
+    return { installed: true, version: void 0 };
+  }
+  const override = buildInstallCommand("AGENTCONNECT_CLAUDE_INSTALL", "");
+  let install = override;
+  let packageManager = override.command ? "unknown" : "unknown";
+  if (!install.command) {
+    if (process.platform === "win32") {
+      if (commandExists("powershell")) {
+        install = {
+          command: "powershell",
+          args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", INSTALL_WINDOWS_PS]
+        };
+        packageManager = "script";
+      } else if (commandExists("pwsh")) {
+        install = {
+          command: "pwsh",
+          args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", INSTALL_WINDOWS_PS]
+        };
+        packageManager = "script";
+      } else if (commandExists("cmd") && commandExists("curl")) {
+        install = { command: "cmd", args: ["/c", INSTALL_WINDOWS_CMD] };
+        packageManager = "script";
+      }
+    } else if (commandExists("bash") && commandExists("curl")) {
+      install = { command: "bash", args: ["-lc", INSTALL_UNIX] };
+      packageManager = "script";
+    } else {
+      const auto = await buildInstallCommandAuto(CLAUDE_PACKAGE);
+      install = { command: auto.command, args: auto.args };
+      packageManager = auto.packageManager;
+    }
+  }
+  if (!install.command) {
+    return { installed: false, version: void 0, packageManager };
+  }
+  await runCommand(install.command, install.args, { shell: process.platform === "win32" });
+  const after = await checkCommandVersion(command2, [["--version"], ["-V"]]);
+  return {
+    installed: after.ok,
+    version: after.version || void 0,
+    packageManager
+  };
+}
+async function getClaudeStatus() {
+  const command2 = getClaudeCommand();
+  const versionCheck = await checkCommandVersion(command2, [["--version"], ["-V"]]);
+  const installed = versionCheck.ok || commandExists(command2);
+  let loggedIn = false;
+  if (installed) {
+    const status = buildStatusCommand("AGENTCONNECT_CLAUDE_STATUS", DEFAULT_STATUS);
+    if (status.command) {
+      const statusCommand = resolveWindowsCommand(status.command);
+      const result = await runCommand(statusCommand, status.args);
+      loggedIn = result.code === 0;
+    } else {
+      const hasAuth = await hasClaudeAuth();
+      const cliStatus = await checkClaudeCliStatus();
+      if (cliStatus === false) {
+        loggedIn = false;
+      } else if (cliStatus === true) {
+        loggedIn = true;
+      } else {
+        loggedIn = hasAuth;
+      }
+    }
+  }
+  return { installed, loggedIn, version: versionCheck.version || void 0 };
+}
+async function loginClaude(options) {
+  const login = buildLoginCommand("AGENTCONNECT_CLAUDE_LOGIN", DEFAULT_LOGIN);
+  if (login.command) {
+    const command2 = resolveWindowsCommand(login.command);
+    await runCommand(command2, login.args);
+  } else {
+    await runClaudeLoginFlow(options);
+  }
+  const status = await getClaudeStatus();
+  return { loggedIn: status.loggedIn };
+}
+async function runClaudeLoginFlow(options) {
+  const command2 = resolveWindowsCommand(getClaudeCommand());
+  const loginMethod = resolveClaudeLoginMethod(options);
+  const loginExperience = resolveClaudeLoginExperience(options);
+  await ensureClaudeOnboardingSettings();
+  const settingsPath = await createClaudeLoginSettingsFile(loginMethod);
+  const loginTimeoutMs = Number(process.env.AGENTCONNECT_CLAUDE_LOGIN_TIMEOUT_MS || 18e4);
+  const loginArgs = settingsPath ? ["--settings", settingsPath] : [];
+  let ptyProcess = null;
+  let childExited = false;
+  const cleanup = async () => {
+    if (ptyProcess) {
+      try {
+        ptyProcess.kill();
+      } catch {
+      }
+    }
+    if (settingsPath) {
+      try {
+        await rm(settingsPath, { force: true });
+      } catch {
+      }
+    }
+  };
+  try {
+    if (loginExperience === "terminal") {
+      await openClaudeLoginTerminal(command2, loginArgs, false);
+    } else {
+      const ptyModule = await loadPtyModule();
+      if (!ptyModule) {
+        throw new Error(
+          "Claude login requires node-pty. Reinstall AgentConnect or run `claude /login` manually."
+        );
+      }
+      ptyProcess = ptyModule.spawn(command2, [...loginArgs, "/login"], {
+        name: "xterm-256color",
+        cols: 100,
+        rows: 30,
+        cwd: os2.homedir(),
+        env: { ...process.env, TERM: "xterm-256color" }
+      });
+      let outputBuffer = "";
+      ptyProcess.onData((data) => {
+        outputBuffer += data;
+        if (outputBuffer.length > 6e3) {
+          outputBuffer = outputBuffer.slice(-3e3);
+        }
+        const advanced = maybeAdvanceClaudeOnboarding(outputBuffer, loginMethod, (input) => {
+          ptyProcess?.write(input);
+        });
+        if (advanced) outputBuffer = "";
+      });
+      ptyProcess.onExit(() => {
+        childExited = true;
+      });
+    }
+    const start = Date.now();
+    while (Date.now() - start < loginTimeoutMs) {
+      const authed = await hasClaudeAuth();
+      if (authed) {
+        return;
+      }
+      if (childExited) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+    throw new Error(
+      "Claude login timed out. Finish login in your browser or run `claude` manually to authenticate."
+    );
+  } finally {
+    await cleanup();
+  }
+}
+function safeJsonParse(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function mapClaudeModel(model) {
+  if (!model) return null;
+  const value = String(model).toLowerCase();
+  if (value === "default" || value === "recommended") return null;
+  if (value === "claude-default" || value === "claude-recommended") return null;
+  if (value.includes("opus")) return "opus";
+  if (value.includes("sonnet")) return "sonnet";
+  if (value.includes("haiku")) return "haiku";
+  if (value.startsWith("claude-")) return value.replace("claude-", "");
+  return model;
+}
+function extractSessionId(msg) {
+  const direct = msg.session_id ?? msg.sessionId;
+  if (typeof direct === "string" && direct) return direct;
+  const nested = msg.message?.session_id ?? msg.message?.sessionId;
+  return typeof nested === "string" && nested ? nested : null;
+}
+function extractAssistantDelta(msg) {
+  const type = String(msg.type ?? "");
+  if (type === "stream_event") {
+    const ev = msg.event ?? {};
+    if (ev.type === "content_block_delta") {
+      const text2 = ev.delta?.text;
+      return typeof text2 === "string" && text2 ? text2 : null;
+    }
+  }
+  if (type === "content_block_delta") {
+    const text2 = msg.delta?.text;
+    return typeof text2 === "string" && text2 ? text2 : null;
+  }
+  const text = msg.delta?.text;
+  return typeof text === "string" && text ? text : null;
+}
+function extractAssistantText(msg) {
+  if (String(msg.type ?? "") !== "assistant") return null;
+  const content = msg.message?.content;
+  if (!Array.isArray(content)) return null;
+  const textBlock = content.find((c) => c && typeof c === "object" && c.type === "text");
+  const text = textBlock?.text;
+  return typeof text === "string" && text ? text : null;
+}
+function extractResultText(msg) {
+  if (String(msg.type ?? "") !== "result") return null;
+  const text = msg.result;
+  return typeof text === "string" && text ? text : null;
+}
+function runClaudePrompt({
+  prompt,
+  resumeSessionId,
+  model,
+  cwd,
+  onEvent,
+  signal
+}) {
+  return new Promise((resolve) => {
+    const command2 = getClaudeCommand();
+    const args2 = [
+      "-p",
+      "--output-format=stream-json",
+      "--verbose",
+      "--permission-mode",
+      "bypassPermissions"
+    ];
+    const modelValue = mapClaudeModel(model);
+    if (modelValue) {
+      args2.push("--model", modelValue);
+    }
+    if (resumeSessionId) args2.push("--resume", resumeSessionId);
+    args2.push(prompt);
+    const child = spawn2(command2, args2, {
+      cwd,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        child.kill("SIGTERM");
+      });
+    }
+    let aggregated = "";
+    let finalSessionId = null;
+    let didFinalize = false;
+    let sawError = false;
+    const emitError = (message) => {
+      if (sawError) return;
+      sawError = true;
+      onEvent({ type: "error", message });
+    };
+    const emitFinal = (text) => {
+      if (finalSessionId) {
+        onEvent({ type: "final", text, providerSessionId: finalSessionId });
+      } else {
+        onEvent({ type: "final", text });
+      }
+    };
+    const handleLine = (line) => {
+      const parsed = safeJsonParse(line);
+      if (!parsed || typeof parsed !== "object") {
+        if (line.trim()) {
+          onEvent({ type: "raw_line", line });
+        }
+        return;
+      }
+      const msg = parsed;
+      const sid = extractSessionId(msg);
+      if (sid) finalSessionId = sid;
+      const delta = extractAssistantDelta(msg);
+      if (delta) {
+        aggregated += delta;
+        onEvent({ type: "delta", text: delta });
+        return;
+      }
+      const assistant = extractAssistantText(msg);
+      if (assistant && !aggregated) {
+        aggregated = assistant;
+        onEvent({ type: "delta", text: assistant });
+        return;
+      }
+      const result = extractResultText(msg);
+      if (result && !didFinalize && !sawError) {
+        didFinalize = true;
+        emitFinal(aggregated || result);
+      }
+    };
+    const stdoutParser = createLineParser(handleLine);
+    const stderrParser = createLineParser(handleLine);
+    child.stdout?.on("data", stdoutParser);
+    child.stderr?.on("data", stderrParser);
+    child.on("close", (code) => {
+      if (!didFinalize) {
+        if (code && code !== 0) {
+          emitError(`Claude exited with code ${code}`);
+        } else if (!sawError) {
+          emitFinal(aggregated);
+        }
+      }
+      resolve({ sessionId: finalSessionId });
+    });
+    child.on("error", (err) => {
+      emitError(err?.message ?? "Claude failed to start");
+      resolve({ sessionId: finalSessionId });
+    });
+  });
+}
+
+// src/providers/codex.ts
+import { spawn as spawn3 } from "child_process";
+import path3 from "path";
+var CODEX_PACKAGE = "@openai/codex";
+var DEFAULT_LOGIN2 = "codex login";
+var DEFAULT_STATUS2 = "codex login status";
+var CODEX_MODELS_CACHE_TTL_MS = 6e4;
+var codexModelsCache = null;
+var codexModelsCacheAt = 0;
+function trimOutput(value, limit = 400) {
+  const cleaned = value.trim();
+  if (!cleaned) return "";
+  if (cleaned.length <= limit) return cleaned;
+  return `${cleaned.slice(0, limit)}...`;
+}
+function buildCodexExecArgs(options) {
+  const { prompt, cdTarget, resumeSessionId, model, reasoningEffort, mode } = options;
+  const args2 = ["exec", "--skip-git-repo-check"];
+  if (mode === "legacy") {
+    args2.push("--json", "-C", cdTarget);
+  } else {
+    args2.push("--experimental-json", "--cd", cdTarget);
+  }
+  args2.push("--yolo");
+  if (model) {
+    args2.push("--model", String(model));
+  }
+  if (reasoningEffort) {
+    args2.push("--config", `model_reasoning_effort=${reasoningEffort}`);
+  }
+  if (resumeSessionId) {
+    args2.push("resume", resumeSessionId);
+  }
+  args2.push(prompt);
+  return args2;
+}
+function shouldFallbackToLegacy(lines) {
+  const combined = lines.join(" ").toLowerCase();
+  if (!(combined.includes("unknown flag") || combined.includes("unknown option") || combined.includes("unrecognized option") || combined.includes("unknown argument") || combined.includes("unexpected argument") || combined.includes("invalid option") || combined.includes("invalid argument"))) {
+    return false;
+  }
+  return combined.includes("experimental-json") || combined.includes("--cd");
+}
+function getCodexCommand() {
+  const override = process.env.AGENTCONNECT_CODEX_COMMAND;
+  const base = override || "codex";
+  const resolved = resolveCommandPath(base);
+  return resolved || resolveWindowsCommand(base);
+}
+async function ensureCodexInstalled() {
+  const command2 = getCodexCommand();
+  const versionCheck = await checkCommandVersion(command2, [["--version"], ["-V"]]);
+  if (versionCheck.ok) {
+    return { installed: true, version: versionCheck.version || void 0 };
+  }
+  if (commandExists(command2)) {
+    return { installed: true, version: void 0 };
+  }
+  const install = await buildInstallCommandAuto(CODEX_PACKAGE);
+  if (!install.command) {
+    return { installed: false, version: void 0, packageManager: install.packageManager };
+  }
+  debugLog("Codex", "install", { command: install.command, args: install.args });
+  const installResult = await runCommand(install.command, install.args, {
+    shell: process.platform === "win32"
+  });
+  debugLog("Codex", "install-result", {
+    code: installResult.code,
+    stderr: trimOutput(installResult.stderr)
+  });
+  const after = await checkCommandVersion(command2, [["--version"], ["-V"]]);
+  codexModelsCache = null;
+  codexModelsCacheAt = 0;
+  return {
+    installed: after.ok,
+    version: after.version || void 0,
+    packageManager: install.packageManager
+  };
+}
+async function getCodexStatus() {
+  const command2 = getCodexCommand();
+  const versionCheck = await checkCommandVersion(command2, [["--version"], ["-V"]]);
+  const installed = versionCheck.ok || commandExists(command2);
+  let loggedIn = false;
+  if (installed) {
+    const status = buildStatusCommand("AGENTCONNECT_CODEX_STATUS", DEFAULT_STATUS2);
+    if (status.command) {
+      const statusCommand = resolveWindowsCommand(status.command);
+      const result = await runCommand(statusCommand, status.args);
+      loggedIn = result.code === 0;
+    }
+  }
+  return { installed, loggedIn, version: versionCheck.version || void 0 };
+}
+async function loginCodex() {
+  const login = buildLoginCommand("AGENTCONNECT_CODEX_LOGIN", DEFAULT_LOGIN2);
+  if (!login.command) {
+    return { loggedIn: false };
+  }
+  const command2 = resolveWindowsCommand(login.command);
+  debugLog("Codex", "login", { command: command2, args: login.args });
+  const result = await runCommand(command2, login.args, { env: { ...process.env, CI: "1" } });
+  debugLog("Codex", "login-result", { code: result.code, stderr: trimOutput(result.stderr) });
+  const status = await getCodexStatus();
+  codexModelsCache = null;
+  codexModelsCacheAt = 0;
+  return { loggedIn: status.loggedIn };
+}
+function safeJsonParse2(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function extractSessionId2(ev) {
+  const t = String(ev.type ?? "");
+  if (t === "thread.started") {
+    return typeof ev.thread_id === "string" ? ev.thread_id : null;
+  }
+  const id = ev.thread_id ?? ev.threadId ?? ev.session_id ?? ev.sessionId;
+  return typeof id === "string" ? id : null;
+}
+function extractUsage(ev) {
+  const usage = ev.usage ?? ev.token_usage ?? ev.tokens ?? ev.tokenUsage;
+  if (!usage || typeof usage !== "object") return null;
+  const toNumber = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  const input = toNumber(
+    usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens ?? usage.promptTokens
+  );
+  const output = toNumber(
+    usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens ?? usage.completionTokens
+  );
+  const total = toNumber(usage.total_tokens ?? usage.totalTokens);
+  const cached = toNumber(usage.cached_input_tokens ?? usage.cachedInputTokens);
+  const out = {};
+  if (input !== void 0) out.input_tokens = input;
+  if (output !== void 0) out.output_tokens = output;
+  if (total !== void 0) out.total_tokens = total;
+  if (cached !== void 0) out.cached_input_tokens = cached;
+  return Object.keys(out).length ? out : null;
+}
+function normalizeItem(raw) {
+  if (!raw || typeof raw !== "object") return raw;
+  const item = raw;
+  const type = item.type;
+  const id = item.id;
+  if (type === "command_execution" && id) {
+    return {
+      id,
+      type,
+      command: item.command || "",
+      aggregated_output: item.aggregated_output,
+      exit_code: item.exit_code,
+      status: item.status
+    };
+  }
+  if (type === "reasoning" && id) {
+    return { id, type, text: item.text || "" };
+  }
+  if (type === "agent_message" && id) {
+    return { id, type, text: item.text || "" };
+  }
+  return raw;
+}
+function normalizeEvent(raw) {
+  const type = typeof raw.type === "string" ? raw.type : "unknown";
+  if (type === "item.started" || type === "item.completed") {
+    return { type, item: normalizeItem(raw.item) };
+  }
+  if (type === "agent_message") {
+    return { type, text: raw.text || "" };
+  }
+  if (type === "error") {
+    return { type, message: raw.message || "Unknown error" };
+  }
+  return { ...raw, type };
+}
+function isTerminalEvent(ev) {
+  const t = String(ev.type ?? "");
+  return t === "turn.completed" || t === "turn.failed";
+}
+function normalizeEffortId(raw) {
+  if (!raw) return null;
+  return String(raw).trim().toLowerCase();
+}
+function formatEffortLabel(id) {
+  if (!id) return "";
+  const normalized = String(id).trim().toLowerCase();
+  if (normalized === "xhigh") return "X-High";
+  if (normalized === "none") return "None";
+  if (normalized === "minimal") return "Minimal";
+  if (normalized === "low") return "Low";
+  if (normalized === "medium") return "Medium";
+  if (normalized === "high") return "High";
+  return normalized.toUpperCase();
+}
+function normalizeEffortOptions(raw) {
+  if (!Array.isArray(raw)) return [];
+  const options = raw.map((entry) => {
+    if (!entry || typeof entry !== "object") return null;
+    const opt = entry;
+    const id = normalizeEffortId(
+      opt.reasoning_effort ?? opt.reasoningEffort ?? opt.effort ?? opt.level
+    );
+    if (!id) return null;
+    const label = formatEffortLabel(id);
+    return { id, label };
+  }).filter((x) => x !== null);
+  const seen = /* @__PURE__ */ new Set();
+  return options.filter((option) => {
+    if (seen.has(option.id)) return false;
+    seen.add(option.id);
+    return true;
+  });
+}
+function normalizeCodexModels(raw) {
+  const response = raw;
+  const list = Array.isArray(response?.data) ? response.data : Array.isArray(response?.items) ? response.items : [];
+  const mapped = [];
+  for (const item of list) {
+    if (!item || typeof item !== "object") continue;
+    const id = item.id || item.model;
+    if (!id) continue;
+    const displayName = item.displayName || item.display_name || item.name || item.title || String(id);
+    const reasoningEfforts = normalizeEffortOptions(
+      item.supportedReasoningEfforts || item.supported_reasoning_efforts || item.supportedReasoningLevels || item.supported_reasoning_levels
+    );
+    const defaultReasoningEffort = normalizeEffortId(
+      item.defaultReasoningEffort || item.default_reasoning_effort
+    );
+    mapped.push({
+      id: String(id),
+      provider: "codex",
+      displayName: String(displayName),
+      reasoningEfforts: reasoningEfforts.length ? reasoningEfforts : void 0,
+      defaultReasoningEffort: defaultReasoningEffort || void 0
+    });
+  }
+  if (!mapped.length) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return mapped.filter((model) => {
+    const key = model.id;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function fetchCodexModels(command2) {
+  return new Promise((resolve) => {
+    const child = spawn3(command2, ["app-server"], {
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let settled = false;
+    const initId = 1;
+    const listId = 2;
+    const timeout = setTimeout(() => {
+      finalize(null);
+    }, 8e3);
+    const finalize = (models) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      child.kill("SIGTERM");
+      resolve(models);
+    };
+    const handleLine = (line) => {
+      const parsed = safeJsonParse2(line);
+      if (!parsed || typeof parsed !== "object") return;
+      if (parsed.id === listId && parsed.result) {
+        finalize(normalizeCodexModels(parsed.result));
+      }
+      if (parsed.id === listId && parsed.error) {
+        finalize(null);
+      }
+    };
+    const stdoutParser = createLineParser(handleLine);
+    child.stdout?.on("data", stdoutParser);
+    child.stderr?.on("data", () => {
+    });
+    child.on("error", () => finalize(null));
+    child.on("close", () => finalize(null));
+    if (!child.stdin) {
+      finalize(null);
+      return;
+    }
+    const initialize = {
+      method: "initialize",
+      id: initId,
+      params: {
+        clientInfo: { name: "agentconnect", title: "AgentConnect", version: "0.1.0" }
+      }
+    };
+    const initialized = { method: "initialized" };
+    const listRequest = { method: "model/list", id: listId, params: { cursor: null, limit: null } };
+    const payload = `${JSON.stringify(initialize)}
+${JSON.stringify(initialized)}
+${JSON.stringify(
+      listRequest
+    )}
+`;
+    child.stdin.write(payload);
+  });
+}
+async function listCodexModels() {
+  if (codexModelsCache && Date.now() - codexModelsCacheAt < CODEX_MODELS_CACHE_TTL_MS) {
+    return codexModelsCache;
+  }
+  const command2 = getCodexCommand();
+  const versionCheck = await checkCommandVersion(command2, [["--version"], ["-V"]]);
+  if (!versionCheck.ok) {
+    return [];
+  }
+  const models = await fetchCodexModels(command2);
+  if (models && models.length) {
+    codexModelsCache = models;
+    codexModelsCacheAt = Date.now();
+    return models;
+  }
+  return [];
+}
+function runCodexPrompt({
+  prompt,
+  resumeSessionId,
+  model,
+  reasoningEffort,
+  repoRoot,
+  cwd,
+  onEvent,
+  signal
+}) {
+  return new Promise((resolve) => {
+    const command2 = getCodexCommand();
+    const resolvedRepoRoot = repoRoot ? path3.resolve(repoRoot) : null;
+    const resolvedCwd = cwd ? path3.resolve(cwd) : null;
+    const runDir = resolvedCwd || resolvedRepoRoot || process.cwd();
+    const cdTarget = resolvedRepoRoot || resolvedCwd || ".";
+    const runAttempt = (mode) => new Promise((attemptResolve) => {
+      const args2 = buildCodexExecArgs({
+        prompt,
+        cdTarget,
+        resumeSessionId,
+        model,
+        reasoningEffort,
+        mode
+      });
+      const argsPreview = [...args2];
+      if (argsPreview.length > 0) {
+        argsPreview[argsPreview.length - 1] = "[prompt]";
+      }
+      debugLog("Codex", "spawn", { command: command2, args: argsPreview, cwd: runDir, mode });
+      const child = spawn3(command2, args2, {
+        cwd: runDir,
+        env: { ...process.env },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          child.kill("SIGTERM");
+        });
+      }
+      let aggregated = "";
+      let finalSessionId = null;
+      let didFinalize = false;
+      let sawError = false;
+      const emitError = (message) => {
+        if (sawError) return;
+        sawError = true;
+        onEvent({ type: "error", message });
+      };
+      let sawJson = false;
+      const stdoutLines = [];
+      const stderrLines = [];
+      const pushLine = (list, line) => {
+        if (!line) return;
+        list.push(line);
+        if (list.length > 12) list.shift();
+      };
+      const emitFinal = (text) => {
+        if (finalSessionId) {
+          onEvent({ type: "final", text, providerSessionId: finalSessionId });
+        } else {
+          onEvent({ type: "final", text });
+        }
+      };
+      const handleLine = (line, source) => {
+        const parsed = safeJsonParse2(line);
+        if (!parsed || typeof parsed !== "object") {
+          if (line.trim()) {
+            onEvent({ type: "raw_line", line });
+          }
+          if (source === "stdout") {
+            pushLine(stdoutLines, line);
+          } else {
+            pushLine(stderrLines, line);
+          }
+          return;
+        }
+        sawJson = true;
+        const ev = parsed;
+        const normalized = normalizeEvent(ev);
+        onEvent({ type: "provider_event", provider: "codex", event: normalized });
+        const sid = extractSessionId2(ev);
+        if (sid) finalSessionId = sid;
+        const usage = extractUsage(ev);
+        if (usage) {
+          onEvent({
+            type: "usage",
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens
+          });
+        }
+        if (normalized.type === "agent_message") {
+          const text = normalized.text;
+          if (typeof text === "string" && text) {
+            aggregated += text;
+            onEvent({ type: "delta", text });
+          }
+        } else if (normalized.type === "item.completed") {
+          const item = normalized.item;
+          if (item && typeof item === "object") {
+            if (item.type === "command_execution" && typeof item.aggregated_output === "string") {
+              onEvent({ type: "delta", text: item.aggregated_output });
+            }
+            if (item.type === "agent_message" && typeof item.text === "string") {
+              aggregated += item.text;
+              onEvent({ type: "delta", text: item.text });
+            }
+          }
+        }
+        if (isTerminalEvent(ev) && !didFinalize) {
+          if (ev.type === "turn.failed") {
+            const message = ev.error?.message;
+            emitError(typeof message === "string" ? message : "Codex run failed");
+            didFinalize = true;
+            return;
+          }
+          if (!sawError) {
+            didFinalize = true;
+            emitFinal(aggregated);
+          }
+        }
+      };
+      const stdoutParser = createLineParser((line) => handleLine(line, "stdout"));
+      const stderrParser = createLineParser((line) => handleLine(line, "stderr"));
+      child.stdout?.on("data", stdoutParser);
+      child.stderr?.on("data", stderrParser);
+      child.on("close", (code) => {
+        if (!didFinalize) {
+          if (code && code !== 0) {
+            const hint = stderrLines.at(-1) || stdoutLines.at(-1) || "";
+            const suffix = hint ? `: ${hint}` : "";
+            const fallback = mode === "modern" && !sawJson && shouldFallbackToLegacy([
+              ...stderrLines,
+              ...stdoutLines
+            ]);
+            debugLog("Codex", "exit", {
+              code,
+              stderr: stderrLines,
+              stdout: stdoutLines,
+              fallback
+            });
+            if (fallback) {
+              attemptResolve({ sessionId: finalSessionId, fallback: true });
+              return;
+            }
+            emitError(`Codex exited with code ${code}${suffix}`);
+          } else if (!sawError) {
+            emitFinal(aggregated);
+          }
+        }
+        attemptResolve({ sessionId: finalSessionId, fallback: false });
+      });
+      child.on("error", (err) => {
+        debugLog("Codex", "spawn-error", { message: err?.message });
+        emitError(err?.message ?? "Codex failed to start");
+        attemptResolve({ sessionId: finalSessionId, fallback: false });
+      });
+    });
+    void (async () => {
+      const primary = await runAttempt("modern");
+      if (primary.fallback) {
+        debugLog("Codex", "fallback", { from: "modern", to: "legacy" });
+        const legacy = await runAttempt("legacy");
+        resolve({ sessionId: legacy.sessionId });
+        return;
+      }
+      resolve({ sessionId: primary.sessionId });
+    })();
+  });
+}
+
+// src/providers/local.ts
+function getLocalBaseUrl() {
+  const base = process.env.AGENTCONNECT_LOCAL_BASE_URL || "http://localhost:11434/v1";
+  return base.replace(/\/+$/, "");
+}
+function getLocalApiKey() {
+  return process.env.AGENTCONNECT_LOCAL_API_KEY || "";
+}
+function resolveLocalModel(model, fallback) {
+  if (!model) return fallback;
+  const raw = String(model);
+  if (raw === "local") return fallback;
+  if (raw.startsWith("local:")) return raw.slice("local:".length);
+  if (raw.startsWith("local/")) return raw.slice("local/".length);
+  return raw;
+}
+async function fetchJson(url, options = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 4e3);
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    if (!res.ok) {
+      return { ok: false, status: res.status, data: null };
+    }
+    const data = await res.json();
+    return { ok: true, status: res.status, data };
+  } catch {
+    return { ok: false, status: 0, data: null };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function ensureLocalInstalled() {
+  const base = getLocalBaseUrl();
+  const res = await fetchJson(`${base}/models`);
+  return { installed: res.ok };
+}
+async function getLocalStatus() {
+  const base = getLocalBaseUrl();
+  const res = await fetchJson(`${base}/models`);
+  if (!res.ok) return { installed: false, loggedIn: false };
+  return { installed: true, loggedIn: true };
+}
+async function loginLocal(options = {}) {
+  if (typeof options.baseUrl === "string") {
+    process.env.AGENTCONNECT_LOCAL_BASE_URL = options.baseUrl;
+  }
+  if (typeof options.apiKey === "string") {
+    process.env.AGENTCONNECT_LOCAL_API_KEY = options.apiKey;
+  }
+  if (typeof options.model === "string") {
+    process.env.AGENTCONNECT_LOCAL_MODEL = options.model;
+  }
+  if (Array.isArray(options.models)) {
+    process.env.AGENTCONNECT_LOCAL_MODELS = JSON.stringify(options.models.filter(Boolean));
+  }
+  const status = await getLocalStatus();
+  return { loggedIn: status.installed };
+}
+async function listLocalModels() {
+  const base = getLocalBaseUrl();
+  const res = await fetchJson(`${base}/models`);
+  if (!res.ok || !res.data || !Array.isArray(res.data.data)) return [];
+  return res.data.data.map((entry) => ({ id: entry.id, provider: "local", displayName: entry.id })).filter((entry) => entry.id);
+}
+async function runLocalPrompt({
+  prompt,
+  model,
+  onEvent
+}) {
+  const base = getLocalBaseUrl();
+  const fallback = process.env.AGENTCONNECT_LOCAL_MODEL || "";
+  const resolvedModel = resolveLocalModel(model, fallback);
+  if (!resolvedModel) {
+    onEvent({ type: "error", message: "Local provider model is not configured." });
+    return { sessionId: null };
+  }
+  const payload = {
+    model: resolvedModel,
+    messages: [{ role: "user", content: prompt }],
+    stream: false
+  };
+  const headers = { "Content-Type": "application/json" };
+  const apiKey = getLocalApiKey();
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  const res = await fetchJson(`${base}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    onEvent({ type: "error", message: "Local provider request failed." });
+    return { sessionId: null };
+  }
+  const message = res.data?.choices?.[0]?.message?.content;
+  const text = typeof message === "string" ? message : "";
+  if (text) {
+    onEvent({ type: "delta", text });
+    onEvent({ type: "final", text });
+  } else {
+    onEvent({ type: "error", message: "Local provider returned no content." });
+  }
+  return { sessionId: null };
+}
+
+// src/providers/index.ts
+var providers = {
+  claude: {
+    id: "claude",
+    name: "Claude",
+    ensureInstalled: ensureClaudeInstalled,
+    status: getClaudeStatus,
+    login: loginClaude,
+    logout: async () => {
+    },
+    runPrompt: runClaudePrompt
+  },
+  codex: {
+    id: "codex",
+    name: "Codex",
+    ensureInstalled: ensureCodexInstalled,
+    status: getCodexStatus,
+    login: loginCodex,
+    logout: async () => {
+    },
+    runPrompt: runCodexPrompt
+  },
+  local: {
+    id: "local",
+    name: "Local",
+    ensureInstalled: ensureLocalInstalled,
+    status: getLocalStatus,
+    login: loginLocal,
+    logout: async () => {
+    },
+    runPrompt: runLocalPrompt
+  }
+};
+async function listModels() {
+  const claudeModels = await listClaudeModels();
+  const codexModels = await listCodexModels();
+  const base = [
+    ...claudeModels,
+    { id: "local", provider: "local", displayName: "Local Model" }
+  ];
+  const envModels = process.env.AGENTCONNECT_LOCAL_MODELS;
+  if (envModels) {
+    try {
+      const parsed = JSON.parse(envModels);
+      if (Array.isArray(parsed)) {
+        for (const entry of parsed) {
+          if (typeof entry === "string" && entry) {
+            base.push({ id: entry, provider: "local", displayName: entry });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const discovered = await listLocalModels();
+  const all = [...base, ...codexModels, ...discovered.filter((entry) => entry.id !== "local")];
+  const seen = /* @__PURE__ */ new Set();
+  return all.filter((entry) => {
+    const key = `${entry.provider}:${entry.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function listRecentModels(providerId) {
+  if (providerId && providerId !== "claude") return [];
+  const recent = await listClaudeRecentModels();
+  return recent.filter((entry) => entry.provider === "claude");
+}
+function resolveProviderForModel(model) {
+  const lower = String(model || "").toLowerCase();
+  if (lower.includes("codex")) return "codex";
+  if (lower.startsWith("gpt") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4")) {
+    return "codex";
+  }
+  if (lower.includes("local")) return "local";
+  if (lower.includes("opus") || lower.includes("sonnet") || lower.includes("haiku"))
+    return "claude";
+  if (lower.includes("claude")) return "claude";
+  return "claude";
+}
+
+// src/observed.ts
+import fs from "fs";
+import path4 from "path";
+function createObservedTracker({
+  basePath,
+  appId,
+  requested = []
+}) {
+  const requestedList = Array.isArray(requested) ? requested.filter(Boolean) : [];
+  const dirPath = path4.join(basePath, ".agentconnect");
+  const filePath = path4.join(dirPath, "observed-capabilities.json");
+  const observed = /* @__PURE__ */ new Set();
+  let writeTimer = null;
+  function load() {
+    if (!fs.existsSync(filePath)) return;
+    try {
+      const raw = fs.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed?.observed)) {
+        for (const entry of parsed.observed) {
+          if (typeof entry === "string" && entry) observed.add(entry);
+        }
+      }
+    } catch {
+    }
+  }
+  function snapshot() {
+    return {
+      appId,
+      requested: requestedList,
+      observed: Array.from(observed).sort(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  function flush() {
+    if (writeTimer) {
+      clearTimeout(writeTimer);
+      writeTimer = null;
+    }
+    const payload = JSON.stringify(snapshot(), null, 2);
+    fs.mkdirSync(dirPath, { recursive: true });
+    fs.writeFileSync(filePath, payload);
+  }
+  function scheduleFlush() {
+    if (writeTimer) return;
+    writeTimer = setTimeout(() => {
+      flush();
+    }, 400);
+  }
+  function record(capability) {
+    const value = typeof capability === "string" ? capability.trim() : "";
+    if (!value) return;
+    if (observed.has(value)) return;
+    observed.add(value);
+    scheduleFlush();
+  }
+  function list() {
+    return Array.from(observed).sort();
+  }
+  load();
+  return {
+    record,
+    list,
+    snapshot,
+    flush
+  };
+}
+
+// src/host.ts
+function send(socket, payload) {
+  socket.send(JSON.stringify(payload));
+}
+function reply(socket, id, result) {
+  send(socket, { jsonrpc: "2.0", id, result });
+}
+function replyError(socket, id, code, message) {
+  send(socket, {
+    jsonrpc: "2.0",
+    id,
+    error: { code, message }
+  });
+}
+function sessionEvent(socket, sessionId, type, data) {
+  send(socket, {
+    jsonrpc: "2.0",
+    method: "acp.session.event",
+    params: { sessionId, type, data }
+  });
+}
+function buildProviderList(statuses) {
+  return Object.values(providers).map((provider) => {
+    const info = statuses[provider.id] || {};
+    return {
+      id: provider.id,
+      name: provider.name,
+      installed: info.installed ?? false,
+      loggedIn: info.loggedIn ?? false,
+      version: info.version
+    };
+  });
+}
+function startDevHost({
+  host = "127.0.0.1",
+  port = 9630,
+  appPath,
+  uiUrl
+} = {}) {
+  process.env.AGENTCONNECT_HOST_MODE ||= "dev";
+  const server = http.createServer();
+  const wss = new WebSocketServer({ server });
+  const sessions = /* @__PURE__ */ new Map();
+  const activeRuns = /* @__PURE__ */ new Map();
+  const processTable = /* @__PURE__ */ new Map();
+  const backendState = /* @__PURE__ */ new Map();
+  const statusCache = /* @__PURE__ */ new Map();
+  const statusCacheTtlMs = 2e3;
+  const basePath = appPath || process.cwd();
+  const manifest = readManifest(basePath);
+  const appId = manifest?.id || "agentconnect-dev-app";
+  const requestedCapabilities = Array.isArray(manifest?.capabilities) ? manifest.capabilities : [];
+  const observedTracker = createObservedTracker({
+    basePath,
+    appId,
+    requested: requestedCapabilities
+  });
+  function resolveAppPathInternal(input) {
+    if (!input) return basePath;
+    const value = String(input);
+    return path5.isAbsolute(value) ? value : path5.resolve(basePath, value);
+  }
+  function mapFileType(stat) {
+    if (stat.isFile()) return "file";
+    if (stat.isDirectory()) return "dir";
+    if (stat.isSymbolicLink()) return "link";
+    return "other";
+  }
+  async function allocatePort() {
+    return new Promise((resolve, reject) => {
+      const socket = net.createServer();
+      socket.listen(0, host, () => {
+        const address = socket.address();
+        if (!address || typeof address === "string") {
+          socket.close();
+          reject(new Error("Failed to allocate port."));
+          return;
+        }
+        const portValue = address.port;
+        socket.close(() => resolve(portValue));
+      });
+      socket.on("error", reject);
+    });
+  }
+  async function waitForHealthcheck(url, timeoutMs = 15e3) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const res = await fetch(url, { method: "GET" });
+        if (res.ok) return true;
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return false;
+  }
+  function readManifest(root) {
+    try {
+      const raw = fs2.readFileSync(path5.join(root, "agentconnect.app.json"), "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  function recordCapability(capability) {
+    observedTracker.record(capability);
+  }
+  function recordModelCapability(model) {
+    const providerId = resolveProviderForModel(model);
+    if (!providerId) return;
+    recordCapability(`model.${providerId}`);
+  }
+  async function getCachedStatus(provider) {
+    const cached = statusCache.get(provider.id);
+    const now = Date.now();
+    if (cached && now - cached.at < statusCacheTtlMs) {
+      return cached.status;
+    }
+    const status = await provider.status();
+    statusCache.set(provider.id, { status, at: now });
+    return status;
+  }
+  function invalidateStatus(providerId) {
+    if (!providerId) return;
+    statusCache.delete(providerId);
+  }
+  wss.on("connection", (socket) => {
+    socket.on("message", async (raw) => {
+      let payload;
+      try {
+        payload = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (!payload || payload.jsonrpc !== "2.0" || payload.id === void 0) {
+        return;
+      }
+      const id = payload.id;
+      const method = payload.method;
+      const params = payload.params ?? {};
+      if (typeof method === "string" && method.startsWith("acp.")) {
+        recordCapability("agent.connect");
+      }
+      if (method === "acp.hello") {
+        const loginExperience = process.env.AGENTCONNECT_LOGIN_EXPERIENCE || process.env.AGENTCONNECT_CLAUDE_LOGIN_EXPERIENCE || (process.env.AGENTCONNECT_HOST_MODE === "dev" ? "terminal" : "embedded");
+        reply(socket, id, {
+          hostId: "agentconnect-dev",
+          hostName: "AgentConnect Dev Host",
+          hostVersion: "0.1.0",
+          protocolVersion: "0.1",
+          mode: "local",
+          capabilities: [],
+          providers: Object.keys(providers),
+          loginExperience
+        });
+        return;
+      }
+      if (method === "acp.providers.list") {
+        const statusEntries = await Promise.all(
+          Object.values(providers).map(async (provider) => {
+            try {
+              return [provider.id, await getCachedStatus(provider)];
+            } catch {
+              return [provider.id, { installed: false, loggedIn: false }];
+            }
+          })
+        );
+        const statuses = Object.fromEntries(statusEntries);
+        reply(socket, id, { providers: buildProviderList(statuses) });
+        return;
+      }
+      if (method === "acp.providers.status") {
+        const providerId = params.provider;
+        const provider = providers[providerId];
+        if (!provider) {
+          replyError(socket, id, "AC_ERR_UNSUPPORTED", "Unknown provider");
+          return;
+        }
+        const status = await getCachedStatus(provider);
+        reply(socket, id, {
+          provider: {
+            id: provider.id,
+            name: provider.name,
+            installed: status.installed,
+            loggedIn: status.loggedIn,
+            version: status.version
+          }
+        });
+        return;
+      }
+      if (method === "acp.providers.ensureInstalled") {
+        const providerId = params.provider;
+        const provider = providers[providerId];
+        if (!provider) {
+          replyError(socket, id, "AC_ERR_UNSUPPORTED", "Unknown provider");
+          return;
+        }
+        const result = await provider.ensureInstalled();
+        invalidateStatus(provider.id);
+        reply(socket, id, result);
+        return;
+      }
+      if (method === "acp.providers.login") {
+        const providerId = params.provider;
+        const provider = providers[providerId];
+        if (!provider) {
+          replyError(socket, id, "AC_ERR_UNSUPPORTED", "Unknown provider");
+          return;
+        }
+        try {
+          const result = await provider.login(params.options);
+          invalidateStatus(provider.id);
+          reply(socket, id, result);
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_INTERNAL",
+            err?.message || "Provider login failed."
+          );
+        }
+        return;
+      }
+      if (method === "acp.providers.logout") {
+        const providerId = params.provider;
+        const provider = providers[providerId];
+        if (!provider) {
+          replyError(socket, id, "AC_ERR_UNSUPPORTED", "Unknown provider");
+          return;
+        }
+        await provider.logout();
+        invalidateStatus(provider.id);
+        reply(socket, id, {});
+        return;
+      }
+      if (method === "acp.models.list") {
+        const models = await listModels();
+        const providerId = params.provider;
+        if (providerId) {
+          reply(socket, id, { models: models.filter((m) => m.provider === providerId) });
+        } else {
+          reply(socket, id, { models });
+        }
+        return;
+      }
+      if (method === "acp.models.recent") {
+        const providerId = params.provider;
+        const models = await listRecentModels(providerId);
+        reply(socket, id, { models });
+        return;
+      }
+      if (method === "acp.models.info") {
+        const modelId = params.model;
+        const model = (await listModels()).find((m) => m.id === modelId);
+        if (!model) {
+          replyError(socket, id, "AC_ERR_INVALID_ARGS", "Unknown model");
+          return;
+        }
+        reply(socket, id, { model });
+        return;
+      }
+      if (method === "acp.sessions.create") {
+        const sessionId = `sess_${Math.random().toString(36).slice(2, 10)}`;
+        const model = params.model || "claude-opus";
+        const reasoningEffort = params.reasoningEffort || null;
+        const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : void 0;
+        const repoRoot = params.repoRoot ? resolveAppPathInternal(params.repoRoot) : void 0;
+        const providerId = resolveProviderForModel(model);
+        recordModelCapability(model);
+        sessions.set(sessionId, {
+          id: sessionId,
+          providerId,
+          model,
+          providerSessionId: null,
+          reasoningEffort,
+          cwd,
+          repoRoot
+        });
+        reply(socket, id, { sessionId });
+        return;
+      }
+      if (method === "acp.sessions.resume") {
+        const sessionId = params.sessionId;
+        const existing = sessions.get(sessionId);
+        if (!existing) {
+          const model = params.model || "claude-opus";
+          const reasoningEffort = params.reasoningEffort || null;
+          const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : void 0;
+          const repoRoot = params.repoRoot ? resolveAppPathInternal(params.repoRoot) : void 0;
+          recordModelCapability(model);
+          sessions.set(sessionId, {
+            id: sessionId,
+            providerId: resolveProviderForModel(model),
+            model,
+            providerSessionId: params.providerSessionId || null,
+            reasoningEffort,
+            cwd,
+            repoRoot
+          });
+        } else {
+          if (params.providerSessionId) {
+            existing.providerSessionId = String(params.providerSessionId);
+          }
+          if (params.cwd) {
+            existing.cwd = resolveAppPathInternal(params.cwd);
+          }
+          if (params.repoRoot) {
+            existing.repoRoot = resolveAppPathInternal(params.repoRoot);
+          }
+          recordModelCapability(existing.model);
+        }
+        reply(socket, id, { sessionId });
+        return;
+      }
+      if (method === "acp.sessions.send") {
+        const sessionId = params.sessionId;
+        const message = params.message?.content || "";
+        const session = sessions.get(sessionId);
+        if (!session) {
+          replyError(socket, id, "AC_ERR_INVALID_ARGS", "Unknown session");
+          return;
+        }
+        recordModelCapability(session.model);
+        const provider = providers[session.providerId];
+        if (!provider) {
+          replyError(socket, id, "AC_ERR_UNSUPPORTED", "Unknown provider");
+          return;
+        }
+        const status = await provider.status();
+        if (!status.installed) {
+          const installed = await provider.ensureInstalled();
+          if (!installed.installed) {
+            replyError(socket, id, "AC_ERR_NOT_INSTALLED", "Provider CLI is not installed.");
+            return;
+          }
+        }
+        const controller = new AbortController();
+        const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : session.cwd || basePath;
+        const repoRoot = params.repoRoot ? resolveAppPathInternal(params.repoRoot) : session.repoRoot || basePath;
+        activeRuns.set(sessionId, controller);
+        let sawError = false;
+        provider.runPrompt({
+          prompt: message,
+          resumeSessionId: session.providerSessionId,
+          model: session.model,
+          reasoningEffort: session.reasoningEffort,
+          repoRoot,
+          cwd,
+          signal: controller.signal,
+          onEvent: (event) => {
+            if (event.type === "error") {
+              sawError = true;
+            }
+            if (sawError && event.type === "final") {
+              return;
+            }
+            sessionEvent(socket, sessionId, event.type, { ...event });
+          }
+        }).then((result) => {
+          if (result?.sessionId) {
+            session.providerSessionId = result.sessionId;
+          }
+        }).catch((err) => {
+          if (!sawError) {
+            sessionEvent(socket, sessionId, "error", {
+              message: err?.message || "Provider error"
+            });
+          }
+        }).finally(() => {
+          activeRuns.delete(sessionId);
+        });
+        reply(socket, id, { accepted: true });
+        return;
+      }
+      if (method === "acp.sessions.cancel") {
+        const sessionId = params.sessionId;
+        const controller = activeRuns.get(sessionId);
+        if (controller) {
+          controller.abort();
+          activeRuns.delete(sessionId);
+        }
+        reply(socket, id, { cancelled: true });
+        return;
+      }
+      if (method === "acp.sessions.close") {
+        const sessionId = params.sessionId;
+        sessions.delete(sessionId);
+        reply(socket, id, { closed: true });
+        return;
+      }
+      if (method === "acp.fs.read") {
+        recordCapability("fs.read");
+        try {
+          const filePath = resolveAppPathInternal(params.path);
+          const encoding = params.encoding || "utf8";
+          const content = await fsp.readFile(filePath, encoding);
+          reply(socket, id, { content, encoding });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_FS_READ",
+            err?.message || "Failed to read file."
+          );
+        }
+        return;
+      }
+      if (method === "acp.fs.write") {
+        recordCapability("fs.write");
+        try {
+          const filePath = resolveAppPathInternal(params.path);
+          const encoding = params.encoding || "utf8";
+          const content = params.content ?? "";
+          await fsp.mkdir(path5.dirname(filePath), { recursive: true });
+          await fsp.writeFile(filePath, content, {
+            encoding,
+            mode: params.mode
+          });
+          const bytes = Buffer.byteLength(String(content), encoding);
+          reply(socket, id, { bytes });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_FS_WRITE",
+            err?.message || "Failed to write file."
+          );
+        }
+        return;
+      }
+      if (method === "acp.fs.list") {
+        recordCapability("fs.read");
+        try {
+          const dirPath = resolveAppPathInternal(params.path);
+          const entries = await fsp.readdir(dirPath, { withFileTypes: true });
+          const results = [];
+          for (const entry of entries) {
+            const entryPath = path5.join(dirPath, entry.name);
+            let size = 0;
+            let type = "other";
+            try {
+              const stat = await fsp.lstat(entryPath);
+              type = mapFileType(stat);
+              if (type === "file") size = stat.size;
+            } catch {
+              type = entry.isDirectory() ? "dir" : entry.isFile() ? "file" : "other";
+            }
+            results.push({
+              name: entry.name,
+              path: entryPath,
+              type,
+              size
+            });
+          }
+          reply(socket, id, { entries: results });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_FS_LIST",
+            err?.message || "Failed to list directory."
+          );
+        }
+        return;
+      }
+      if (method === "acp.fs.stat") {
+        recordCapability("fs.read");
+        try {
+          const filePath = resolveAppPathInternal(params.path);
+          const stat = await fsp.lstat(filePath);
+          reply(socket, id, {
+            type: mapFileType(stat),
+            size: stat.size,
+            mtime: stat.mtime.toISOString()
+          });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_FS_STAT",
+            err?.message || "Failed to stat file."
+          );
+        }
+        return;
+      }
+      if (method === "acp.process.spawn") {
+        recordCapability("process.spawn");
+        try {
+          const command2 = String(params.command || "");
+          const args2 = Array.isArray(params.args) ? params.args.map(String) : [];
+          const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : basePath;
+          const env = { ...process.env, ...params.env || {} };
+          const useTty = Boolean(params.tty);
+          const child = spawn4(command2, args2, {
+            cwd,
+            env,
+            stdio: useTty ? "inherit" : ["pipe", "pipe", "pipe"]
+          });
+          if (!useTty) {
+            child.stdout?.on("data", () => void 0);
+            child.stderr?.on("data", () => void 0);
+          }
+          if (typeof params.stdin === "string" && child.stdin) {
+            child.stdin.write(params.stdin);
+            child.stdin.end();
+          }
+          if (child.pid) {
+            processTable.set(child.pid, child);
+            child.on("close", () => {
+              if (child.pid) processTable.delete(child.pid);
+            });
+          }
+          reply(socket, id, { pid: child.pid });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_PROCESS",
+            err?.message || "Failed to spawn process."
+          );
+        }
+        return;
+      }
+      if (method === "acp.process.kill") {
+        recordCapability("process.kill");
+        const pid = Number(params.pid);
+        const signal = params.signal || "SIGTERM";
+        const child = processTable.get(pid);
+        try {
+          const success = child ? child.kill(signal) : process.kill(pid, signal);
+          reply(socket, id, { success: Boolean(success) });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_PROCESS",
+            err?.message || "Failed to kill process."
+          );
+        }
+        return;
+      }
+      if (method === "acp.net.request") {
+        recordCapability("network.request");
+        try {
+          if (typeof fetch !== "function") {
+            replyError(socket, id, "AC_ERR_NET", "Fetch is not available.");
+            return;
+          }
+          const controller = new AbortController();
+          const timeout = params.timeoutMs;
+          let timer = null;
+          if (timeout) {
+            timer = setTimeout(() => controller.abort(), Number(timeout));
+          }
+          const res = await fetch(String(params.url), {
+            method: params.method || "GET",
+            headers: params.headers || {},
+            body: params.body,
+            signal: controller.signal
+          });
+          if (timer) clearTimeout(timer);
+          const body = await res.text();
+          const headers = {};
+          res.headers.forEach((value, key) => {
+            headers[key] = value;
+          });
+          reply(socket, id, { status: res.status, headers, body });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_NET",
+            err?.message || "Network request failed."
+          );
+        }
+        return;
+      }
+      if (method === "acp.backend.start") {
+        recordCapability("backend.run");
+        if (!manifest?.backend) {
+          reply(socket, id, { status: "disabled" });
+          return;
+        }
+        const backendConfig = manifest.backend;
+        const existing = backendState.get(appId);
+        if (existing?.status === "running") {
+          reply(socket, id, { status: "running", url: existing.url });
+          return;
+        }
+        try {
+          let assignedPort = null;
+          const declaredPort = backendConfig.env?.PORT;
+          if (declaredPort === void 0 || String(declaredPort) === "0") {
+            assignedPort = await allocatePort();
+          } else if (!Number.isNaN(Number(declaredPort))) {
+            assignedPort = Number(declaredPort);
+          }
+          const env = {
+            ...process.env,
+            ...backendConfig.env || {},
+            AGENTCONNECT_HOST: `ws://${host}:${port}`,
+            AGENTCONNECT_APP_ID: appId
+          };
+          if (assignedPort) {
+            env.PORT = String(assignedPort);
+            env.AGENTCONNECT_APP_PORT = String(assignedPort);
+          }
+          const cwd = backendConfig.cwd ? resolveAppPathInternal(backendConfig.cwd) : basePath;
+          const args2 = backendConfig.args || [];
+          const child = spawn4(backendConfig.command, args2, {
+            cwd,
+            env,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          child.stdout?.on("data", () => void 0);
+          child.stderr?.on("data", () => void 0);
+          const url = assignedPort ? `http://${host}:${assignedPort}` : void 0;
+          const record = { status: "starting", pid: child.pid, url };
+          backendState.set(appId, record);
+          child.on("exit", () => {
+            backendState.set(appId, { status: "stopped" });
+          });
+          if (backendConfig.healthcheck?.type === "http" && assignedPort) {
+            const healthUrl = `http://${host}:${assignedPort}${backendConfig.healthcheck.path}`;
+            const ok = await waitForHealthcheck(healthUrl);
+            if (!ok) {
+              child.kill("SIGTERM");
+              backendState.set(appId, { status: "error" });
+              reply(socket, id, { status: "error" });
+              return;
+            }
+          }
+          backendState.set(appId, { status: "running", pid: child.pid, url });
+          reply(socket, id, { status: "running", url });
+        } catch (err) {
+          replyError(
+            socket,
+            id,
+            "AC_ERR_BACKEND",
+            err?.message || "Failed to start backend."
+          );
+        }
+        return;
+      }
+      if (method === "acp.backend.stop") {
+        recordCapability("backend.run");
+        const current = backendState.get(appId);
+        if (!current?.pid) {
+          backendState.set(appId, { status: "stopped" });
+          reply(socket, id, { status: "stopped" });
+          return;
+        }
+        try {
+          process.kill(current.pid, "SIGTERM");
+        } catch {
+        }
+        backendState.set(appId, { status: "stopped" });
+        reply(socket, id, { status: "stopped" });
+        return;
+      }
+      if (method === "acp.backend.status") {
+        recordCapability("backend.run");
+        const current = backendState.get(appId) || { status: "stopped" };
+        reply(socket, id, { status: current.status, url: current.url });
+        return;
+      }
+      if (method === "acp.capabilities.observed") {
+        reply(socket, id, { ...observedTracker.snapshot() });
+        return;
+      }
+      reply(socket, id, {});
+    });
+  });
+  server.listen(port, host, () => {
+    console.log(`AgentConnect dev host running at ws://${host}:${port}`);
+    if (appPath) console.log(`App path: ${appPath}`);
+    if (uiUrl) console.log(`UI dev server: ${uiUrl}`);
+  });
+  process.on("SIGINT", () => {
+    try {
+      observedTracker.flush();
+    } catch {
+    }
+    server.close(() => process.exit(0));
+  });
+}
+
+// src/paths.ts
+import path6 from "path";
+import { fileURLToPath } from "url";
+import { promises as fs3 } from "fs";
+async function exists(target) {
+  try {
+    await fs3.stat(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveAppPath(input) {
+  const candidate = input ? path6.resolve(input) : process.cwd();
+  return candidate;
+}
+async function findSchemaDir() {
+  const envDir = process.env.AGENTCONNECT_SCHEMA_DIR;
+  if (envDir && await exists(envDir)) return envDir;
+  const start = path6.dirname(fileURLToPath(import.meta.url));
+  const roots = [start, process.cwd()];
+  for (const root of roots) {
+    let current = root;
+    for (let i = 0; i < 8; i += 1) {
+      const candidate = path6.join(current, "schemas");
+      if (await exists(candidate)) return candidate;
+      const parent = path6.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  return null;
+}
+
+// src/zip.ts
+import fs5 from "fs";
+import path8 from "path";
+import { createHash } from "crypto";
+import yazl from "yazl";
+import yauzl from "yauzl";
+
+// src/fs-utils.ts
+import path7 from "path";
+import { promises as fs4 } from "fs";
+async function collectFiles(root, options = {}) {
+  const ignoreNames = new Set(options.ignoreNames || []);
+  const ignorePaths = new Set(options.ignorePaths || []);
+  const files = [];
+  async function walk(dir) {
+    const entries = await fs4.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (ignoreNames.has(entry.name)) continue;
+      const fullPath = path7.join(dir, entry.name);
+      const rel = path7.relative(root, fullPath);
+      if (ignorePaths.has(rel)) continue;
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        files.push({ fullPath, rel });
+      }
+    }
+  }
+  await walk(root);
+  return files.sort((a, b) => a.rel.localeCompare(b.rel));
+}
+async function readJson(filePath) {
+  const raw = await fs4.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+async function writeJson(filePath, data) {
+  await fs4.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs4.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+}
+async function fileExists(filePath) {
+  try {
+    await fs4.stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/zip.ts
+async function hashFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = fs5.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+async function zipDirectory({
+  inputDir,
+  outputPath,
+  ignoreNames = [],
+  ignorePaths = []
+}) {
+  await fs5.promises.mkdir(path8.dirname(outputPath), { recursive: true });
+  const zipfile = new yazl.ZipFile();
+  const files = await collectFiles(inputDir, { ignoreNames, ignorePaths });
+  for (const file of files) {
+    zipfile.addFile(file.fullPath, file.rel);
+  }
+  return new Promise((resolve, reject) => {
+    const outStream = fs5.createWriteStream(outputPath);
+    zipfile.outputStream.pipe(outStream);
+    outStream.on("close", () => resolve());
+    outStream.on("error", reject);
+    zipfile.end();
+  });
+}
+async function readZipEntry(zipPath, entryName) {
+  return new Promise((resolve, reject) => {
+    yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+      if (err || !zipfile) {
+        reject(err || new Error("Unable to open zip"));
+        return;
+      }
+      let found = false;
+      zipfile.readEntry();
+      zipfile.on("entry", (entry) => {
+        if (entry.fileName === entryName || entry.fileName.endsWith(`/${entryName}`)) {
+          found = true;
+          zipfile.openReadStream(entry, (streamErr, stream) => {
+            if (streamErr || !stream) {
+              zipfile.close();
+              reject(streamErr || new Error("Unable to read zip entry"));
+              return;
+            }
+            const chunks = [];
+            stream.on("data", (chunk) => chunks.push(chunk));
+            stream.on("end", () => {
+              const content = Buffer.concat(chunks).toString("utf8");
+              zipfile.close();
+              resolve(content);
+            });
+            stream.on("error", reject);
+          });
+        } else {
+          zipfile.readEntry();
+        }
+      });
+      zipfile.on("end", () => {
+        if (!found) {
+          zipfile.close();
+          resolve(null);
+        }
+      });
+    });
+  });
+}
+
+// src/manifest.ts
+import path9 from "path";
+import Ajv from "ajv";
+async function readManifestFromDir(appPath) {
+  const manifestPath = path9.join(appPath, "agentconnect.app.json");
+  if (!await fileExists(manifestPath)) {
+    throw new Error("agentconnect.app.json not found in app directory.");
+  }
+  return readJson(manifestPath);
+}
+async function readManifestFromZip(zipPath) {
+  const content = await readZipEntry(zipPath, "agentconnect.app.json");
+  if (!content) {
+    throw new Error("agentconnect.app.json not found in zip.");
+  }
+  return JSON.parse(content);
+}
+async function loadManifestSchema() {
+  const schemaDir = await findSchemaDir();
+  if (!schemaDir) {
+    throw new Error("Unable to locate schemas directory.");
+  }
+  const schemaPath = path9.join(schemaDir, "app-manifest.json");
+  return readJson(schemaPath);
+}
+async function validateManifest(manifest) {
+  const schema = await loadManifestSchema();
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  const validate = ajv.compile(schema);
+  const valid = validate(manifest);
+  return { valid: Boolean(valid), errors: validate.errors || [] };
+}
+
+// src/registry.ts
+import path10 from "path";
+import { promises as fs6 } from "fs";
+function compareSemver(a, b) {
+  const parse = (v) => v.split("-")[0].split(".").map((n) => Number(n));
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+async function publishPackage({
+  zipPath,
+  signaturePath,
+  registryPath,
+  manifest
+}) {
+  const resolvedManifest = manifest || await readManifestFromZip(zipPath);
+  const appId = resolvedManifest.id;
+  const version = resolvedManifest.version;
+  if (!appId || !version) {
+    throw new Error("Manifest must include id and version.");
+  }
+  const entryDir = path10.join(registryPath, "apps", appId, version);
+  await fs6.mkdir(entryDir, { recursive: true });
+  const targetZip = path10.join(entryDir, "app.zip");
+  await fs6.copyFile(zipPath, targetZip);
+  const manifestPath = path10.join(entryDir, "manifest.json");
+  await writeJson(manifestPath, resolvedManifest);
+  let signatureOut = null;
+  if (signaturePath) {
+    signatureOut = path10.join(entryDir, "signature.json");
+    await fs6.copyFile(signaturePath, signatureOut);
+  }
+  const hash = await hashFile(zipPath);
+  const indexPath = path10.join(registryPath, "index.json");
+  const index = await fileExists(indexPath) ? await readJson(indexPath) : { apps: {} };
+  if (!index.apps) index.apps = {};
+  if (!index.apps[appId]) {
+    index.apps[appId] = { latest: version, versions: {} };
+  }
+  index.apps[appId].versions[version] = {
+    path: path10.relative(registryPath, targetZip).replace(/\\/g, "/"),
+    manifest: resolvedManifest,
+    signature: signatureOut ? {
+      algorithm: "unknown",
+      publicKey: "",
+      signature: ""
+    } : void 0,
+    hash
+  };
+  const currentLatest = index.apps[appId].latest;
+  if (!currentLatest || compareSemver(version, currentLatest) > 0) {
+    index.apps[appId].latest = version;
+  }
+  await writeJson(indexPath, index);
+  return { appId, version, hash, targetZip, manifestPath, signaturePath: signatureOut, indexPath };
+}
+
+// src/registry-validate.ts
+import path11 from "path";
+import { createPublicKey, verify as verifySignature } from "crypto";
+function compareSemver2(a, b) {
+  const parse = (v) => v.split("-")[0].split(".").map((n) => Number(n));
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function resolveEntry(registryPath, entryPath) {
+  if (!entryPath || typeof entryPath !== "string") return null;
+  return path11.resolve(registryPath, entryPath);
+}
+function normalizeSignatureAlg(signatureAlg) {
+  const value = String(signatureAlg || "").toLowerCase();
+  if (value === "ed25519") return null;
+  if (value === "rsa-sha256") return "sha256";
+  if (value === "ecdsa-sha256") return "sha256";
+  return "sha256";
+}
+async function verifySignatureFile({
+  signaturePath,
+  hash
+}) {
+  const signature = await readJson(signaturePath);
+  if (!signature || typeof signature !== "object") {
+    return { ok: false, message: "Signature payload is not valid JSON." };
+  }
+  if (signature.hash !== hash) {
+    return { ok: false, message: "Signature hash does not match app hash." };
+  }
+  const publicKey = signature.publicKey;
+  if (!publicKey || typeof publicKey !== "string") {
+    return { ok: false, message: "Signature is missing public key." };
+  }
+  const signatureValue = signature.signature;
+  if (!signatureValue || typeof signatureValue !== "string") {
+    return { ok: false, message: "Signature is missing signature bytes." };
+  }
+  const algorithm = normalizeSignatureAlg(signature.signatureAlg);
+  const key = createPublicKey(publicKey);
+  const payload = Buffer.from(hash, "hex");
+  const sigBuffer = Buffer.from(signatureValue, "base64");
+  const ok = verifySignature(algorithm, payload, key, sigBuffer);
+  return { ok, message: ok ? "" : "Signature verification failed." };
+}
+async function validateRegistry({
+  registryPath,
+  requireSignature = false
+}) {
+  const errors = [];
+  const warnings = [];
+  const indexPath = path11.join(registryPath, "index.json");
+  if (!await fileExists(indexPath)) {
+    return {
+      valid: false,
+      errors: [{ path: "index.json", message: "index.json not found." }],
+      warnings
+    };
+  }
+  const index = await readJson(indexPath).catch(() => null);
+  if (!index || typeof index !== "object") {
+    return {
+      valid: false,
+      errors: [{ path: "index.json", message: "index.json is not valid JSON." }],
+      warnings
+    };
+  }
+  const apps = index.apps;
+  if (!apps || typeof apps !== "object") {
+    return {
+      valid: false,
+      errors: [{ path: "index.json", message: "index.json missing apps map." }],
+      warnings
+    };
+  }
+  for (const [appId, appEntry] of Object.entries(apps)) {
+    if (!appEntry || typeof appEntry !== "object") {
+      errors.push({
+        path: `apps.${appId}`,
+        message: `App entry for ${appId} is invalid.`
+      });
+      continue;
+    }
+    const versions = appEntry.versions;
+    if (!versions || typeof versions !== "object") {
+      errors.push({
+        path: `apps.${appId}`,
+        message: `App entry for ${appId} missing versions.`
+      });
+      continue;
+    }
+    const versionKeys = Object.keys(versions);
+    if (!versionKeys.length) {
+      errors.push({
+        path: `apps.${appId}`,
+        message: `App entry for ${appId} has no versions.`
+      });
+      continue;
+    }
+    const latest = appEntry.latest;
+    if (latest && !versions[latest]) {
+      errors.push({
+        path: `apps.${appId}`,
+        message: `App ${appId} latest (${latest}) not found in versions.`
+      });
+    }
+    const sorted = [...versionKeys].sort(compareSemver2);
+    const expectedLatest = sorted[sorted.length - 1];
+    if (latest && expectedLatest && compareSemver2(latest, expectedLatest) !== 0) {
+      warnings.push({
+        path: `apps.${appId}`,
+        message: `App ${appId} latest (${latest}) is not the newest (${expectedLatest}).`
+      });
+    }
+    for (const [version, entry] of Object.entries(versions)) {
+      if (!entry || typeof entry !== "object") {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} entry is invalid.`
+        });
+        continue;
+      }
+      const zipPath = resolveEntry(registryPath, entry.path);
+      const manifestPath = resolveEntry(registryPath, entry.manifest);
+      const signaturePath = entry.signature ? resolveEntry(registryPath, entry.signature) : null;
+      if (!zipPath || !await fileExists(zipPath)) {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} app.zip missing.`
+        });
+        continue;
+      }
+      if (!manifestPath || !await fileExists(manifestPath)) {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} manifest missing.`
+        });
+        continue;
+      }
+      const hash = await hashFile(zipPath);
+      if (entry.hash && entry.hash !== hash) {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} hash mismatch.`
+        });
+      }
+      const manifest = await readJson(manifestPath).catch(
+        () => null
+      );
+      if (!manifest) {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} manifest invalid JSON.`
+        });
+        continue;
+      }
+      const manifestValidation = await validateManifest(manifest);
+      if (!manifestValidation.valid) {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} manifest failed schema validation.`
+        });
+      }
+      if (manifest.id !== appId || manifest.version !== version) {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} manifest id/version mismatch.`
+        });
+      }
+      if (signaturePath) {
+        if (!await fileExists(signaturePath)) {
+          errors.push({
+            path: `apps.${appId}.versions.${version}`,
+            message: `App ${appId}@${version} signature file missing.`
+          });
+        } else {
+          const verification = await verifySignatureFile({ signaturePath, hash });
+          if (!verification.ok) {
+            errors.push({
+              path: `apps.${appId}.versions.${version}`,
+              message: `App ${appId}@${version} signature invalid: ${verification.message}`
+            });
+          }
+        }
+      } else if (requireSignature) {
+        errors.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} is missing a signature.`
+        });
+      } else {
+        warnings.push({
+          path: `apps.${appId}.versions.${version}`,
+          message: `App ${appId}@${version} has no signature.`
+        });
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+var helpText = `agentconnect <command>
+
+Commands:
+  dev     Start a local AgentConnect host
+  pack    Package an app
+  verify  Verify an app package
+  sign    Sign an app package
+  publish Publish to registry
+  registry-verify  Validate a registry
+
+Dev options:
+  --host <host>   Host to bind (default: 127.0.0.1)
+  --port <port>   Port to bind (default: 9630)
+  --app <path>    App path (optional)
+  --ui <url>      UI dev server URL (optional)
+
+Pack options:
+  --app <path>    App directory (default: cwd)
+  --out <path>    Output zip path (default: dist/app.zip)
+
+Verify options:
+  --app <path>    App directory or zip
+  --json          Output JSON
+
+Sign options:
+  --app <path>    Zip path
+  --key <path>    Private key path (PEM)
+  --out <path>    Signature output path (default: dist/app.sig.json)
+
+Publish options:
+  --app <path>        Zip path
+  --registry <path>   Registry directory
+  --signature <path>  Signature file (optional)
+
+Registry-verify options:
+  --registry <path>        Registry directory
+  --require-signature      Fail if any entry lacks a signature
+  --json                   Output JSON
+`;
+function getFlag(name, alias) {
+  const idx = args.findIndex((arg) => arg === name || arg === alias);
+  if (idx === -1) return null;
+  return args[idx + 1] ?? null;
+}
+function parsePort(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+async function main() {
+  if (!command || command === "--help" || command === "-h") {
+    console.log(helpText);
+    return 0;
+  }
+  if (command === "dev") {
+    const host = getFlag("--host", "-H") ?? "127.0.0.1";
+    const port = parsePort(getFlag("--port", "-p"), 9630);
+    const appPath = getFlag("--app", "-a") ?? void 0;
+    const uiUrl = getFlag("--ui", "-u") ?? void 0;
+    startDevHost({ host, port, appPath, uiUrl });
+    return null;
+  }
+  if (command === "pack") {
+    const appPath = resolveAppPath(getFlag("--app", "-a") ?? void 0);
+    const outPath = getFlag("--out", "-o") || path12.join(appPath, "dist", "app.zip");
+    const manifest = await readManifestFromDir(appPath);
+    const validation = await validateManifest(manifest);
+    if (!validation.valid) {
+      console.error("Manifest validation failed.");
+      console.error(validation.errors);
+      return 1;
+    }
+    const ignoreNames = ["node_modules", ".git", ".DS_Store"];
+    const ignorePaths = [];
+    const outputRel = path12.relative(appPath, outPath);
+    if (!outputRel.startsWith("..") && outputRel !== "") {
+      ignorePaths.push(outputRel);
+    }
+    await zipDirectory({ inputDir: appPath, outputPath: outPath, ignoreNames, ignorePaths });
+    console.log(`Packed ${appPath} -> ${outPath}`);
+    return 0;
+  }
+  if (command === "verify") {
+    const appArg = getFlag("--app", "-a");
+    const jsonOut = args.includes("--json");
+    const appPath = resolveAppPath(appArg ?? void 0);
+    const stats = await fs7.stat(appPath).catch(() => null);
+    if (!stats) {
+      console.error("App path not found.");
+      return 1;
+    }
+    let manifest;
+    let hash = null;
+    if (stats.isDirectory()) {
+      manifest = await readManifestFromDir(appPath);
+    } else {
+      manifest = await readManifestFromZip(appPath);
+      hash = await hashFile(appPath);
+    }
+    const validation = await validateManifest(manifest);
+    const result = {
+      valid: validation.valid,
+      errors: validation.errors,
+      hash,
+      manifest
+    };
+    if (jsonOut) {
+      console.log(JSON.stringify(result, null, 2));
+      return validation.valid ? 0 : 1;
+    }
+    if (validation.valid) {
+      console.log("Manifest valid.");
+      if (hash) console.log(`SHA256: ${hash}`);
+      return 0;
+    }
+    console.error("Manifest validation failed.");
+    console.error(validation.errors);
+    return 1;
+  }
+  if (command === "sign") {
+    const appArg = getFlag("--app", "-a");
+    const keyPath = getFlag("--key", "-k");
+    if (!appArg || !keyPath) {
+      console.error("Usage: agentconnect sign --app <zip> --key <pem> [--out <path>]");
+      return 1;
+    }
+    const appPath = resolveAppPath(appArg);
+    const appStats = await fs7.stat(appPath).catch(() => null);
+    if (!appStats || !appStats.isFile()) {
+      console.error("Sign requires a zip file path.");
+      return 1;
+    }
+    const outPath = getFlag("--out", "-o") || path12.join(path12.dirname(appPath), "app.sig.json");
+    const manifest = await readManifestFromZip(appPath);
+    const hash = await hashFile(appPath);
+    const hashBuffer = Buffer.from(hash, "hex");
+    const privateKeyPem = await fs7.readFile(keyPath, "utf8");
+    const privateKey = createPrivateKey(privateKeyPem);
+    const keyType = privateKey.asymmetricKeyType;
+    const algorithm = keyType === "ed25519" ? null : "sha256";
+    const signatureAlg = keyType === "ed25519" ? "ed25519" : keyType === "rsa" ? "rsa-sha256" : keyType === "ec" ? "ecdsa-sha256" : "sha256";
+    const signature = signData(algorithm, hashBuffer, privateKey);
+    const publicKeyPem = createPublicKey2(privateKey).export({
+      type: "spki",
+      format: "pem"
+    });
+    const signaturePayload = {
+      appId: manifest.id,
+      version: manifest.version,
+      hash,
+      hashAlg: "sha256",
+      signature: signature.toString("base64"),
+      signatureAlg,
+      publicKey: publicKeyPem,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await fs7.mkdir(path12.dirname(outPath), { recursive: true });
+    await fs7.writeFile(outPath, JSON.stringify(signaturePayload, null, 2), "utf8");
+    console.log(`Signature written to ${outPath}`);
+    return 0;
+  }
+  if (command === "publish") {
+    const appArg = getFlag("--app", "-a");
+    const registry = getFlag("--registry", "-r");
+    const signaturePath = getFlag("--signature", "-s") ?? void 0;
+    if (!appArg || !registry) {
+      console.error(
+        "Usage: agentconnect publish --app <zip> --registry <path> [--signature <path>]"
+      );
+      return 1;
+    }
+    const appPath = resolveAppPath(appArg);
+    const appStats = await fs7.stat(appPath).catch(() => null);
+    if (!appStats || !appStats.isFile()) {
+      console.error("Publish requires a zip file path.");
+      return 1;
+    }
+    const registryPath = resolveAppPath(registry);
+    const manifest = await readManifestFromZip(appPath);
+    const validation = await validateManifest(manifest);
+    if (!validation.valid) {
+      console.error("Manifest validation failed.");
+      console.error(validation.errors);
+      return 1;
+    }
+    const result = await publishPackage({
+      zipPath: appPath,
+      signaturePath,
+      registryPath,
+      manifest
+    });
+    console.log(`Published ${result.appId}@${result.version}`);
+    console.log(`Registry entry: ${result.indexPath}`);
+    return 0;
+  }
+  if (command === "registry-verify") {
+    const registry = getFlag("--registry", "-r");
+    const jsonOut = args.includes("--json");
+    const requireSignature = args.includes("--require-signature");
+    if (!registry) {
+      console.error(
+        "Usage: agentconnect registry-verify --registry <path> [--require-signature] [--json]"
+      );
+      return 1;
+    }
+    const registryPath = resolveAppPath(registry);
+    const result = await validateRegistry({ registryPath, requireSignature });
+    if (jsonOut) {
+      console.log(JSON.stringify(result, null, 2));
+      return result.valid ? 0 : 1;
+    }
+    if (result.valid) {
+      console.log("Registry valid.");
+      if (result.warnings.length) {
+        console.log("Warnings:");
+        for (const warning of result.warnings) {
+          console.log(`- ${warning.message}`);
+        }
+      }
+      return 0;
+    }
+    console.error("Registry validation failed.");
+    for (const error of result.errors) {
+      console.error(`- ${error.message}`);
+    }
+    if (result.warnings.length) {
+      console.error("Warnings:");
+      for (const warning of result.warnings) {
+        console.error(`- ${warning.message}`);
+      }
+    }
+    return 1;
+  }
+  console.error(`Unknown command: ${command}`);
+  console.log(helpText);
+  return 1;
+}
+main().then((code) => {
+  if (typeof code === "number") {
+    process.exitCode = code;
+  }
+}).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});