@agentconnect/cli 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,28 +1,29 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path12 from "path";
+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 spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import fs2 from "fs";
 import { promises as fsp } from "fs";
 import net from "net";
-import path5 from "path";
+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 } from "fs";
+import { existsSync, realpathSync } from "fs";
 import os from "os";
 import path from "path";
 var DEBUG_ENABLED = Boolean(process.env.AGENTCONNECT_DEBUG?.trim());
@@ -128,6 +129,15 @@ function resolveCommandPath(command2) {
   }
   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));
 }
@@ -143,6 +153,12 @@ function runCommand(command2, args2, options = {}) {
       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"]
@@ -168,10 +184,21 @@ function runCommand(command2, args2, options = {}) {
     });
     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 });
     });
   });
@@ -268,10 +295,110 @@ 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",
@@ -299,6 +426,23 @@ function getClaudeCommand() {
 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;
@@ -391,6 +535,18 @@ function resolveClaudeLoginExperience(options) {
   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`;
@@ -551,25 +707,154 @@ async function hasClaudeAuth() {
   }
   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() {
-  const command2 = resolveWindowsCommand(getClaudeCommand());
-  const result = await runCommand(command2, ["--print"], {
-    env: { ...process.env, CI: "1" },
-    input: "/status\n",
-    timeoutMs: 4e3
-  });
-  const output = `${result.stdout}
-${result.stderr}`.toLowerCase();
-  if (!output.trim()) {
-    return null;
+  if (claudeLoginCache && Date.now() - claudeLoginCache.checkedAt < CLAUDE_LOGIN_CACHE_TTL_MS) {
+    return claudeLoginCache.status;
   }
-  if (output.includes("not logged in") || output.includes("not authenticated") || output.includes("please log in") || output.includes("please login") || output.includes("run /login") || output.includes("sign in") || output.includes("invalid api key")) {
-    return false;
+  if (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
+    };
   }
-  if (output.includes("logged in") || output.includes("authenticated") || output.includes("signed in") || output.includes("account") || output.includes("@")) {
-    return true;
+  return {};
+}
+function ensureClaudeUpdateCheck(currentVersion, commandPath) {
+  if (claudeUpdateCache && Date.now() - claudeUpdateCache.checkedAt < CLAUDE_UPDATE_CACHE_TTL_MS) {
+    return;
   }
-  return null;
+  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();
@@ -633,18 +918,55 @@ async function getClaudeStatus() {
       const result = await runCommand(statusCommand, status.args);
       loggedIn = result.code === 0;
     } else {
-      const hasAuth = await hasClaudeAuth();
       const cliStatus = await checkClaudeCliStatus();
-      if (cliStatus === false) {
+      if (cliStatus.loggedIn === false) {
         loggedIn = false;
-      } else if (cliStatus === true) {
+      } else if (cliStatus.loggedIn === true) {
         loggedIn = true;
+      } else if (cliStatus.apiKeySource?.toLowerCase() === "none") {
+        loggedIn = false;
       } else {
-        loggedIn = hasAuth;
+        loggedIn = await hasClaudeAuth();
       }
     }
   }
-  return { installed, loggedIn, version: versionCheck.version || void 0 };
+  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 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);
@@ -661,10 +983,12 @@ 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 () => {
@@ -674,7 +998,7 @@ async function runClaudeLoginFlow(options) {
       } catch {
       }
     }
-    if (settingsPath) {
+    if (settingsPath && loginExperience !== "terminal") {
       try {
         await rm(settingsPath, { force: true });
       } catch {
@@ -683,7 +1007,13 @@ async function runClaudeLoginFlow(options) {
   };
   try {
     if (loginExperience === "terminal") {
-      await openClaudeLoginTerminal(command2, loginArgs, false);
+      await openClaudeLoginTerminal(command2, loginArgs, includeLogin);
+      if (settingsPath) {
+        setTimeout(() => {
+          rm(settingsPath, { force: true }).catch(() => {
+          });
+        }, loginTimeoutMs);
+      }
     } else {
       const ptyModule = await loadPtyModule();
       if (!ptyModule) {
@@ -691,7 +1021,8 @@ async function runClaudeLoginFlow(options) {
           "Claude login requires node-pty. Reinstall AgentConnect or run `claude /login` manually."
         );
       }
-      ptyProcess = ptyModule.spawn(command2, [...loginArgs, "/login"], {
+      const spawnArgs = includeLogin ? [...loginArgs, "/login"] : loginArgs;
+      ptyProcess = ptyModule.spawn(command2, spawnArgs, {
         name: "xterm-256color",
         cols: 100,
         rows: 30,
@@ -771,6 +1102,19 @@ function extractAssistantDelta(msg) {
   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;
@@ -789,6 +1133,7 @@ function runClaudePrompt({
   resumeSessionId,
   model,
   cwd,
+  providerDetailLevel,
   onEvent,
   signal
 }) {
@@ -821,45 +1166,189 @@ function runClaudePrompt({
     let finalSessionId = null;
     let didFinalize = false;
     let sawError = false;
-    const emitError = (message) => {
-      if (sawError) return;
-      sawError = true;
-      onEvent({ type: "error", message });
+    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 emitFinal = (text) => {
+    const emit = (event) => {
       if (finalSessionId) {
-        onEvent({ type: "final", text, providerSessionId: finalSessionId });
+        onEvent({ ...event, providerSessionId: finalSessionId });
       } else {
-        onEvent({ type: "final", text });
+        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()) {
-          onEvent({ type: "raw_line", line });
+          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;
-        onEvent({ type: "delta", text: delta });
+        emit({
+          type: "delta",
+          text: delta,
+          providerDetail: buildProviderDetail(msgType || "delta", {}, msg)
+        });
         return;
       }
       const assistant = extractAssistantText(msg);
       if (assistant && !aggregated) {
         aggregated = assistant;
-        onEvent({ type: "delta", text: 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);
+        emitFinal(aggregated || result, buildProviderDetail("result", {}, msg));
+        handled = true;
+      }
+      if (!handled) {
+        emit({
+          type: "detail",
+          provider: "claude",
+          providerDetail: buildProviderDetail(msgType || "unknown", {}, msg)
+        });
       }
     };
     const stdoutParser = createLineParser(handleLine);
@@ -886,23 +1375,177 @@ function runClaudePrompt({
 // 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;
-function trimOutput(value, limit = 400) {
+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;
 }
@@ -983,7 +1626,7 @@ async function ensureCodexInstalled() {
   });
   debugLog("Codex", "install-result", {
     code: installResult.code,
-    stderr: trimOutput(installResult.stderr)
+    stderr: trimOutput2(installResult.stderr)
   });
   const after = await checkCommandVersion(command2, [["--version"], ["-V"]]);
   codexModelsCache = null;
@@ -1020,7 +1663,44 @@ ${result.stderr}`.toLowerCase();
       loggedIn = await hasCodexAuth();
     }
   }
-  return { installed, loggedIn, version: versionCheck.version || void 0 };
+  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 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);
@@ -1030,7 +1710,7 @@ async function loginCodex() {
   const command2 = resolveWindowsCommand(login.command);
   debugLog("Codex", "login", { command: command2, args: login.args });
   const result = await runCommand(command2, login.args, { env: { ...process.env, CI: "1" } });
-  debugLog("Codex", "login-result", { code: result.code, stderr: trimOutput(result.stderr) });
+  debugLog("Codex", "login-result", { code: result.code, stderr: trimOutput2(result.stderr) });
   const status = await getCodexStatus();
   codexModelsCache = null;
   codexModelsCacheAt = 0;
@@ -1257,6 +1937,7 @@ function runCodexPrompt({
   reasoningEffort,
   repoRoot,
   cwd,
+  providerDetailLevel,
   onEvent,
   signal
 }) {
@@ -1294,10 +1975,88 @@ function runCodexPrompt({
       let finalSessionId = null;
       let didFinalize = false;
       let sawError = false;
-      const emitError = (message) => {
+      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;
-        onEvent({ type: "error", message });
+        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 = [];
@@ -1307,18 +2066,14 @@ function runCodexPrompt({
         list.push(line);
         if (list.length > 12) list.shift();
       };
-      const emitFinal = (text) => {
-        if (finalSessionId) {
-          onEvent({ type: "final", text, providerSessionId: finalSessionId });
-        } else {
-          onEvent({ type: "final", text });
-        }
+      const emitFinal = (text, providerDetail) => {
+        emit({ type: "final", text, providerDetail });
       };
       const handleLine = (line, source) => {
         const parsed = safeJsonParse2(line);
         if (!parsed || typeof parsed !== "object") {
           if (line.trim()) {
-            onEvent({ type: "raw_line", line });
+            emit({ type: "raw_line", line });
           }
           if (source === "stdout") {
             pushLine(stdoutLines, line);
@@ -1330,47 +2085,85 @@ function runCodexPrompt({
         sawJson = true;
         const ev = parsed;
         const normalized = normalizeEvent(ev);
-        onEvent({ type: "provider_event", provider: "codex", event: normalized });
         const sid = extractSessionId2(ev);
         if (sid) finalSessionId = sid;
+        const 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) {
-          onEvent({
+          emit({
             type: "usage",
             inputTokens: usage.input_tokens,
-            outputTokens: usage.output_tokens
+            outputTokens: usage.output_tokens,
+            providerDetail
           });
+          handled = true;
         }
         if (normalized.type === "agent_message") {
           const text = normalized.text;
           if (typeof text === "string" && text) {
             aggregated += text;
-            onEvent({ type: "delta", 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") {
-              onEvent({ type: "delta", text: item.aggregated_output });
+              emit({ type: "delta", text: item.aggregated_output, providerDetail: itemDetail });
             }
             if (item.type === "agent_message" && typeof item.text === "string") {
               aggregated += item.text;
-              onEvent({ type: "delta", text: 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");
+            emitError(typeof message === "string" ? message : "Codex run failed", providerDetail);
             didFinalize = true;
+            handled = true;
             return;
           }
           if (!sawError) {
             didFinalize = true;
-            emitFinal(aggregated);
+            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"));
@@ -1421,49 +2214,841 @@ function runCodexPrompt({
   });
 }
 
-// src/providers/local.ts
-function getLocalBaseUrl() {
-  const base = process.env.AGENTCONNECT_LOCAL_BASE_URL || "http://localhost:11434/v1";
-  return base.replace(/\/+$/, "");
+// 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 getLocalApiKey() {
-  return process.env.AGENTCONNECT_LOCAL_API_KEY || "";
+function normalizePath3(value) {
+  const normalized = value.replace(/\\/g, "/");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
-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;
+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])];
 }
-async function fetchJson(url, options = {}) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 4e3);
+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 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 };
+    const parsed = JSON.parse(result.stdout);
+    const version = parsed?.casks?.[0]?.version;
+    return typeof version === "string" ? version : null;
   } catch {
-    return { ok: false, status: 0, data: null };
-  } finally {
-    clearTimeout(timer);
+    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 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 fetchJson(`${base}/models`);
+  const res = await fetchJson3(`${base}/models`);
   return { installed: res.ok };
 }
 async function getLocalStatus() {
   const base = getLocalBaseUrl();
-  const res = await fetchJson(`${base}/models`);
+  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;
@@ -1482,7 +3067,7 @@ async function loginLocal(options = {}) {
 }
 async function listLocalModels() {
   const base = getLocalBaseUrl();
-  const res = await fetchJson(`${base}/models`);
+  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);
 }
@@ -1506,7 +3091,7 @@ async function runLocalPrompt({
   const headers = { "Content-Type": "application/json" };
   const apiKey = getLocalApiKey();
   if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-  const res = await fetchJson(`${base}/chat/completions`, {
+  const res = await fetchJson3(`${base}/chat/completions`, {
     method: "POST",
     headers,
     body: JSON.stringify(payload)
@@ -1533,6 +3118,7 @@ var providers = {
     name: "Claude",
     ensureInstalled: ensureClaudeInstalled,
     status: getClaudeStatus,
+    update: updateClaude,
     login: loginClaude,
     logout: async () => {
     },
@@ -1543,16 +3129,29 @@ var providers = {
     name: "Codex",
     ensureInstalled: ensureCodexInstalled,
     status: getCodexStatus,
+    update: updateCodex,
     login: loginCodex,
     logout: async () => {
     },
     runPrompt: runCodexPrompt
   },
+  cursor: {
+    id: "cursor",
+    name: "Cursor",
+    ensureInstalled: ensureCursorInstalled,
+    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 () => {
     },
@@ -1562,8 +3161,10 @@ var providers = {
 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;
@@ -1597,6 +3198,7 @@ async function listRecentModels(providerId) {
 }
 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";
@@ -1610,15 +3212,15 @@ function resolveProviderForModel(model) {
 
 // src/observed.ts
 import fs from "fs";
-import path4 from "path";
+import path5 from "path";
 function createObservedTracker({
   basePath,
   appId,
   requested = []
 }) {
   const requestedList = Array.isArray(requested) ? requested.filter(Boolean) : [];
-  const dirPath = path4.join(basePath, ".agentconnect");
-  const filePath = path4.join(dirPath, "observed-capabilities.json");
+  const dirPath = path5.join(basePath, ".agentconnect");
+  const filePath = path5.join(dirPath, "observed-capabilities.json");
   const observed = /* @__PURE__ */ new Set();
   let writeTimer = null;
   function load() {
@@ -1691,6 +3293,15 @@ function replyError(socket, id, 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",
@@ -1705,7 +3316,14 @@ function buildProviderList(statuses) {
       name: provider.name,
       installed: info.installed ?? false,
       loggedIn: info.loggedIn ?? false,
-      version: info.version
+      version: info.version,
+      updateAvailable: info.updateAvailable,
+      latestVersion: info.latestVersion,
+      updateCheckedAt: info.updateCheckedAt,
+      updateSource: info.updateSource,
+      updateCommand: info.updateCommand,
+      updateMessage: info.updateMessage,
+      updateInProgress: info.updateInProgress
     };
   });
 }
@@ -1720,10 +3338,12 @@ function startDevHost({
   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 = 2e3;
+  const statusCacheTtlMs = 8e3;
+  const statusInFlight = /* @__PURE__ */ new Map();
   const basePath = appPath || process.cwd();
   const manifest = readManifest(basePath);
   const appId = manifest?.id || "agentconnect-dev-app";
@@ -1736,7 +3356,7 @@ function startDevHost({
   function resolveAppPathInternal(input) {
     if (!input) return basePath;
     const value = String(input);
-    return path5.isAbsolute(value) ? value : path5.resolve(basePath, value);
+    return path6.isAbsolute(value) ? value : path6.resolve(basePath, value);
   }
   function mapFileType(stat) {
     if (stat.isFile()) return "file";
@@ -1774,7 +3394,7 @@ function startDevHost({
   }
   function readManifest(root) {
     try {
-      const raw = fs2.readFileSync(path5.join(root, "agentconnect.app.json"), "utf8");
+      const raw = fs2.readFileSync(path6.join(root, "agentconnect.app.json"), "utf8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -1794,9 +3414,22 @@ function startDevHost({
     if (cached && now - cached.at < statusCacheTtlMs) {
       return cached.status;
     }
-    const status = await provider.status();
-    statusCache.set(provider.id, { status, at: now });
-    return status;
+    const existing = statusInFlight.get(provider.id);
+    if (existing) return existing;
+    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;
@@ -1844,7 +3477,11 @@ function startDevHost({
           })
         );
         const statuses = Object.fromEntries(statusEntries);
-        reply(socket, id, { providers: buildProviderList(statuses) });
+        const list = buildProviderList(statuses).map((entry) => ({
+          ...entry,
+          updateInProgress: updatingProviders.has(entry.id)
+        }));
+        reply(socket, id, { providers: list });
         return;
       }
       if (method === "acp.providers.status") {
@@ -1861,11 +3498,66 @@ function startDevHost({
             name: provider.name,
             installed: status.installed,
             loggedIn: status.loggedIn,
-            version: status.version
+            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];
@@ -1943,6 +3635,7 @@ function startDevHost({
         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, {
@@ -1952,7 +3645,8 @@ function startDevHost({
           providerSessionId: null,
           reasoningEffort,
           cwd,
-          repoRoot
+          repoRoot,
+          providerDetailLevel: providerDetailLevel === "raw" || providerDetailLevel === "minimal" ? providerDetailLevel : void 0
         });
         reply(socket, id, { sessionId });
         return;
@@ -1965,6 +3659,7 @@ function startDevHost({
           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,
@@ -1973,7 +3668,8 @@ function startDevHost({
             providerSessionId: params.providerSessionId || null,
             reasoningEffort,
             cwd,
-            repoRoot
+            repoRoot,
+            providerDetailLevel: providerDetailLevel === "raw" || providerDetailLevel === "minimal" ? providerDetailLevel : void 0
           });
         } else {
           if (params.providerSessionId) {
@@ -1985,6 +3681,12 @@ function startDevHost({
           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 });
@@ -2004,6 +3706,10 @@ function startDevHost({
           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();
@@ -2015,6 +3721,7 @@ function startDevHost({
         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({
@@ -2024,6 +3731,7 @@ function startDevHost({
           reasoningEffort: session.reasoningEffort,
           repoRoot,
           cwd,
+          providerDetailLevel,
           signal: controller.signal,
           onEvent: (event) => {
             if (event.type === "error") {
@@ -2089,7 +3797,7 @@ function startDevHost({
           const filePath = resolveAppPathInternal(params.path);
           const encoding = params.encoding || "utf8";
           const content = params.content ?? "";
-          await fsp.mkdir(path5.dirname(filePath), { recursive: true });
+          await fsp.mkdir(path6.dirname(filePath), { recursive: true });
           await fsp.writeFile(filePath, content, {
             encoding,
             mode: params.mode
@@ -2113,7 +3821,7 @@ function startDevHost({
           const entries = await fsp.readdir(dirPath, { withFileTypes: true });
           const results = [];
           for (const entry of entries) {
-            const entryPath = path5.join(dirPath, entry.name);
+            const entryPath = path6.join(dirPath, entry.name);
             let size = 0;
             let type = "other";
             try {
@@ -2169,7 +3877,7 @@ function startDevHost({
           const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : basePath;
           const env = { ...process.env, ...params.env || {} };
           const useTty = Boolean(params.tty);
-          const child = spawn4(command2, args2, {
+          const child = spawn5(command2, args2, {
             cwd,
             env,
             stdio: useTty ? "inherit" : ["pipe", "pipe", "pipe"]
@@ -2285,7 +3993,7 @@ function startDevHost({
           }
           const cwd = backendConfig.cwd ? resolveAppPathInternal(backendConfig.cwd) : basePath;
           const args2 = backendConfig.args || [];
-          const child = spawn4(backendConfig.command, args2, {
+          const child = spawn5(backendConfig.command, args2, {
             cwd,
             env,
             stdio: ["ignore", "pipe", "pipe"]
@@ -2364,7 +4072,7 @@ function startDevHost({
 }
 
 // src/paths.ts
-import path6 from "path";
+import path7 from "path";
 import { fileURLToPath } from "url";
 import { promises as fs3 } from "fs";
 async function exists(target) {
@@ -2376,20 +4084,20 @@ async function exists(target) {
   }
 }
 function resolveAppPath(input) {
-  const candidate = input ? path6.resolve(input) : process.cwd();
+  const candidate = input ? path7.resolve(input) : process.cwd();
   return candidate;
 }
 async function findSchemaDir() {
   const envDir = process.env.AGENTCONNECT_SCHEMA_DIR;
   if (envDir && await exists(envDir)) return envDir;
-  const start = path6.dirname(fileURLToPath(import.meta.url));
+  const start = path7.dirname(fileURLToPath(import.meta.url));
   const roots = [start, process.cwd()];
   for (const root of roots) {
     let current = root;
     for (let i = 0; i < 8; i += 1) {
-      const candidate = path6.join(current, "schemas");
+      const candidate = path7.join(current, "schemas");
       if (await exists(candidate)) return candidate;
-      const parent = path6.dirname(current);
+      const parent = path7.dirname(current);
       if (parent === current) break;
       current = parent;
     }
@@ -2399,13 +4107,13 @@ async function findSchemaDir() {
 
 // src/zip.ts
 import fs5 from "fs";
-import path8 from "path";
+import path9 from "path";
 import { createHash } from "crypto";
 import yazl from "yazl";
 import yauzl from "yauzl";
 
 // src/fs-utils.ts
-import path7 from "path";
+import path8 from "path";
 import { promises as fs4 } from "fs";
 async function collectFiles(root, options = {}) {
   const ignoreNames = new Set(options.ignoreNames || []);
@@ -2415,8 +4123,8 @@ async function collectFiles(root, options = {}) {
     const entries = await fs4.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (ignoreNames.has(entry.name)) continue;
-      const fullPath = path7.join(dir, entry.name);
-      const rel = path7.relative(root, fullPath);
+      const fullPath = path8.join(dir, entry.name);
+      const rel = path8.relative(root, fullPath);
       if (ignorePaths.has(rel)) continue;
       if (entry.isDirectory()) {
         await walk(fullPath);
@@ -2433,7 +4141,7 @@ async function readJson(filePath) {
   return JSON.parse(raw);
 }
 async function writeJson(filePath, data) {
-  await fs4.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs4.mkdir(path8.dirname(filePath), { recursive: true });
   await fs4.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
 }
 async function fileExists(filePath) {
@@ -2461,7 +4169,7 @@ async function zipDirectory({
   ignoreNames = [],
   ignorePaths = []
 }) {
-  await fs5.promises.mkdir(path8.dirname(outputPath), { recursive: true });
+  await fs5.promises.mkdir(path9.dirname(outputPath), { recursive: true });
   const zipfile = new yazl.ZipFile();
   const files = await collectFiles(inputDir, { ignoreNames, ignorePaths });
   for (const file of files) {
@@ -2517,10 +4225,10 @@ async function readZipEntry(zipPath, entryName) {
 }
 
 // src/manifest.ts
-import path9 from "path";
+import path10 from "path";
 import Ajv from "ajv";
 async function readManifestFromDir(appPath) {
-  const manifestPath = path9.join(appPath, "agentconnect.app.json");
+  const manifestPath = path10.join(appPath, "agentconnect.app.json");
   if (!await fileExists(manifestPath)) {
     throw new Error("agentconnect.app.json not found in app directory.");
   }
@@ -2538,7 +4246,7 @@ async function loadManifestSchema() {
   if (!schemaDir) {
     throw new Error("Unable to locate schemas directory.");
   }
-  const schemaPath = path9.join(schemaDir, "app-manifest.json");
+  const schemaPath = path10.join(schemaDir, "app-manifest.json");
   return readJson(schemaPath);
 }
 async function validateManifest(manifest) {
@@ -2550,9 +4258,9 @@ async function validateManifest(manifest) {
 }
 
 // src/registry.ts
-import path10 from "path";
+import path11 from "path";
 import { promises as fs6 } from "fs";
-function compareSemver(a, b) {
+function compareSemver4(a, b) {
   const parse = (v) => v.split("-")[0].split(".").map((n) => Number(n));
   const pa = parse(a);
   const pb = parse(b);
@@ -2574,26 +4282,26 @@ async function publishPackage({
   if (!appId || !version) {
     throw new Error("Manifest must include id and version.");
   }
-  const entryDir = path10.join(registryPath, "apps", appId, version);
+  const entryDir = path11.join(registryPath, "apps", appId, version);
   await fs6.mkdir(entryDir, { recursive: true });
-  const targetZip = path10.join(entryDir, "app.zip");
+  const targetZip = path11.join(entryDir, "app.zip");
   await fs6.copyFile(zipPath, targetZip);
-  const manifestPath = path10.join(entryDir, "manifest.json");
+  const manifestPath = path11.join(entryDir, "manifest.json");
   await writeJson(manifestPath, resolvedManifest);
   let signatureOut = null;
   if (signaturePath) {
-    signatureOut = path10.join(entryDir, "signature.json");
+    signatureOut = path11.join(entryDir, "signature.json");
     await fs6.copyFile(signaturePath, signatureOut);
   }
   const hash = await hashFile(zipPath);
-  const indexPath = path10.join(registryPath, "index.json");
+  const indexPath = path11.join(registryPath, "index.json");
   const index = await fileExists(indexPath) ? await readJson(indexPath) : { apps: {} };
   if (!index.apps) index.apps = {};
   if (!index.apps[appId]) {
     index.apps[appId] = { latest: version, versions: {} };
   }
   index.apps[appId].versions[version] = {
-    path: path10.relative(registryPath, targetZip).replace(/\\/g, "/"),
+    path: path11.relative(registryPath, targetZip).replace(/\\/g, "/"),
     manifest: resolvedManifest,
     signature: signatureOut ? {
       algorithm: "unknown",
@@ -2603,7 +4311,7 @@ async function publishPackage({
     hash
   };
   const currentLatest = index.apps[appId].latest;
-  if (!currentLatest || compareSemver(version, currentLatest) > 0) {
+  if (!currentLatest || compareSemver4(version, currentLatest) > 0) {
     index.apps[appId].latest = version;
   }
   await writeJson(indexPath, index);
@@ -2611,9 +4319,9 @@ async function publishPackage({
 }
 
 // src/registry-validate.ts
-import path11 from "path";
+import path12 from "path";
 import { createPublicKey, verify as verifySignature } from "crypto";
-function compareSemver2(a, b) {
+function compareSemver5(a, b) {
   const parse = (v) => v.split("-")[0].split(".").map((n) => Number(n));
   const pa = parse(a);
   const pb = parse(b);
@@ -2625,7 +4333,7 @@ function compareSemver2(a, b) {
 }
 function resolveEntry(registryPath, entryPath) {
   if (!entryPath || typeof entryPath !== "string") return null;
-  return path11.resolve(registryPath, entryPath);
+  return path12.resolve(registryPath, entryPath);
 }
 function normalizeSignatureAlg(signatureAlg) {
   const value = String(signatureAlg || "").toLowerCase();
@@ -2666,7 +4374,7 @@ async function validateRegistry({
 }) {
   const errors = [];
   const warnings = [];
-  const indexPath = path11.join(registryPath, "index.json");
+  const indexPath = path12.join(registryPath, "index.json");
   if (!await fileExists(indexPath)) {
     return {
       valid: false,
@@ -2721,9 +4429,9 @@ async function validateRegistry({
         message: `App ${appId} latest (${latest}) not found in versions.`
       });
     }
-    const sorted = [...versionKeys].sort(compareSemver2);
+    const sorted = [...versionKeys].sort(compareSemver5);
     const expectedLatest = sorted[sorted.length - 1];
-    if (latest && expectedLatest && compareSemver2(latest, expectedLatest) !== 0) {
+    if (latest && expectedLatest && compareSemver5(latest, expectedLatest) !== 0) {
       warnings.push({
         path: `apps.${appId}`,
         message: `App ${appId} latest (${latest}) is not the newest (${expectedLatest}).`
@@ -2882,7 +4590,7 @@ async function main() {
   }
   if (command === "pack") {
     const appPath = resolveAppPath(getFlag("--app", "-a") ?? void 0);
-    const outPath = getFlag("--out", "-o") || path12.join(appPath, "dist", "app.zip");
+    const outPath = getFlag("--out", "-o") || path13.join(appPath, "dist", "app.zip");
     const manifest = await readManifestFromDir(appPath);
     const validation = await validateManifest(manifest);
     if (!validation.valid) {
@@ -2892,7 +4600,7 @@ async function main() {
     }
     const ignoreNames = ["node_modules", ".git", ".DS_Store"];
     const ignorePaths = [];
-    const outputRel = path12.relative(appPath, outPath);
+    const outputRel = path13.relative(appPath, outPath);
     if (!outputRel.startsWith("..") && outputRel !== "") {
       ignorePaths.push(outputRel);
     }
@@ -2950,7 +4658,7 @@ async function main() {
       console.error("Sign requires a zip file path.");
       return 1;
     }
-    const outPath = getFlag("--out", "-o") || path12.join(path12.dirname(appPath), "app.sig.json");
+    const outPath = getFlag("--out", "-o") || path13.join(path13.dirname(appPath), "app.sig.json");
     const manifest = await readManifestFromZip(appPath);
     const hash = await hashFile(appPath);
     const hashBuffer = Buffer.from(hash, "hex");
@@ -2974,7 +4682,7 @@ async function main() {
       publicKey: publicKeyPem,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs7.mkdir(path12.dirname(outPath), { recursive: true });
+    await fs7.mkdir(path13.dirname(outPath), { recursive: true });
     await fs7.writeFile(outPath, JSON.stringify(signaturePayload, null, 2), "utf8");
     console.log(`Signature written to ${outPath}`);
     return 0;