@agentconnect/cli 0.1.6 → 0.2.0

package/dist/index.js

@@ -1,4146 +1,38 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path13 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 spawn5 } from "child_process";
-import fs2 from "fs";
-import { promises as fsp } from "fs";
-import net from "net";
-import path6 from "path";
-
-// src/providers/claude.ts
-import { spawn as spawn2 } from "child_process";
-import { access, mkdir, readFile, rm, writeFile } from "fs/promises";
-import https from "https";
-import os2 from "os";
-import path2 from "path";
-
-// src/providers/utils.ts
-import { spawn } from "child_process";
-import { existsSync, realpathSync } 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 resolveCommandRealPath(command2) {
-  const resolved = resolveCommandPath(command2);
-  if (!resolved) return null;
-  try {
-    return realpathSync(resolved);
-  } catch {
-    return resolved;
-  }
-}
-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 startedAt = Date.now();
-    debugLog("Command", "run", {
-      command: resolved,
-      args: args2,
-      startedAt: new Date(startedAt).toISOString()
-    });
-    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);
-      debugLog("Command", "result", {
-        command: resolved,
-        code: -1,
-        durationMs: Date.now() - startedAt,
-        error: err.message
-      });
-      resolve({ code: -1, stdout, stderr: `${stderr}${err.message}` });
-    });
-    child.on("close", (code) => {
-      if (timeout) clearTimeout(timeout);
-      debugLog("Command", "result", {
-        command: resolved,
-        code: code ?? 0,
-        durationMs: Date.now() - startedAt
-      });
-      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 CLAUDE_UPDATE_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
-var claudeModelsCache = null;
-var claudeModelsCacheAt = 0;
-var claudeRecentModelsCache = null;
-var claudeRecentModelsCacheAt = 0;
-var claudeUpdateCache = null;
-var claudeUpdatePromise = null;
-var CLAUDE_LOGIN_CACHE_TTL_MS = 3e4;
-var claudeLoginCache = null;
-var claudeLoginPromise = null;
-function trimOutput(value, limit = 400) {
-  const cleaned = value.trim();
-  if (!cleaned) return "";
-  if (cleaned.length <= limit) return cleaned;
-  return `${cleaned.slice(0, limit)}...`;
-}
-function normalizePath(value) {
-  const normalized = value.replace(/\\/g, "/");
-  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
-function parseSemver(value) {
-  if (!value) return null;
-  const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
-  if (!match) return null;
-  return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-function compareSemver(a, b) {
-  if (a[0] !== b[0]) return a[0] - b[0];
-  if (a[1] !== b[1]) return a[1] - b[1];
-  return a[2] - b[2];
-}
-async function fetchLatestNpmVersion(pkg) {
-  const encoded = encodeURIComponent(pkg);
-  const data = await fetchJson(`https://registry.npmjs.org/${encoded}`);
-  if (!data || typeof data !== "object") return null;
-  const latest = data["dist-tags"]?.latest;
-  return typeof latest === "string" ? latest : null;
-}
-async function fetchBrewCaskVersion(cask) {
-  if (!commandExists("brew")) return null;
-  const result = await runCommand("brew", ["info", "--json=v2", "--cask", cask]);
-  if (result.code !== 0) return null;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    const version = parsed?.casks?.[0]?.version;
-    return typeof version === "string" ? version : null;
-  } catch {
-    return null;
-  }
-}
-function getClaudeUpdateAction(commandPath) {
-  if (!commandPath) return null;
-  const normalized = normalizePath(commandPath);
-  const home = normalizePath(os2.homedir());
-  if (normalized.startsWith(`${home}/.bun/bin/`)) {
-    return {
-      command: "bun",
-      args: ["install", "-g", CLAUDE_PACKAGE],
-      source: "bun",
-      commandLabel: "bun install -g @anthropic-ai/claude-code"
-    };
-  }
-  if (normalized.includes("/node_modules/.bin/")) {
-    return {
-      command: "npm",
-      args: ["install", "-g", CLAUDE_PACKAGE],
-      source: "npm",
-      commandLabel: "npm install -g @anthropic-ai/claude-code"
-    };
-  }
-  if (normalized.includes("/cellar/") || normalized.includes("/caskroom/") || normalized.includes("/homebrew/")) {
-    return {
-      command: "brew",
-      args: ["upgrade", "--cask", "claude-code"],
-      source: "brew",
-      commandLabel: "brew upgrade --cask claude-code"
-    };
-  }
-  if (process.platform === "win32" && (normalized.includes("/program files/claudecode") || normalized.includes("/programdata/claudecode"))) {
-    return {
-      command: "winget",
-      args: ["upgrade", "Anthropic.ClaudeCode"],
-      source: "winget",
-      commandLabel: "winget upgrade Anthropic.ClaudeCode"
-    };
-  }
-  if (normalized.includes("/.local/bin/") || normalized.includes("/.local/share/claude/versions/") || normalized.includes("/.local/share/claude-code/versions/")) {
-    if (process.platform === "win32") {
-      return {
-        command: "powershell",
-        args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", INSTALL_WINDOWS_PS],
-        source: "script",
-        commandLabel: INSTALL_WINDOWS_PS
-      };
-    }
-    return {
-      command: "bash",
-      args: ["-lc", INSTALL_UNIX],
-      source: "script",
-      commandLabel: INSTALL_UNIX
-    };
-  }
-  return null;
-}
-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 fetchJson(url) {
-  return new Promise((resolve) => {
-    https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-      res.on("end", () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch {
-          resolve(null);
-        }
-      });
-    }).on("error", () => resolve(null));
-  });
-}
-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 resolveClaudeLoginHint(options) {
-  const raw = process.env.AGENTCONNECT_CLAUDE_LOGIN_HINT;
-  if (raw) {
-    const normalized = String(raw).trim().toLowerCase();
-    if (normalized === "setup") return "setup";
-    if (normalized === "login") return "login";
-  }
-  if (options?.loginExperience) {
-  }
-  const status = await checkClaudeCliStatus();
-  return status.loginHint ?? "login";
-}
-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;
-}
-function isClaudeAuthErrorText(value) {
-  const text = value.toLowerCase();
-  return text.includes("authentication_error") || text.includes("authentication_failed") || text.includes("oauth token has expired") || text.includes("token has expired") || text.includes("please run /login") || text.includes("unauthorized") || text.includes("api error: 401") || text.includes("status 401") || text.includes("invalid api key");
-}
-function extractClaudeMessageText(content) {
-  if (Array.isArray(content)) {
-    return content.map((part) => part?.text ?? "").join(" ");
-  }
-  return typeof content === "string" ? content : "";
-}
-function resolveClaudeLoginHintFromSource(apiKeySource) {
-  if (apiKeySource && apiKeySource.toLowerCase() === "none") return "setup";
-  return "login";
-}
-async function checkClaudeCliStatus() {
-  if (claudeLoginCache && Date.now() - claudeLoginCache.checkedAt < CLAUDE_LOGIN_CACHE_TTL_MS) {
-    return claudeLoginCache.status;
-  }
-  if (claudeLoginPromise) return claudeLoginPromise;
-  claudeLoginPromise = (async () => {
-    const command2 = resolveWindowsCommand(getClaudeCommand());
-    const args2 = [
-      "--print",
-      "--output-format",
-      "stream-json",
-      "--no-session-persistence",
-      "--max-budget-usd",
-      "0.01"
-    ];
-    const result = await runCommand(command2, args2, {
-      env: { ...process.env, CI: "1" },
-      input: "ping\n",
-      timeoutMs: 8e3
-    });
-    const output = `${result.stdout}
-${result.stderr}`.trim();
-    if (!output) return { loggedIn: null };
-    let apiKeySource;
-    let authError = null;
-    let sawAssistant = false;
-    let sawSuccess = false;
-    const lines = output.split("\n");
-    for (const line of lines) {
-      const parsed = safeJsonParse(line);
-      if (!parsed || typeof parsed !== "object") continue;
-      const record = parsed;
-      const type = typeof record.type === "string" ? record.type : "";
-      if (type === "system" && record.subtype === "init") {
-        const source = typeof record.apiKeySource === "string" ? record.apiKeySource : void 0;
-        if (source) apiKeySource = source;
-      }
-      if (type === "result") {
-        const isError = Boolean(record.is_error);
-        const resultText = typeof record.result === "string" ? record.result : typeof record.error === "string" ? record.error : JSON.stringify(record.error || record);
-        if (isError && isClaudeAuthErrorText(resultText)) {
-          authError = authError ?? resultText;
-        }
-        if (!isError) sawSuccess = true;
-      }
-      if (type === "message") {
-        const message = record.message;
-        const role = typeof message?.role === "string" ? message.role : "";
-        if (role === "assistant") {
-          const text = extractClaudeMessageText(message?.content);
-          const errorText = typeof record.error === "string" ? record.error : typeof message?.error === "string" ? message.error : "";
-          if (isClaudeAuthErrorText(text) || errorText && isClaudeAuthErrorText(errorText)) {
-            authError = authError ?? (text || errorText);
-          } else if (text.trim()) {
-            sawAssistant = true;
-          }
-        }
-      }
-    }
-    if (authError) {
-      return {
-        loggedIn: false,
-        apiKeySource,
-        loginHint: resolveClaudeLoginHintFromSource(apiKeySource),
-        authError
-      };
-    }
-    if (sawAssistant || sawSuccess) {
-      return { loggedIn: true, apiKeySource };
-    }
-    if (apiKeySource && apiKeySource.toLowerCase() === "none") {
-      return { loggedIn: false, apiKeySource, loginHint: "setup" };
-    }
-    return { loggedIn: null, apiKeySource };
-  })().then((status) => {
-    claudeLoginCache = { checkedAt: Date.now(), status };
-    return status;
-  }).finally(() => {
-    claudeLoginPromise = null;
-  });
-  return claudeLoginPromise;
-}
-function getClaudeUpdateSnapshot(commandPath) {
-  if (claudeUpdateCache && Date.now() - claudeUpdateCache.checkedAt < CLAUDE_UPDATE_CACHE_TTL_MS) {
-    const action = getClaudeUpdateAction(commandPath);
-    return {
-      updateAvailable: claudeUpdateCache.updateAvailable,
-      latestVersion: claudeUpdateCache.latestVersion,
-      updateCheckedAt: claudeUpdateCache.checkedAt,
-      updateSource: action?.source ?? "unknown",
-      updateCommand: action?.commandLabel,
-      updateMessage: claudeUpdateCache.updateMessage
-    };
-  }
-  return {};
-}
-function ensureClaudeUpdateCheck(currentVersion, commandPath) {
-  if (claudeUpdateCache && Date.now() - claudeUpdateCache.checkedAt < CLAUDE_UPDATE_CACHE_TTL_MS) {
-    return;
-  }
-  if (claudeUpdatePromise) return;
-  claudeUpdatePromise = (async () => {
-    const action = getClaudeUpdateAction(commandPath || null);
-    let latest = null;
-    let updateAvailable;
-    let updateMessage;
-    if (action?.source === "npm" || action?.source === "bun") {
-      latest = await fetchLatestNpmVersion(CLAUDE_PACKAGE);
-    } else if (action?.source === "brew") {
-      latest = await fetchBrewCaskVersion("claude-code");
-    }
-    if (latest && currentVersion) {
-      const a = parseSemver(currentVersion);
-      const b = parseSemver(latest);
-      if (a && b) {
-        updateAvailable = compareSemver(a, b) < 0;
-        updateMessage = updateAvailable ? `Update available: ${currentVersion} -> ${latest}` : `Up to date (${currentVersion})`;
-      }
-    } else if (!action) {
-      updateMessage = "Update check unavailable";
-    }
-    debugLog("Claude", "update-check", {
-      updateAvailable,
-      message: updateMessage
-    });
-    claudeUpdateCache = {
-      checkedAt: Date.now(),
-      updateAvailable,
-      latestVersion: latest ?? void 0,
-      updateMessage
-    };
-  })().finally(() => {
-    claudeUpdatePromise = 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 cliStatus = await checkClaudeCliStatus();
-      if (cliStatus.loggedIn === false) {
-        loggedIn = false;
-      } else if (cliStatus.loggedIn === true) {
-        loggedIn = true;
-      } else if (cliStatus.apiKeySource?.toLowerCase() === "none") {
-        loggedIn = false;
-      } else {
-        loggedIn = await hasClaudeAuth();
-      }
-    }
-  }
-  if (installed) {
-    const resolved2 = resolveCommandRealPath(command2);
-    ensureClaudeUpdateCheck(versionCheck.version, resolved2 || null);
-  }
-  const resolved = resolveCommandRealPath(command2);
-  const updateInfo = installed ? getClaudeUpdateSnapshot(resolved || null) : {};
-  return { installed, loggedIn, version: versionCheck.version || void 0, ...updateInfo };
-}
-async function getClaudeFastStatus() {
-  const command2 = getClaudeCommand();
-  const installed = commandExists(command2);
-  const loggedIn = installed ? await hasClaudeAuth() : false;
-  return { installed, loggedIn };
-}
-async function updateClaude() {
-  const command2 = getClaudeCommand();
-  if (!commandExists(command2)) {
-    return { installed: false, loggedIn: false };
-  }
-  const resolved = resolveCommandRealPath(command2);
-  const updateOverride = buildStatusCommand("AGENTCONNECT_CLAUDE_UPDATE", "");
-  const action = updateOverride.command ? null : getClaudeUpdateAction(resolved || null);
-  const updateCommand = updateOverride.command || action?.command || "";
-  const updateArgs = updateOverride.command ? updateOverride.args : action?.args || [];
-  if (!updateCommand) {
-    throw new Error("No update command available. Please update Claude manually.");
-  }
-  const cmd = resolveWindowsCommand(updateCommand);
-  debugLog("Claude", "update-run", { command: cmd, args: updateArgs });
-  const result = await runCommand(cmd, updateArgs, { env: { ...process.env, CI: "1" } });
-  debugLog("Claude", "update-result", {
-    code: result.code,
-    stdout: trimOutput(result.stdout),
-    stderr: trimOutput(result.stderr)
-  });
-  if (result.code !== 0 && result.code !== null) {
-    const message = trimOutput(`${result.stdout}
-${result.stderr}`, 800) || "Update failed";
-    throw new Error(message);
-  }
-  claudeUpdateCache = null;
-  claudeUpdatePromise = null;
-  return getClaudeStatus();
-}
-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);
-  const loginHint = await resolveClaudeLoginHint(options);
-  await ensureClaudeOnboardingSettings();
-  const settingsPath = await createClaudeLoginSettingsFile(loginMethod);
-  const loginTimeoutMs = Number(process.env.AGENTCONNECT_CLAUDE_LOGIN_TIMEOUT_MS || 18e4);
-  const loginArgs = settingsPath ? ["--settings", settingsPath] : [];
-  const includeLogin = loginHint === "login";
-  let ptyProcess = null;
-  let childExited = false;
-  const cleanup = async () => {
-    if (ptyProcess) {
-      try {
-        ptyProcess.kill();
-      } catch {
-      }
-    }
-    if (settingsPath && loginExperience !== "terminal") {
-      try {
-        await rm(settingsPath, { force: true });
-      } catch {
-      }
-    }
-  };
-  try {
-    if (loginExperience === "terminal") {
-      await openClaudeLoginTerminal(command2, loginArgs, includeLogin);
-      if (settingsPath) {
-        setTimeout(() => {
-          rm(settingsPath, { force: true }).catch(() => {
-          });
-        }, loginTimeoutMs);
-      }
-    } else {
-      const ptyModule = await loadPtyModule();
-      if (!ptyModule) {
-        throw new Error(
-          "Claude login requires node-pty. Reinstall AgentConnect or run `claude /login` manually."
-        );
-      }
-      const spawnArgs = includeLogin ? [...loginArgs, "/login"] : loginArgs;
-      ptyProcess = ptyModule.spawn(command2, spawnArgs, {
-        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 extractTextFromContent(content) {
-  if (!content) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (!part || typeof part !== "object") return "";
-      const text = part.text;
-      if (typeof text === "string") return text;
-      return "";
-    }).filter(Boolean).join("");
-  }
-  return "";
-}
-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,
-  providerDetailLevel,
-  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 toolBlocks = /* @__PURE__ */ new Map();
-    const thinkingBlocks = /* @__PURE__ */ new Set();
-    const includeRaw = providerDetailLevel === "raw";
-    const buildProviderDetail = (eventType, data, raw) => {
-      const detail = { eventType };
-      if (data && Object.keys(data).length) detail.data = data;
-      if (includeRaw && raw !== void 0) detail.raw = raw;
-      return detail;
-    };
-    const emit = (event) => {
-      if (finalSessionId) {
-        onEvent({ ...event, providerSessionId: finalSessionId });
-      } else {
-        onEvent(event);
-      }
-    };
-    const emitError = (message) => {
-      if (sawError) return;
-      sawError = true;
-      emit({ type: "error", message });
-    };
-    const emitFinal = (text, providerDetail) => {
-      emit({ type: "final", text, providerDetail });
-    };
-    const handleLine = (line) => {
-      const parsed = safeJsonParse(line);
-      if (!parsed || typeof parsed !== "object") {
-        if (line.trim()) {
-          emit({ type: "raw_line", line });
-        }
-        return;
-      }
-      const msg = parsed;
-      const sid = extractSessionId(msg);
-      if (sid) finalSessionId = sid;
-      const msgType = String(msg.type ?? "");
-      let handled = false;
-      if (msgType === "assistant" || msgType === "user" || msgType === "system") {
-        const role = msg.message?.role === "assistant" || msg.message?.role === "user" || msg.message?.role === "system" ? msg.message.role : msgType;
-        const rawContent = msg.message?.content;
-        const content = extractTextFromContent(rawContent);
-        emit({
-          type: "message",
-          provider: "claude",
-          role,
-          content,
-          contentParts: rawContent ?? null,
-          providerDetail: buildProviderDetail(msgType, {}, msg)
-        });
-        handled = true;
-      }
-      if (msgType === "stream_event" && msg.event) {
-        const evType = String(msg.event.type ?? "");
-        const index = typeof msg.event.index === "number" ? msg.event.index : void 0;
-        const block = msg.event.content_block;
-        if (evType === "content_block_start" && block && typeof index === "number") {
-          if (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use") {
-            toolBlocks.set(index, { id: block.id, name: block.name });
-            emit({
-              type: "tool_call",
-              provider: "claude",
-              name: block.name,
-              callId: block.id,
-              input: block.input,
-              phase: "start",
-              providerDetail: buildProviderDetail(
-                "content_block_start",
-                { blockType: block.type, index, name: block.name, id: block.id },
-                msg
-              )
-            });
-          }
-          if (block.type === "thinking" || block.type === "redacted_thinking") {
-            thinkingBlocks.add(index);
-            emit({
-              type: "thinking",
-              provider: "claude",
-              phase: "start",
-              text: typeof block.thinking === "string" ? block.thinking : void 0,
-              providerDetail: buildProviderDetail(
-                "content_block_start",
-                { blockType: block.type, index },
-                msg
-              )
-            });
-          }
-          handled = true;
-        }
-        if (evType === "content_block_delta") {
-          const delta2 = msg.event.delta ?? {};
-          if (delta2.type === "thinking_delta") {
-            emit({
-              type: "thinking",
-              provider: "claude",
-              phase: "delta",
-              text: typeof delta2.thinking === "string" ? delta2.thinking : void 0,
-              providerDetail: buildProviderDetail(
-                "content_block_delta",
-                { deltaType: delta2.type, index },
-                msg
-              )
-            });
-            handled = true;
-          }
-          if (delta2.type === "input_json_delta") {
-            const tool = typeof index === "number" ? toolBlocks.get(index) : void 0;
-            emit({
-              type: "tool_call",
-              provider: "claude",
-              name: tool?.name,
-              callId: tool?.id,
-              input: delta2.partial_json,
-              phase: "delta",
-              providerDetail: buildProviderDetail(
-                "content_block_delta",
-                { deltaType: delta2.type, index, name: tool?.name, id: tool?.id },
-                msg
-              )
-            });
-            handled = true;
-          }
-        }
-        if (evType === "content_block_stop" && typeof index === "number") {
-          if (toolBlocks.has(index)) {
-            const tool = toolBlocks.get(index);
-            emit({
-              type: "tool_call",
-              provider: "claude",
-              name: tool?.name,
-              callId: tool?.id,
-              phase: "completed",
-              providerDetail: buildProviderDetail(
-                "content_block_stop",
-                { index, name: tool?.name, id: tool?.id },
-                msg
-              )
-            });
-            toolBlocks.delete(index);
-          }
-          if (thinkingBlocks.has(index)) {
-            emit({
-              type: "thinking",
-              provider: "claude",
-              phase: "completed",
-              providerDetail: buildProviderDetail("content_block_stop", { index }, msg)
-            });
-            thinkingBlocks.delete(index);
-          }
-          handled = true;
-        }
-      }
-      const delta = extractAssistantDelta(msg);
-      if (delta) {
-        aggregated += delta;
-        emit({
-          type: "delta",
-          text: delta,
-          providerDetail: buildProviderDetail(msgType || "delta", {}, msg)
-        });
-        return;
-      }
-      const assistant = extractAssistantText(msg);
-      if (assistant && !aggregated) {
-        aggregated = assistant;
-        emit({
-          type: "delta",
-          text: assistant,
-          providerDetail: buildProviderDetail(msgType || "assistant", {}, msg)
-        });
-        return;
-      }
-      const result = extractResultText(msg);
-      if (result && !didFinalize && !sawError) {
-        didFinalize = true;
-        emitFinal(aggregated || result, buildProviderDetail("result", {}, msg));
-        handled = true;
-      }
-      if (!handled) {
-        emit({
-          type: "detail",
-          provider: "claude",
-          providerDetail: buildProviderDetail(msgType || "unknown", {}, msg)
-        });
-      }
-    };
-    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 { readFile as readFile2 } from "fs/promises";
-import https2 from "https";
-import os3 from "os";
-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 CODEX_UPDATE_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
-var codexModelsCache = null;
-var codexModelsCacheAt = 0;
-var codexUpdateCache = null;
-var codexUpdatePromise = null;
-function trimOutput2(value, limit = 400) {
-  const cleaned = value.trim();
-  if (!cleaned) return "";
-  if (cleaned.length <= limit) return cleaned;
-  return `${cleaned.slice(0, limit)}...`;
-}
-function normalizePath2(value) {
-  const normalized = value.replace(/\\/g, "/");
-  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
-function getCodexConfigDir() {
-  return process.env.CODEX_CONFIG_DIR || path3.join(os3.homedir(), ".codex");
-}
-function fetchJson2(url) {
-  return new Promise((resolve) => {
-    https2.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-      res.on("end", () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch {
-          resolve(null);
-        }
-      });
-    }).on("error", () => resolve(null));
-  });
-}
-function parseSemver2(value) {
-  if (!value) return null;
-  const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
-  if (!match) return null;
-  return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-function compareSemver2(a, b) {
-  if (a[0] !== b[0]) return a[0] - b[0];
-  if (a[1] !== b[1]) return a[1] - b[1];
-  return a[2] - b[2];
-}
-async function fetchLatestNpmVersion2(pkg) {
-  const encoded = encodeURIComponent(pkg);
-  const data = await fetchJson2(`https://registry.npmjs.org/${encoded}`);
-  if (!data || typeof data !== "object") return null;
-  const latest = data["dist-tags"]?.latest;
-  return typeof latest === "string" ? latest : null;
-}
-async function fetchBrewFormulaVersion(formula) {
-  if (!commandExists("brew")) return null;
-  const result = await runCommand("brew", ["info", "--json=v2", formula]);
-  if (result.code !== 0) return null;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    const version = parsed?.formulae?.[0]?.versions?.stable;
-    return typeof version === "string" ? version : null;
-  } catch {
-    return null;
-  }
-}
-function getCodexUpdateAction(commandPath) {
-  if (process.env.CODEX_MANAGED_BY_NPM) {
-    return {
-      command: "npm",
-      args: ["install", "-g", CODEX_PACKAGE],
-      source: "npm",
-      commandLabel: "npm install -g @openai/codex"
-    };
-  }
-  if (process.env.CODEX_MANAGED_BY_BUN) {
-    return {
-      command: "bun",
-      args: ["install", "-g", CODEX_PACKAGE],
-      source: "bun",
-      commandLabel: "bun install -g @openai/codex"
-    };
-  }
-  if (commandPath) {
-    const normalized = normalizePath2(commandPath);
-    if (normalized.includes(".bun/install/global")) {
-      return {
-        command: "bun",
-        args: ["install", "-g", CODEX_PACKAGE],
-        source: "bun",
-        commandLabel: "bun install -g @openai/codex"
-      };
-    }
-    if (normalized.includes("/node_modules/.bin/") || normalized.includes("/lib/node_modules/")) {
-      return {
-        command: "npm",
-        args: ["install", "-g", CODEX_PACKAGE],
-        source: "npm",
-        commandLabel: "npm install -g @openai/codex"
-      };
-    }
-  }
-  if (process.platform === "darwin" && commandPath && (commandPath.startsWith("/opt/homebrew") || commandPath.startsWith("/usr/local"))) {
-    return {
-      command: "brew",
-      args: ["upgrade", "codex"],
-      source: "brew",
-      commandLabel: "brew upgrade codex"
-    };
-  }
-  return null;
-}
-function getCodexUpdateSnapshot(commandPath) {
-  if (codexUpdateCache && Date.now() - codexUpdateCache.checkedAt < CODEX_UPDATE_CACHE_TTL_MS) {
-    const action = getCodexUpdateAction(commandPath);
-    return {
-      updateAvailable: codexUpdateCache.updateAvailable,
-      latestVersion: codexUpdateCache.latestVersion,
-      updateCheckedAt: codexUpdateCache.checkedAt,
-      updateSource: action?.source ?? "unknown",
-      updateCommand: action?.commandLabel,
-      updateMessage: codexUpdateCache.updateMessage
-    };
-  }
-  return {};
-}
-function ensureCodexUpdateCheck(currentVersion, commandPath) {
-  if (codexUpdateCache && Date.now() - codexUpdateCache.checkedAt < CODEX_UPDATE_CACHE_TTL_MS) {
-    return;
-  }
-  if (codexUpdatePromise) return;
-  codexUpdatePromise = (async () => {
-    const action = getCodexUpdateAction(commandPath || null);
-    let latest = null;
-    if (action?.source === "brew") {
-      latest = await fetchBrewFormulaVersion("codex");
-    } else {
-      latest = await fetchLatestNpmVersion2(CODEX_PACKAGE);
-    }
-    let updateAvailable;
-    let updateMessage;
-    if (latest && currentVersion) {
-      const a = parseSemver2(currentVersion);
-      const b = parseSemver2(latest);
-      if (a && b) {
-        updateAvailable = compareSemver2(a, b) < 0;
-        updateMessage = updateAvailable ? `Update available: ${currentVersion} -> ${latest}` : `Up to date (${currentVersion})`;
-      }
-    }
-    codexUpdateCache = {
-      checkedAt: Date.now(),
-      updateAvailable,
-      latestVersion: latest ?? void 0,
-      updateMessage
-    };
-    debugLog("Codex", "update-check", {
-      currentVersion,
-      latest,
-      updateAvailable,
-      message: updateMessage
-    });
-  })().finally(() => {
-    codexUpdatePromise = null;
-  });
-}
-function hasAuthValue(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-async function hasCodexAuth() {
-  const home = os3.homedir();
-  const candidates = [
-    path3.join(getCodexConfigDir(), "auth.json"),
-    path3.join(home, ".config", "codex", "auth.json")
-  ];
-  for (const filePath of candidates) {
-    try {
-      const raw = await readFile2(filePath, "utf8");
-      const parsed = JSON.parse(raw);
-      if (hasAuthValue(parsed.OPENAI_API_KEY)) return true;
-      if (hasAuthValue(parsed.access_token)) return true;
-      if (hasAuthValue(parsed.token)) return true;
-      const tokens = parsed.tokens;
-      if (tokens) {
-        if (hasAuthValue(tokens.access_token)) return true;
-        if (hasAuthValue(tokens.refresh_token)) return true;
-        if (hasAuthValue(tokens.id_token)) return true;
-      }
-    } catch {
-    }
-  }
-  return false;
-}
-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: trimOutput2(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;
-  let explicitLoggedOut = 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, { env: { ...process.env, CI: "1" } });
-      const output = `${result.stdout}
-${result.stderr}`.toLowerCase();
-      if (output.includes("not logged in") || output.includes("not logged") || output.includes("login required") || output.includes("please login") || output.includes("run codex login")) {
-        explicitLoggedOut = true;
-        loggedIn = false;
-      } else if (output.includes("logged in") || output.includes("signed in") || output.includes("authenticated")) {
-        loggedIn = true;
-      } else {
-        loggedIn = result.code === 0;
-      }
-    }
-    if (!loggedIn && !explicitLoggedOut) {
-      loggedIn = await hasCodexAuth();
-    }
-  }
-  const resolved = resolveCommandRealPath(command2);
-  if (installed) {
-    ensureCodexUpdateCheck(versionCheck.version, resolved || null);
-  }
-  const updateInfo = installed ? getCodexUpdateSnapshot(resolved || null) : {};
-  return { installed, loggedIn, version: versionCheck.version || void 0, ...updateInfo };
-}
-async function getCodexFastStatus() {
-  const command2 = getCodexCommand();
-  const loggedIn = await hasCodexAuth();
-  const installed = commandExists(command2) || loggedIn;
-  return { installed, loggedIn };
-}
-async function updateCodex() {
-  const command2 = getCodexCommand();
-  if (!commandExists(command2)) {
-    return { installed: false, loggedIn: false };
-  }
-  const resolved = resolveCommandRealPath(command2);
-  const updateOverride = buildStatusCommand("AGENTCONNECT_CODEX_UPDATE", "");
-  const action = updateOverride.command ? null : getCodexUpdateAction(resolved || null);
-  const updateCommand = updateOverride.command || action?.command || "";
-  const updateArgs = updateOverride.command ? updateOverride.args : action?.args || [];
-  if (!updateCommand) {
-    throw new Error("No update command available. Please update Codex manually.");
-  }
-  const cmd = resolveWindowsCommand(updateCommand);
-  debugLog("Codex", "update-run", { command: cmd, args: updateArgs });
-  const result = await runCommand(cmd, updateArgs, {
-    env: { ...process.env, CI: "1" }
-  });
-  debugLog("Codex", "update-result", {
-    code: result.code,
-    stdout: trimOutput2(result.stdout),
-    stderr: trimOutput2(result.stderr)
-  });
-  if (result.code !== 0 && result.code !== null) {
-    const message = trimOutput2(`${result.stdout}
-${result.stderr}`, 800) || "Update failed";
-    throw new Error(message);
-  }
-  codexUpdateCache = null;
-  codexUpdatePromise = null;
-  return getCodexStatus();
-}
-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: trimOutput2(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,
-  providerDetailLevel,
-  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 includeRaw = providerDetailLevel === "raw";
-      const buildProviderDetail = (eventType, data, raw) => {
-        const detail = { eventType };
-        if (data && Object.keys(data).length) detail.data = data;
-        if (includeRaw && raw !== void 0) detail.raw = raw;
-        return detail;
-      };
-      const emit = (event) => {
-        if (finalSessionId) {
-          onEvent({ ...event, providerSessionId: finalSessionId });
-        } else {
-          onEvent(event);
-        }
-      };
-      const emitError = (message, providerDetail) => {
-        if (sawError) return;
-        sawError = true;
-        emit({ type: "error", message, providerDetail });
-      };
-      const emitItemEvent = (item, phase) => {
-        const itemType = typeof item.type === "string" ? item.type : "";
-        if (!itemType) return;
-        const providerDetail = buildProviderDetail(
-          phase === "start" ? "item.started" : "item.completed",
-          {
-            itemType,
-            itemId: item.id,
-            status: item.status
-          },
-          item
-        );
-        if (itemType === "agent_message") {
-          if (phase === "completed" && typeof item.text === "string") {
-            emit({
-              type: "message",
-              provider: "codex",
-              role: "assistant",
-              content: item.text,
-              contentParts: item,
-              providerDetail
-            });
-          }
-          return;
-        }
-        if (itemType === "reasoning") {
-          emit({
-            type: "thinking",
-            provider: "codex",
-            phase,
-            text: typeof item.text === "string" ? item.text : void 0,
-            providerDetail
-          });
-          return;
-        }
-        if (itemType === "command_execution") {
-          const output = phase === "completed" ? {
-            output: item.aggregated_output,
-            exitCode: item.exit_code,
-            status: item.status
-          } : void 0;
-          emit({
-            type: "tool_call",
-            provider: "codex",
-            name: "command_execution",
-            callId: item.id,
-            input: { command: item.command },
-            output,
-            phase,
-            providerDetail
-          });
-          return;
-        }
-        emit({
-          type: "tool_call",
-          provider: "codex",
-          name: itemType,
-          callId: item.id,
-          input: phase === "start" ? item : void 0,
-          output: phase === "completed" ? item : void 0,
-          phase,
-          providerDetail
-        });
-      };
-      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, providerDetail) => {
-        emit({ type: "final", text, providerDetail });
-      };
-      const handleLine = (line, source) => {
-        const parsed = safeJsonParse2(line);
-        if (!parsed || typeof parsed !== "object") {
-          if (line.trim()) {
-            emit({ type: "raw_line", line });
-          }
-          if (source === "stdout") {
-            pushLine(stdoutLines, line);
-          } else {
-            pushLine(stderrLines, line);
-          }
-          return;
-        }
-        sawJson = true;
-        const ev = parsed;
-        const normalized = normalizeEvent(ev);
-        const sid = extractSessionId2(ev);
-        if (sid) finalSessionId = sid;
-        const eventType = typeof ev.type === "string" ? ev.type : normalized.type;
-        const detailData = {};
-        const threadId = ev.thread_id ?? ev.threadId;
-        if (typeof threadId === "string" && threadId) detailData.threadId = threadId;
-        const providerDetail = buildProviderDetail(eventType || "unknown", detailData, ev);
-        let handled = false;
-        const usage = extractUsage(ev);
-        if (usage) {
-          emit({
-            type: "usage",
-            inputTokens: usage.input_tokens,
-            outputTokens: usage.output_tokens,
-            providerDetail
-          });
-          handled = true;
-        }
-        if (normalized.type === "agent_message") {
-          const text = normalized.text;
-          if (typeof text === "string" && text) {
-            aggregated += text;
-            emit({ type: "delta", text, providerDetail });
-            emit({
-              type: "message",
-              provider: "codex",
-              role: "assistant",
-              content: text,
-              contentParts: ev,
-              providerDetail
-            });
-            handled = true;
-          }
-        } else if (normalized.type === "item.completed") {
-          const item = normalized.item;
-          if (item && typeof item === "object") {
-            const itemDetail = buildProviderDetail("item.completed", {
-              itemType: item.type,
-              itemId: item.id,
-              status: item.status
-            }, item);
-            if (item.type === "command_execution" && typeof item.aggregated_output === "string") {
-              emit({ type: "delta", text: item.aggregated_output, providerDetail: itemDetail });
-            }
-            if (item.type === "agent_message" && typeof item.text === "string") {
-              aggregated += item.text;
-              emit({ type: "delta", text: item.text, providerDetail: itemDetail });
-            }
-          }
-        }
-        if (normalized.type === "item.started" && ev.item && typeof ev.item === "object") {
-          emitItemEvent(ev.item, "start");
-          handled = true;
-        }
-        if (normalized.type === "item.completed" && ev.item && typeof ev.item === "object") {
-          emitItemEvent(ev.item, "completed");
-          handled = true;
-        }
-        if (normalized.type === "error") {
-          emitError(normalized.message || "Codex run failed", providerDetail);
-          handled = true;
-        }
-        if (isTerminalEvent(ev) && !didFinalize) {
-          if (ev.type === "turn.failed") {
-            const message = ev.error?.message;
-            emitError(typeof message === "string" ? message : "Codex run failed", providerDetail);
-            didFinalize = true;
-            handled = true;
-            return;
-          }
-          if (!sawError) {
-            didFinalize = true;
-            emitFinal(aggregated, providerDetail);
-            handled = true;
-          }
-        }
-        if (!handled) {
-          emit({ type: "detail", provider: "codex", providerDetail });
-        }
-      };
-      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/cursor.ts
-import { spawn as spawn4 } from "child_process";
-import path4 from "path";
-var INSTALL_UNIX2 = "curl https://cursor.com/install -fsS | bash";
-var DEFAULT_LOGIN3 = "cursor-agent login";
-var DEFAULT_STATUS3 = "cursor-agent status";
-var CURSOR_MODELS_COMMAND = "cursor-agent models";
-var CURSOR_MODELS_CACHE_TTL_MS = 6e4;
-var CURSOR_UPDATE_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
-var cursorModelsCache = null;
-var cursorModelsCacheAt = 0;
-var cursorUpdateCache = null;
-var cursorUpdatePromise = null;
-function trimOutput3(value, limit = 400) {
-  const cleaned = value.trim();
-  if (!cleaned) return "";
-  if (cleaned.length <= limit) return cleaned;
-  return `${cleaned.slice(0, limit)}...`;
-}
-function normalizePath3(value) {
-  const normalized = value.replace(/\\/g, "/");
-  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
-function parseSemver3(value) {
-  if (!value) return null;
-  const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
-  if (!match) return null;
-  return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-function compareSemver3(a, b) {
-  if (a[0] !== b[0]) return a[0] - b[0];
-  if (a[1] !== b[1]) return a[1] - b[1];
-  return a[2] - b[2];
-}
-async function fetchBrewCaskVersion2(cask) {
-  if (!commandExists("brew")) return null;
-  const result = await runCommand("brew", ["info", "--json=v2", "--cask", cask]);
-  if (result.code !== 0) return null;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    const version = parsed?.casks?.[0]?.version;
-    return typeof version === "string" ? version : null;
-  } catch {
-    return null;
-  }
-}
-function getCursorUpdateAction(commandPath) {
-  if (!commandPath) return null;
-  const normalized = normalizePath3(commandPath);
-  if (normalized.includes("/cellar/") || normalized.includes("/caskroom/") || normalized.includes("/homebrew/")) {
-    return {
-      command: "brew",
-      args: ["upgrade", "--cask", "cursor"],
-      source: "brew",
-      commandLabel: "brew upgrade --cask cursor"
-    };
-  }
-  if (normalized.includes("/.local/bin/") || normalized.includes("/.local/share/cursor-agent/versions/")) {
-    return {
-      command: "bash",
-      args: ["-lc", INSTALL_UNIX2],
-      source: "script",
-      commandLabel: INSTALL_UNIX2
-    };
-  }
-  return null;
-}
-function getCursorCommand() {
-  const override = process.env.AGENTCONNECT_CURSOR_COMMAND;
-  const base = override || "cursor-agent";
-  const resolved = resolveCommandPath(base);
-  return resolved || resolveWindowsCommand(base);
-}
-function getCursorApiKey() {
-  return process.env.CURSOR_API_KEY || process.env.AGENTCONNECT_CURSOR_API_KEY || "";
-}
-function getCursorDefaultModel() {
-  return process.env.AGENTCONNECT_CURSOR_MODEL?.trim() || "";
-}
-function resolveCursorEndpoint() {
-  return process.env.AGENTCONNECT_CURSOR_ENDPOINT?.trim() || "";
-}
-function withCursorEndpoint(args2) {
-  const endpoint = resolveCursorEndpoint();
-  if (!endpoint) return args2;
-  if (args2.includes("--endpoint")) return args2;
-  return [...args2, "--endpoint", endpoint];
-}
-function resolveCursorModel(model, fallback) {
-  if (!model) return fallback;
-  const raw = String(model);
-  if (raw === "cursor" || raw === "cursor-default") return fallback;
-  if (raw.startsWith("cursor:")) return raw.slice("cursor:".length);
-  if (raw.startsWith("cursor/")) return raw.slice("cursor/".length);
-  return raw;
-}
-function formatCursorDefaultLabel(fallback) {
-  if (!fallback) return "Default";
-  return `Default \xB7 ${fallback}`;
-}
-function normalizeCursorModelId(value) {
-  if (value.startsWith("cursor:") || value.startsWith("cursor/")) return value;
-  return `cursor:${value}`;
-}
-function normalizeCursorModelDisplay(value) {
-  if (value.startsWith("cursor:")) return value.slice("cursor:".length);
-  if (value.startsWith("cursor/")) return value.slice("cursor/".length);
-  return value;
-}
-async function listCursorModelsFromCli() {
-  const command2 = getCursorCommand();
-  if (!commandExists(command2)) return [];
-  const modelsCommand = buildStatusCommand(
-    "AGENTCONNECT_CURSOR_MODELS_COMMAND",
-    CURSOR_MODELS_COMMAND
-  );
-  if (!modelsCommand.command) return [];
-  const resolvedCommand = resolveWindowsCommand(modelsCommand.command);
-  const result = await runCommand(resolvedCommand, withCursorEndpoint(modelsCommand.args), {
-    env: buildCursorEnv()
-  });
-  const output = `${result.stdout}
-${result.stderr}`.trim();
-  if (!output) return [];
-  const parsed = safeJsonParse3(output);
-  if (Array.isArray(parsed)) {
-    const models = parsed.map((entry) => {
-      if (typeof entry === "string" && entry.trim()) {
-        const value = entry.trim();
-        return {
-          id: normalizeCursorModelId(value),
-          provider: "cursor",
-          displayName: normalizeCursorModelDisplay(value)
-        };
-      }
-      if (entry && typeof entry === "object") {
-        const record = entry;
-        const idRaw = typeof record.id === "string" ? record.id.trim() : "";
-        const nameRaw = typeof record.name === "string" ? record.name.trim() : "";
-        const displayRaw = typeof record.displayName === "string" ? record.displayName.trim() : "";
-        const value = idRaw || nameRaw || displayRaw;
-        if (!value) return null;
-        return {
-          id: normalizeCursorModelId(value),
-          provider: "cursor",
-          displayName: normalizeCursorModelDisplay(displayRaw || nameRaw || value)
-        };
-      }
-      return null;
-    }).filter(Boolean);
-    return models;
-  }
-  const lines = output.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => !line.toLowerCase().startsWith("model")).filter((line) => !/^[-=]{2,}$/.test(line));
-  return lines.map((line) => {
-    const cleaned = line.replace(/^[-*•]\s*/, "");
-    const value = cleaned.split(/\s+/)[0] || cleaned;
-    return {
-      id: normalizeCursorModelId(value),
-      provider: "cursor",
-      displayName: normalizeCursorModelDisplay(value)
-    };
-  });
-}
-async function listCursorModels() {
-  if (cursorModelsCache && Date.now() - cursorModelsCacheAt < CURSOR_MODELS_CACHE_TTL_MS) {
-    return cursorModelsCache;
-  }
-  const fallback = getCursorDefaultModel();
-  const base = [
-    {
-      id: "cursor-default",
-      provider: "cursor",
-      displayName: formatCursorDefaultLabel(fallback)
-    }
-  ];
-  const envModels = process.env.AGENTCONNECT_CURSOR_MODELS;
-  if (envModels) {
-    try {
-      const parsed = JSON.parse(envModels);
-      if (Array.isArray(parsed)) {
-        for (const entry of parsed) {
-          if (typeof entry === "string" && entry.trim()) {
-            const trimmed = entry.trim();
-            base.push({
-              id: normalizeCursorModelId(trimmed),
-              provider: "cursor",
-              displayName: normalizeCursorModelDisplay(trimmed)
-            });
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  const cliModels = await listCursorModelsFromCli();
-  base.push(...cliModels);
-  const seen = /* @__PURE__ */ new Set();
-  const list = base.filter((entry) => {
-    const key = `${entry.provider}:${entry.id}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-  cursorModelsCache = list;
-  cursorModelsCacheAt = Date.now();
-  return list;
-}
-function normalizeCursorStatusOutput(output) {
-  const text = output.toLowerCase();
-  if (text.includes("not authenticated") || text.includes("not logged in") || text.includes("login required") || text.includes("please login") || text.includes("please log in") || text.includes("unauthorized")) {
-    return false;
-  }
-  if (text.includes("authenticated") || text.includes("logged in") || text.includes("signed in") || text.includes("account")) {
-    return true;
-  }
-  return null;
-}
-function getCursorUpdateSnapshot(commandPath) {
-  if (cursorUpdateCache && Date.now() - cursorUpdateCache.checkedAt < CURSOR_UPDATE_CACHE_TTL_MS) {
-    const action = getCursorUpdateAction(commandPath);
-    return {
-      updateAvailable: cursorUpdateCache.updateAvailable,
-      latestVersion: cursorUpdateCache.latestVersion,
-      updateCheckedAt: cursorUpdateCache.checkedAt,
-      updateSource: action?.source ?? "unknown",
-      updateCommand: action?.commandLabel,
-      updateMessage: cursorUpdateCache.updateMessage
-    };
-  }
-  return {};
-}
-function ensureCursorUpdateCheck(currentVersion, commandPath) {
-  if (cursorUpdateCache && Date.now() - cursorUpdateCache.checkedAt < CURSOR_UPDATE_CACHE_TTL_MS) {
-    return;
-  }
-  if (cursorUpdatePromise) return;
-  cursorUpdatePromise = (async () => {
-    const action = getCursorUpdateAction(commandPath || null);
-    let latest = null;
-    let updateAvailable;
-    let updateMessage;
-    if (action?.source === "brew") {
-      latest = await fetchBrewCaskVersion2("cursor");
-    }
-    if (latest && currentVersion) {
-      const a = parseSemver3(currentVersion);
-      const b = parseSemver3(latest);
-      if (a && b) {
-        updateAvailable = compareSemver3(a, b) < 0;
-        updateMessage = updateAvailable ? `Update available: ${currentVersion} -> ${latest}` : `Up to date (${currentVersion})`;
-      }
-    } else if (!action) {
-      updateMessage = "Update check unavailable";
-    }
-    debugLog("Cursor", "update-check", {
-      updateAvailable,
-      message: updateMessage
-    });
-    cursorUpdateCache = {
-      checkedAt: Date.now(),
-      updateAvailable,
-      latestVersion: latest ?? void 0,
-      updateMessage
-    };
-  })().finally(() => {
-    cursorUpdatePromise = null;
-  });
-}
-async function ensureCursorInstalled() {
-  const command2 = getCursorCommand();
-  const versionCheck = await checkCommandVersion(command2, [["--version"], ["-V"]]);
-  debugLog("Cursor", "install-check", {
-    command: command2,
-    versionOk: versionCheck.ok,
-    version: versionCheck.version
-  });
-  if (versionCheck.ok) {
-    return { installed: true, version: versionCheck.version || void 0 };
-  }
-  if (commandExists(command2)) {
-    return { installed: true, version: void 0 };
-  }
-  const override = buildInstallCommand("AGENTCONNECT_CURSOR_INSTALL", "");
-  let install = override;
-  let packageManager = override.command ? "unknown" : "unknown";
-  if (!install.command) {
-    if (process.platform !== "win32" && commandExists("bash") && commandExists("curl")) {
-      install = { command: "bash", args: ["-lc", INSTALL_UNIX2] };
-      packageManager = "script";
-    }
-  }
-  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 getCursorStatus() {
-  const command2 = getCursorCommand();
-  const versionCheck = await checkCommandVersion(command2, [["--version"], ["-V"]]);
-  const installed = versionCheck.ok || commandExists(command2);
-  let loggedIn = false;
-  if (installed) {
-    const status = buildStatusCommand("AGENTCONNECT_CURSOR_STATUS", DEFAULT_STATUS3);
-    if (status.command) {
-      const statusCommand = resolveWindowsCommand(status.command);
-      const result = await runCommand(statusCommand, withCursorEndpoint(status.args), {
-        env: buildCursorEnv()
-      });
-      const output = `${result.stdout}
-${result.stderr}`;
-      const parsed = normalizeCursorStatusOutput(output);
-      loggedIn = parsed ?? result.code === 0;
-    }
-    if (!loggedIn) {
-      loggedIn = Boolean(getCursorApiKey().trim());
-    }
-  }
-  if (installed) {
-    const resolved2 = resolveCommandRealPath(command2);
-    ensureCursorUpdateCheck(versionCheck.version, resolved2 || null);
-  }
-  const resolved = resolveCommandRealPath(command2);
-  const updateInfo = installed ? getCursorUpdateSnapshot(resolved || null) : {};
-  return { installed, loggedIn, version: versionCheck.version || void 0, ...updateInfo };
-}
-async function getCursorFastStatus() {
-  const command2 = getCursorCommand();
-  const installed = commandExists(command2);
-  if (!installed) {
-    return { installed: false, loggedIn: false };
-  }
-  return { installed: true, loggedIn: true };
-}
-async function updateCursor() {
-  const command2 = getCursorCommand();
-  if (!commandExists(command2)) {
-    return { installed: false, loggedIn: false };
-  }
-  const resolved = resolveCommandRealPath(command2);
-  const updateOverride = buildStatusCommand("AGENTCONNECT_CURSOR_UPDATE", "");
-  const action = updateOverride.command ? null : getCursorUpdateAction(resolved || null);
-  const updateCommand = updateOverride.command || action?.command || "";
-  const updateArgs = updateOverride.command ? updateOverride.args : action?.args || [];
-  if (!updateCommand) {
-    throw new Error("No update command available. Please update Cursor manually.");
-  }
-  const cmd = resolveWindowsCommand(updateCommand);
-  debugLog("Cursor", "update-run", { command: cmd, args: updateArgs });
-  const result = await runCommand(cmd, updateArgs, { env: buildCursorEnv() });
-  debugLog("Cursor", "update-result", {
-    code: result.code,
-    stdout: trimOutput3(result.stdout),
-    stderr: trimOutput3(result.stderr)
-  });
-  if (result.code !== 0 && result.code !== null) {
-    const message = trimOutput3(`${result.stdout}
-${result.stderr}`, 800) || "Update failed";
-    throw new Error(message);
-  }
-  cursorUpdateCache = null;
-  cursorUpdatePromise = null;
-  return getCursorStatus();
-}
-function buildCursorEnv() {
-  const env = { ...process.env };
-  const apiKey = getCursorApiKey().trim();
-  if (apiKey) {
-    env.CURSOR_API_KEY = apiKey;
-  }
-  return env;
-}
-async function loginCursor(options) {
-  if (typeof options?.apiKey === "string") {
-    process.env.CURSOR_API_KEY = options.apiKey;
-  }
-  if (typeof options?.baseUrl === "string") {
-    process.env.AGENTCONNECT_CURSOR_ENDPOINT = options.baseUrl;
-  }
-  if (typeof options?.model === "string") {
-    process.env.AGENTCONNECT_CURSOR_MODEL = options.model;
-    cursorModelsCache = null;
-    cursorModelsCacheAt = 0;
-  }
-  if (Array.isArray(options?.models)) {
-    process.env.AGENTCONNECT_CURSOR_MODELS = JSON.stringify(options.models.filter(Boolean));
-    cursorModelsCache = null;
-    cursorModelsCacheAt = 0;
-  }
-  if (!options?.apiKey) {
-    const login = buildLoginCommand("AGENTCONNECT_CURSOR_LOGIN", DEFAULT_LOGIN3);
-    if (login.command) {
-      const command2 = resolveWindowsCommand(login.command);
-      await runCommand(command2, withCursorEndpoint(login.args), { env: buildCursorEnv() });
-    }
-  }
-  const timeoutMs = Number(process.env.AGENTCONNECT_CURSOR_LOGIN_TIMEOUT_MS || 2e4);
-  const pollIntervalMs = Number(process.env.AGENTCONNECT_CURSOR_LOGIN_POLL_MS || 1e3);
-  const start = Date.now();
-  let status = await getCursorStatus();
-  while (!status.loggedIn && Date.now() - start < timeoutMs) {
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-    status = await getCursorStatus();
-  }
-  return { loggedIn: status.loggedIn };
-}
-function safeJsonParse3(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-function extractSessionId3(ev) {
-  const id = ev.session_id ?? ev.sessionId;
-  return typeof id === "string" ? id : null;
-}
-function extractUsage2(ev) {
-  const usage = ev.usage ?? ev.token_usage ?? ev.tokenUsage ?? ev.tokens;
-  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 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;
-  return Object.keys(out).length ? out : null;
-}
-function extractTextFromContent2(content) {
-  if (!content) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (!part) return "";
-      if (typeof part === "string") return part;
-      if (typeof part === "object") {
-        const text = part.text;
-        if (typeof text === "string") return text;
-      }
-      return "";
-    }).join("");
-  }
-  if (typeof content === "object") {
-    const text = content.text;
-    if (typeof text === "string") return text;
-  }
-  return "";
-}
-function extractToolCall(ev) {
-  if (ev.type !== "tool_call") return null;
-  const toolCall = ev.tool_call && typeof ev.tool_call === "object" ? ev.tool_call : null;
-  if (!toolCall) return null;
-  const keys = Object.keys(toolCall);
-  if (!keys.length) return null;
-  const name = keys[0];
-  const entry = toolCall[name];
-  const record = entry && typeof entry === "object" ? entry : null;
-  const input = record?.args ?? record?.input ?? void 0;
-  const output = record?.output ?? record?.result ?? void 0;
-  const subtype = typeof ev.subtype === "string" ? ev.subtype : "";
-  const phase = subtype === "completed" ? "completed" : subtype === "started" ? "start" : subtype === "error" ? "error" : subtype === "delta" ? "delta" : void 0;
-  return {
-    name,
-    input,
-    output,
-    callId: typeof ev.call_id === "string" ? ev.call_id : void 0,
-    phase
-  };
-}
-function extractTextFromMessage(message) {
-  if (!message || typeof message !== "object") return "";
-  const content = message.content;
-  return extractTextFromContent2(content);
-}
-function extractAssistantDelta2(ev) {
-  if (ev.type !== "assistant" && ev.message?.role !== "assistant") return null;
-  if (typeof ev.text === "string") return ev.text;
-  if (typeof ev.delta === "string") return ev.delta;
-  if (ev.message) {
-    const text = extractTextFromMessage(ev.message);
-    return text || null;
-  }
-  if (ev.content) {
-    const text = extractTextFromContent2(ev.content);
-    return text || null;
-  }
-  return null;
-}
-function extractResultText2(ev) {
-  if (typeof ev.result === "string") return ev.result;
-  if (ev.result && typeof ev.result === "object") {
-    const result = ev.result;
-    if (typeof result.text === "string") return result.text;
-    if (result.message) {
-      const text = extractTextFromMessage(result.message);
-      if (text) return text;
-    }
-    if (result.content) {
-      const text = extractTextFromContent2(result.content);
-      if (text) return text;
-    }
-  }
-  if (ev.message) {
-    const text = extractTextFromMessage(ev.message);
-    if (text) return text;
-  }
-  return null;
-}
-function isErrorEvent(ev) {
-  if (ev.type === "error") return true;
-  if (ev.type === "result" && ev.subtype) {
-    const subtype = String(ev.subtype).toLowerCase();
-    if (subtype.includes("error") || subtype.includes("failed")) return true;
-  }
-  return false;
-}
-function extractErrorMessage(ev) {
-  if (typeof ev.error === "string") return ev.error;
-  if (ev.error && typeof ev.error === "object" && typeof ev.error.message === "string") {
-    return ev.error.message;
-  }
-  if (typeof ev.text === "string" && ev.type === "error") return ev.text;
-  if (typeof ev.result === "string" && ev.type === "result") return ev.result;
-  return null;
-}
-function normalizeCursorEvent(raw) {
-  if (!raw || typeof raw !== "object") return { type: "unknown" };
-  const type = typeof raw.type === "string" ? raw.type : "unknown";
-  return { ...raw, type };
-}
-function runCursorPrompt({
-  prompt,
-  resumeSessionId,
-  model,
-  repoRoot,
-  cwd,
-  providerDetailLevel,
-  onEvent,
-  signal
-}) {
-  return new Promise((resolve) => {
-    const command2 = getCursorCommand();
-    const resolvedRepoRoot = repoRoot ? path4.resolve(repoRoot) : null;
-    const resolvedCwd = cwd ? path4.resolve(cwd) : null;
-    const runDir = resolvedCwd || resolvedRepoRoot || process.cwd();
-    const args2 = ["--print", "--output-format", "stream-json"];
-    if (resumeSessionId) {
-      args2.push("--resume", resumeSessionId);
-    }
-    const fallbackModel = getCursorDefaultModel();
-    const resolvedModel = resolveCursorModel(model, fallbackModel);
-    if (resolvedModel) {
-      args2.push("--model", resolvedModel);
-    }
-    const endpoint = resolveCursorEndpoint();
-    if (endpoint) {
-      args2.push("--endpoint", endpoint);
-    }
-    args2.push(prompt);
-    const argsPreview = [...args2];
-    if (argsPreview.length > 0) {
-      argsPreview[argsPreview.length - 1] = "[prompt]";
-    }
-    debugLog("Cursor", "spawn", {
-      command: command2,
-      args: argsPreview,
-      cwd: runDir,
-      model: resolvedModel || null,
-      endpoint: endpoint || null,
-      resume: resumeSessionId || null,
-      apiKeyConfigured: Boolean(getCursorApiKey().trim()),
-      promptChars: prompt.length
-    });
-    const child = spawn4(command2, args2, {
-      cwd: runDir,
-      env: buildCursorEnv(),
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (signal) {
-      signal.addEventListener("abort", () => {
-        child.kill("SIGTERM");
-      });
-    }
-    let aggregated = "";
-    let finalSessionId = null;
-    let didFinalize = false;
-    let sawError = false;
-    let sawJson = false;
-    let rawOutput = "";
-    const stdoutLines = [];
-    const stderrLines = [];
-    const includeRaw = providerDetailLevel === "raw";
-    const buildProviderDetail = (eventType, data, raw) => {
-      const detail = { eventType };
-      if (data && Object.keys(data).length) detail.data = data;
-      if (includeRaw && raw !== void 0) detail.raw = raw;
-      return detail;
-    };
-    const emit = (event) => {
-      if (finalSessionId) {
-        onEvent({ ...event, providerSessionId: finalSessionId });
-      } else {
-        onEvent(event);
-      }
-    };
-    const pushLine = (list, line) => {
-      if (!line) return;
-      list.push(line);
-      if (list.length > 12) list.shift();
-    };
-    const emitError = (message, providerDetail) => {
-      if (sawError) return;
-      sawError = true;
-      emit({ type: "error", message, providerDetail });
-    };
-    const emitFinal = (text) => {
-      if (didFinalize) return;
-      didFinalize = true;
-      emit({ type: "final", text });
-    };
-    const handleEvent = (ev) => {
-      const normalized = normalizeCursorEvent(ev);
-      if (ev?.type === "system" && ev?.subtype === "init") {
-        debugLog("Cursor", "init", {
-          apiKeySource: ev.apiKeySource || null,
-          cwd: ev.cwd || null,
-          model: ev.model || null,
-          permissionMode: ev.permissionMode || null,
-          sessionId: ev.session_id ?? ev.sessionId ?? null
-        });
-        emit({
-          type: "detail",
-          provider: "cursor",
-          providerDetail: buildProviderDetail(
-            "system.init",
-            {
-              apiKeySource: ev.apiKeySource,
-              cwd: ev.cwd,
-              model: ev.model,
-              permissionMode: ev.permissionMode
-            },
-            ev
-          )
-        });
-      }
-      const sid = extractSessionId3(ev);
-      if (sid) finalSessionId = sid;
-      if (ev?.type === "thinking") {
-        const subtype = typeof ev.subtype === "string" ? ev.subtype : "";
-        const phase = subtype === "completed" ? "completed" : subtype === "started" ? "start" : subtype === "error" ? "error" : "delta";
-        emit({
-          type: "thinking",
-          provider: "cursor",
-          phase,
-          text: typeof ev.text === "string" ? ev.text : "",
-          timestampMs: typeof ev.timestamp_ms === "number" ? ev.timestamp_ms : void 0,
-          providerDetail: buildProviderDetail(
-            subtype ? `thinking.${subtype}` : "thinking",
-            {
-              subtype: subtype || void 0
-            },
-            ev
-          )
-        });
-      }
-      if (ev?.type === "assistant" || ev?.type === "user") {
-        const role = ev.message?.role === "assistant" || ev.message?.role === "user" ? ev.message?.role : ev.type;
-        const rawContent = ev.message?.content ?? ev.content;
-        const content = extractTextFromContent2(rawContent);
-        emit({
-          type: "message",
-          provider: "cursor",
-          role,
-          content,
-          contentParts: rawContent ?? null,
-          providerDetail: buildProviderDetail(ev.type, {}, ev)
-        });
-      }
-      const toolCall = extractToolCall(ev);
-      if (toolCall) {
-        emit({
-          type: "tool_call",
-          provider: "cursor",
-          name: toolCall.name,
-          callId: toolCall.callId,
-          input: toolCall.input,
-          output: toolCall.output,
-          phase: toolCall.phase,
-          providerDetail: buildProviderDetail(
-            ev.subtype ? `tool_call.${ev.subtype}` : "tool_call",
-            {
-              name: toolCall.name,
-              callId: toolCall.callId,
-              subtype: ev.subtype
-            },
-            ev
-          )
-        });
-      }
-      const usage = extractUsage2(ev);
-      if (usage) {
-        emit({
-          type: "usage",
-          inputTokens: usage.input_tokens,
-          outputTokens: usage.output_tokens
-        });
-      }
-      if (isErrorEvent(ev)) {
-        const message = extractErrorMessage(ev) || "Cursor run failed";
-        emitError(message, buildProviderDetail(ev.subtype ? `error.${ev.subtype}` : "error", {}, ev));
-        return;
-      }
-      const delta = extractAssistantDelta2(ev);
-      if (delta) {
-        aggregated += delta;
-        emit({ type: "delta", text: delta, providerDetail: buildProviderDetail("delta", {}, ev) });
-      }
-      if (ev.type === "result") {
-        const resultText = extractResultText2(ev);
-        if (!aggregated && resultText) {
-          aggregated = resultText;
-        }
-        if (!sawError) {
-          emitFinal(aggregated || resultText || "");
-          emit({
-            type: "detail",
-            provider: "cursor",
-            providerDetail: buildProviderDetail(
-              "result",
-              {
-                subtype: ev.subtype,
-                duration_ms: typeof ev.duration_ms === "number" ? ev.duration_ms : void 0,
-                request_id: typeof ev.request_id === "string" ? ev.request_id : void 0,
-                is_error: typeof ev.is_error === "boolean" ? ev.is_error : void 0
-              },
-              ev
-            )
-          });
-        }
-      }
-    };
-    const handleLine = (line, source) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-      const payload = trimmed.startsWith("data: ") ? trimmed.slice(6).trim() : trimmed;
-      const parsed = safeJsonParse3(payload);
-      if (!parsed || typeof parsed !== "object") {
-        emit({ type: "raw_line", line });
-        if (source === "stdout") {
-          rawOutput += `${line}
-`;
-          pushLine(stdoutLines, line);
-        } else {
-          pushLine(stderrLines, line);
-        }
-        return;
-      }
-      sawJson = true;
-      handleEvent(parsed);
-    };
-    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}` : "";
-          debugLog("Cursor", "exit", { code, stderr: stderrLines, stdout: stdoutLines });
-          emitError(`Cursor CLI exited with code ${code}${suffix}`);
-        } else if (!sawError) {
-          const fallback = !sawJson ? rawOutput.trim() : "";
-          emitFinal(aggregated || fallback);
-        }
-      }
-      resolve({ sessionId: finalSessionId });
-    });
-    child.on("error", (err) => {
-      debugLog("Cursor", "spawn-error", { message: err?.message });
-      emitError(err?.message ?? "Cursor failed to start");
-      resolve({ sessionId: finalSessionId });
-    });
-  });
-}
-
-// 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 fetchJson3(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 fetchJson3(`${base}/models`);
-  return { installed: res.ok };
-}
-async function getLocalStatus() {
-  const base = getLocalBaseUrl();
-  const res = await fetchJson3(`${base}/models`);
-  if (!res.ok) return { installed: false, loggedIn: false };
-  return { installed: true, loggedIn: true };
-}
-async function updateLocal() {
-  return getLocalStatus();
-}
-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 fetchJson3(`${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 fetchJson3(`${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,
-    fastStatus: getClaudeFastStatus,
-    status: getClaudeStatus,
-    update: updateClaude,
-    login: loginClaude,
-    logout: async () => {
-    },
-    runPrompt: runClaudePrompt
-  },
-  codex: {
-    id: "codex",
-    name: "Codex",
-    ensureInstalled: ensureCodexInstalled,
-    fastStatus: getCodexFastStatus,
-    status: getCodexStatus,
-    update: updateCodex,
-    login: loginCodex,
-    logout: async () => {
-    },
-    runPrompt: runCodexPrompt
-  },
-  cursor: {
-    id: "cursor",
-    name: "Cursor",
-    ensureInstalled: ensureCursorInstalled,
-    fastStatus: getCursorFastStatus,
-    status: getCursorStatus,
-    update: updateCursor,
-    login: loginCursor,
-    logout: async () => {
-    },
-    runPrompt: runCursorPrompt
-  },
-  local: {
-    id: "local",
-    name: "Local",
-    ensureInstalled: ensureLocalInstalled,
-    status: getLocalStatus,
-    update: updateLocal,
-    login: loginLocal,
-    logout: async () => {
-    },
-    runPrompt: runLocalPrompt
-  }
-};
-async function listModels() {
-  const claudeModels = await listClaudeModels();
-  const codexModels = await listCodexModels();
-  const cursorModels = await listCursorModels();
-  const base = [
-    ...claudeModels,
-    ...cursorModels,
-    { 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("cursor")) return "cursor";
-  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 path5 from "path";
-function createObservedTracker({
-  basePath,
-  appId,
-  requested = []
-}) {
-  const requestedList = Array.isArray(requested) ? requested.filter(Boolean) : [];
-  const dirPath = path5.join(basePath, ".agentconnect");
-  const filePath = path5.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) {
-  if (process.env.AGENTCONNECT_DEBUG?.trim()) {
-    try {
-      console.log(
-        `[AgentConnect][Session ${sessionId}] ${type} ${JSON.stringify(data)}`
-      );
-    } catch {
-      console.log(`[AgentConnect][Session ${sessionId}] ${type}`);
-    }
-  }
-  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,
-      updateAvailable: info.updateAvailable,
-      latestVersion: info.latestVersion,
-      updateCheckedAt: info.updateCheckedAt,
-      updateSource: info.updateSource,
-      updateCommand: info.updateCommand,
-      updateMessage: info.updateMessage,
-      updateInProgress: info.updateInProgress
-    };
-  });
-}
-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 updatingProviders = /* @__PURE__ */ new Map();
-  const processTable = /* @__PURE__ */ new Map();
-  const backendState = /* @__PURE__ */ new Map();
-  const statusCache = /* @__PURE__ */ new Map();
-  const statusCacheTtlMs = 8e3;
-  const statusInFlight = /* @__PURE__ */ new Map();
-  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 path6.isAbsolute(value) ? value : path6.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(path6.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, options = {}) {
-    const cached = statusCache.get(provider.id);
-    const now = Date.now();
-    if (cached && now - cached.at < statusCacheTtlMs) {
-      return cached.status;
-    }
-    const existing = statusInFlight.get(provider.id);
-    if (existing) return existing;
-    if (options.allowFast && provider.fastStatus) {
-      try {
-        const fast = await provider.fastStatus();
-        const startedAt2 = Date.now();
-        const promise2 = provider.status().then((status) => {
-          debugLog("Providers", "status-check", {
-            providerId: provider.id,
-            durationMs: Date.now() - startedAt2,
-            completedAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          statusCache.set(provider.id, { status, at: Date.now() });
-          return status;
-        }).finally(() => {
-          statusInFlight.delete(provider.id);
-        });
-        statusInFlight.set(provider.id, promise2);
-        return fast;
-      } catch {
-      }
-    }
-    const startedAt = Date.now();
-    const promise = provider.status().then((status) => {
-      debugLog("Providers", "status-check", {
-        providerId: provider.id,
-        durationMs: Date.now() - startedAt,
-        completedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      statusCache.set(provider.id, { status, at: Date.now() });
-      return status;
-    }).finally(() => {
-      statusInFlight.delete(provider.id);
-    });
-    statusInFlight.set(provider.id, promise);
-    return promise;
-  }
-  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, { allowFast: true })];
-            } catch {
-              return [provider.id, { installed: false, loggedIn: false }];
-            }
-          })
-        );
-        const statuses = Object.fromEntries(statusEntries);
-        const list = buildProviderList(statuses).map((entry) => ({
-          ...entry,
-          updateInProgress: updatingProviders.has(entry.id)
-        }));
-        reply(socket, id, { providers: list });
-        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, { allowFast: true });
-        reply(socket, id, {
-          provider: {
-            id: provider.id,
-            name: provider.name,
-            installed: status.installed,
-            loggedIn: status.loggedIn,
-            version: status.version,
-            updateAvailable: status.updateAvailable,
-            latestVersion: status.latestVersion,
-            updateCheckedAt: status.updateCheckedAt,
-            updateSource: status.updateSource,
-            updateCommand: status.updateCommand,
-            updateMessage: status.updateMessage,
-            updateInProgress: updatingProviders.has(provider.id) || status.updateInProgress
-          }
-        });
-        return;
-      }
-      if (method === "acp.providers.update") {
-        const providerId = params.provider;
-        const provider = providers[providerId];
-        if (!provider) {
-          replyError(socket, id, "AC_ERR_UNSUPPORTED", "Unknown provider");
-          return;
-        }
-        debugLog("Providers", "update-start", { providerId });
-        if (!updatingProviders.has(providerId)) {
-          const promise = provider.update().finally(() => {
-            updatingProviders.delete(providerId);
-            invalidateStatus(providerId);
-          });
-          updatingProviders.set(providerId, promise);
-        }
-        try {
-          const status = await updatingProviders.get(providerId);
-          debugLog("Providers", "update-complete", {
-            providerId,
-            updateAvailable: status.updateAvailable,
-            latestVersion: status.latestVersion,
-            updateMessage: status.updateMessage
-          });
-          reply(socket, id, {
-            provider: {
-              id: provider.id,
-              name: provider.name,
-              installed: status.installed,
-              loggedIn: status.loggedIn,
-              version: status.version,
-              updateAvailable: status.updateAvailable,
-              latestVersion: status.latestVersion,
-              updateCheckedAt: status.updateCheckedAt,
-              updateSource: status.updateSource,
-              updateCommand: status.updateCommand,
-              updateMessage: status.updateMessage,
-              updateInProgress: false
-            }
-          });
-        } catch (err) {
-          debugLog("Providers", "update-error", {
-            providerId,
-            message: err instanceof Error ? err.message : String(err)
-          });
-          replyError(socket, id, "AC_ERR_INTERNAL", err?.message || "Update failed");
-        }
-        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 providerDetailLevel = params.providerDetailLevel || void 0;
-        const providerId = resolveProviderForModel(model);
-        recordModelCapability(model);
-        sessions.set(sessionId, {
-          id: sessionId,
-          providerId,
-          model,
-          providerSessionId: null,
-          reasoningEffort,
-          cwd,
-          repoRoot,
-          providerDetailLevel: providerDetailLevel === "raw" || providerDetailLevel === "minimal" ? providerDetailLevel : void 0
-        });
-        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;
-          const providerDetailLevel = params.providerDetailLevel || void 0;
-          recordModelCapability(model);
-          sessions.set(sessionId, {
-            id: sessionId,
-            providerId: resolveProviderForModel(model),
-            model,
-            providerSessionId: params.providerSessionId || null,
-            reasoningEffort,
-            cwd,
-            repoRoot,
-            providerDetailLevel: providerDetailLevel === "raw" || providerDetailLevel === "minimal" ? providerDetailLevel : void 0
-          });
-        } 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);
-          }
-          if (params.providerDetailLevel) {
-            const level = String(params.providerDetailLevel);
-            if (level === "raw" || level === "minimal") {
-              existing.providerDetailLevel = level;
-            }
-          }
-          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;
-        }
-        if (updatingProviders.has(session.providerId)) {
-          replyError(socket, id, "AC_ERR_BUSY", "Provider update in progress.");
-          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;
-        const providerDetailLevel = params.providerDetailLevel === "raw" || params.providerDetailLevel === "minimal" ? params.providerDetailLevel : session.providerDetailLevel || "minimal";
-        activeRuns.set(sessionId, controller);
-        let sawError = false;
-        provider.runPrompt({
-          prompt: message,
-          resumeSessionId: session.providerSessionId,
-          model: session.model,
-          reasoningEffort: session.reasoningEffort,
-          repoRoot,
-          cwd,
-          providerDetailLevel,
-          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(path6.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 = path6.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 = spawn5(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 = spawn5(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));
-  });
-}
+import path7 from "path";
+import { promises as fs5 } from "fs";
+import { createPrivateKey, createPublicKey as createPublicKey2, sign as signData } from "crypto";
+import { startDevHost } from "@agentconnect/host";
 
 // src/paths.ts
-import path7 from "path";
+import path from "path";
 import { fileURLToPath } from "url";
-import { promises as fs3 } from "fs";
+import { promises as fs } from "fs";
 async function exists(target) {
   try {
-    await fs3.stat(target);
+    await fs.stat(target);
     return true;
   } catch {
     return false;
   }
 }
 function resolveAppPath(input) {
-  const candidate = input ? path7.resolve(input) : process.cwd();
+  const candidate = input ? path.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 = path7.dirname(fileURLToPath(import.meta.url));
+  const start = path.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 = path7.join(current, "schemas");
+      const candidate = path.join(current, "schemas");
       if (await exists(candidate)) return candidate;
-      const parent = path7.dirname(current);
+      const parent = path.dirname(current);
       if (parent === current) break;
       current = parent;
     }
@@ -4149,25 +41,25 @@ async function findSchemaDir() {
 }
 
 // src/zip.ts
-import fs5 from "fs";
-import path9 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import { createHash } from "crypto";
 import yazl from "yazl";
 import yauzl from "yauzl";
 
 // src/fs-utils.ts
-import path8 from "path";
-import { promises as fs4 } from "fs";
+import path2 from "path";
+import { promises as fs2 } 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 });
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (ignoreNames.has(entry.name)) continue;
-      const fullPath = path8.join(dir, entry.name);
-      const rel = path8.relative(root, fullPath);
+      const fullPath = path2.join(dir, entry.name);
+      const rel = path2.relative(root, fullPath);
       if (ignorePaths.has(rel)) continue;
       if (entry.isDirectory()) {
         await walk(fullPath);
@@ -4180,16 +72,16 @@ async function collectFiles(root, options = {}) {
   return files.sort((a, b) => a.rel.localeCompare(b.rel));
 }
 async function readJson(filePath) {
-  const raw = await fs4.readFile(filePath, "utf8");
+  const raw = await fs2.readFile(filePath, "utf8");
   return JSON.parse(raw);
 }
 async function writeJson(filePath, data) {
-  await fs4.mkdir(path8.dirname(filePath), { recursive: true });
-  await fs4.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+  await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+  await fs2.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
 }
 async function fileExists(filePath) {
   try {
-    await fs4.stat(filePath);
+    await fs2.stat(filePath);
     return true;
   } catch {
     return false;
@@ -4200,7 +92,7 @@ async function fileExists(filePath) {
 async function hashFile(filePath) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = fs5.createReadStream(filePath);
+    const stream = fs3.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -4212,14 +104,14 @@ async function zipDirectory({
   ignoreNames = [],
   ignorePaths = []
 }) {
-  await fs5.promises.mkdir(path9.dirname(outputPath), { recursive: true });
+  await fs3.promises.mkdir(path3.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);
+    const outStream = fs3.createWriteStream(outputPath);
     zipfile.outputStream.pipe(outStream);
     outStream.on("close", () => resolve());
     outStream.on("error", reject);
@@ -4268,10 +160,10 @@ async function readZipEntry(zipPath, entryName) {
 }
 
 // src/manifest.ts
-import path10 from "path";
+import path4 from "path";
 import Ajv from "ajv";
 async function readManifestFromDir(appPath) {
-  const manifestPath = path10.join(appPath, "agentconnect.app.json");
+  const manifestPath = path4.join(appPath, "agentconnect.app.json");
   if (!await fileExists(manifestPath)) {
     throw new Error("agentconnect.app.json not found in app directory.");
   }
@@ -4289,7 +181,7 @@ async function loadManifestSchema() {
   if (!schemaDir) {
     throw new Error("Unable to locate schemas directory.");
   }
-  const schemaPath = path10.join(schemaDir, "app-manifest.json");
+  const schemaPath = path4.join(schemaDir, "app-manifest.json");
   return readJson(schemaPath);
 }
 async function validateManifest(manifest) {
@@ -4301,9 +193,9 @@ async function validateManifest(manifest) {
 }
 
 // src/registry.ts
-import path11 from "path";
-import { promises as fs6 } from "fs";
-function compareSemver4(a, b) {
+import path5 from "path";
+import { promises as fs4 } 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);
@@ -4325,26 +217,26 @@ async function publishPackage({
   if (!appId || !version) {
     throw new Error("Manifest must include id and version.");
   }
-  const entryDir = path11.join(registryPath, "apps", appId, version);
-  await fs6.mkdir(entryDir, { recursive: true });
-  const targetZip = path11.join(entryDir, "app.zip");
-  await fs6.copyFile(zipPath, targetZip);
-  const manifestPath = path11.join(entryDir, "manifest.json");
+  const entryDir = path5.join(registryPath, "apps", appId, version);
+  await fs4.mkdir(entryDir, { recursive: true });
+  const targetZip = path5.join(entryDir, "app.zip");
+  await fs4.copyFile(zipPath, targetZip);
+  const manifestPath = path5.join(entryDir, "manifest.json");
   await writeJson(manifestPath, resolvedManifest);
   let signatureOut = null;
   if (signaturePath) {
-    signatureOut = path11.join(entryDir, "signature.json");
-    await fs6.copyFile(signaturePath, signatureOut);
+    signatureOut = path5.join(entryDir, "signature.json");
+    await fs4.copyFile(signaturePath, signatureOut);
   }
   const hash = await hashFile(zipPath);
-  const indexPath = path11.join(registryPath, "index.json");
+  const indexPath = path5.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: path11.relative(registryPath, targetZip).replace(/\\/g, "/"),
+    path: path5.relative(registryPath, targetZip).replace(/\\/g, "/"),
     manifest: resolvedManifest,
     signature: signatureOut ? {
       algorithm: "unknown",
@@ -4354,7 +246,7 @@ async function publishPackage({
     hash
   };
   const currentLatest = index.apps[appId].latest;
-  if (!currentLatest || compareSemver4(version, currentLatest) > 0) {
+  if (!currentLatest || compareSemver(version, currentLatest) > 0) {
     index.apps[appId].latest = version;
   }
   await writeJson(indexPath, index);
@@ -4362,9 +254,9 @@ async function publishPackage({
 }
 
 // src/registry-validate.ts
-import path12 from "path";
+import path6 from "path";
 import { createPublicKey, verify as verifySignature } from "crypto";
-function compareSemver5(a, b) {
+function compareSemver2(a, b) {
   const parse = (v) => v.split("-")[0].split(".").map((n) => Number(n));
   const pa = parse(a);
   const pb = parse(b);
@@ -4376,7 +268,7 @@ function compareSemver5(a, b) {
 }
 function resolveEntry(registryPath, entryPath) {
   if (!entryPath || typeof entryPath !== "string") return null;
-  return path12.resolve(registryPath, entryPath);
+  return path6.resolve(registryPath, entryPath);
 }
 function normalizeSignatureAlg(signatureAlg) {
   const value = String(signatureAlg || "").toLowerCase();
@@ -4417,7 +309,7 @@ async function validateRegistry({
 }) {
   const errors = [];
   const warnings = [];
-  const indexPath = path12.join(registryPath, "index.json");
+  const indexPath = path6.join(registryPath, "index.json");
   if (!await fileExists(indexPath)) {
     return {
       valid: false,
@@ -4472,9 +364,9 @@ async function validateRegistry({
         message: `App ${appId} latest (${latest}) not found in versions.`
       });
     }
-    const sorted = [...versionKeys].sort(compareSemver5);
+    const sorted = [...versionKeys].sort(compareSemver2);
     const expectedLatest = sorted[sorted.length - 1];
-    if (latest && expectedLatest && compareSemver5(latest, expectedLatest) !== 0) {
+    if (latest && expectedLatest && compareSemver2(latest, expectedLatest) !== 0) {
       warnings.push({
         path: `apps.${appId}`,
         message: `App ${appId} latest (${latest}) is not the newest (${expectedLatest}).`
@@ -4633,7 +525,7 @@ async function main() {
   }
   if (command === "pack") {
     const appPath = resolveAppPath(getFlag("--app", "-a") ?? void 0);
-    const outPath = getFlag("--out", "-o") || path13.join(appPath, "dist", "app.zip");
+    const outPath = getFlag("--out", "-o") || path7.join(appPath, "dist", "app.zip");
     const manifest = await readManifestFromDir(appPath);
     const validation = await validateManifest(manifest);
     if (!validation.valid) {
@@ -4643,7 +535,7 @@ async function main() {
     }
     const ignoreNames = ["node_modules", ".git", ".DS_Store"];
     const ignorePaths = [];
-    const outputRel = path13.relative(appPath, outPath);
+    const outputRel = path7.relative(appPath, outPath);
     if (!outputRel.startsWith("..") && outputRel !== "") {
       ignorePaths.push(outputRel);
     }
@@ -4655,7 +547,7 @@ async function main() {
     const appArg = getFlag("--app", "-a");
     const jsonOut = args.includes("--json");
     const appPath = resolveAppPath(appArg ?? void 0);
-    const stats = await fs7.stat(appPath).catch(() => null);
+    const stats = await fs5.stat(appPath).catch(() => null);
     if (!stats) {
       console.error("App path not found.");
       return 1;
@@ -4696,16 +588,16 @@ async function main() {
       return 1;
     }
     const appPath = resolveAppPath(appArg);
-    const appStats = await fs7.stat(appPath).catch(() => null);
+    const appStats = await fs5.stat(appPath).catch(() => null);
     if (!appStats || !appStats.isFile()) {
       console.error("Sign requires a zip file path.");
       return 1;
     }
-    const outPath = getFlag("--out", "-o") || path13.join(path13.dirname(appPath), "app.sig.json");
+    const outPath = getFlag("--out", "-o") || path7.join(path7.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 privateKeyPem = await fs5.readFile(keyPath, "utf8");
     const privateKey = createPrivateKey(privateKeyPem);
     const keyType = privateKey.asymmetricKeyType;
     const algorithm = keyType === "ed25519" ? null : "sha256";
@@ -4725,8 +617,8 @@ async function main() {
       publicKey: publicKeyPem,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs7.mkdir(path13.dirname(outPath), { recursive: true });
-    await fs7.writeFile(outPath, JSON.stringify(signaturePayload, null, 2), "utf8");
+    await fs5.mkdir(path7.dirname(outPath), { recursive: true });
+    await fs5.writeFile(outPath, JSON.stringify(signaturePayload, null, 2), "utf8");
     console.log(`Signature written to ${outPath}`);
     return 0;
   }
@@ -4741,7 +633,7 @@ async function main() {
       return 1;
     }
     const appPath = resolveAppPath(appArg);
-    const appStats = await fs7.stat(appPath).catch(() => null);
+    const appStats = await fs5.stat(appPath).catch(() => null);
     if (!appStats || !appStats.isFile()) {
       console.error("Publish requires a zip file path.");
       return 1;