@codeam/shared 2.54.0

package/dist/index.js

@@ -0,0 +1,700 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AGENT_REGISTRY: () => AGENT_REGISTRY,
+  DEFAULT_API_BASE_URL: () => DEFAULT_API_BASE_URL,
+  DEV_API_BASE_URL: () => DEV_API_BASE_URL,
+  HEADROOM_BACKEND_ENV: () => HEADROOM_BACKEND_ENV,
+  HEADROOM_EXTRAS_BY_SURFACE: () => HEADROOM_EXTRAS_BY_SURFACE,
+  HEADROOM_MODELS: () => HEADROOM_MODELS,
+  HEADROOM_PIP_COMPANIONS: () => HEADROOM_PIP_COMPANIONS,
+  HEADROOM_PROXY_PORT: () => HEADROOM_PROXY_PORT,
+  HEARTBEAT_INTERVAL_MS_DEFAULT: () => HEARTBEAT_INTERVAL_MS_DEFAULT,
+  HOUSE_AGENT_ID: () => HOUSE_AGENT_ID,
+  HOUSE_AGENT_NAME: () => HOUSE_AGENT_NAME,
+  HOUSE_AGENT_PROVIDER: () => HOUSE_AGENT_PROVIDER,
+  HOUSE_AGENT_SUBTITLE: () => HOUSE_AGENT_SUBTITLE,
+  HOUSE_AGENT_VENDOR: () => HOUSE_AGENT_VENDOR,
+  INTERNAL_TO_PUBLIC: () => INTERNAL_TO_PUBLIC,
+  LINKED_AGENT_IDS: () => LINKED_AGENT_IDS,
+  MODEL_CONTEXT_WINDOW: () => MODEL_CONTEXT_WINDOW,
+  MODEL_PRICING: () => MODEL_PRICING,
+  OBSERVER_BRIDGE_PORT: () => OBSERVER_BRIDGE_PORT,
+  PREVIEW_DETECT_PROMPT: () => PREVIEW_DETECT_PROMPT,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  PUBLIC_TO_INTERNAL: () => PUBLIC_TO_INTERNAL,
+  SSE_SOCKET_TIMEOUT_MS: () => SSE_SOCKET_TIMEOUT_MS,
+  TERMINAL_AGENT_PREFIX: () => TERMINAL_AGENT_PREFIX,
+  USER_EVENTS: () => USER_EVENTS,
+  getAgent: () => getAgent,
+  getContextWindow: () => getContextWindow,
+  getEnabledAgents: () => getEnabledAgents,
+  getPricing: () => getPricing,
+  headroomKindFor: () => headroomKindFor,
+  headroomModelPredownloadScript: () => headroomModelPredownloadScript,
+  headroomPipPackage: () => headroomPipPackage,
+  headroomSnapshotDownloadLine: () => headroomSnapshotDownloadLine,
+  internalToPublic: () => internalToPublic,
+  isHeadroomWrappable: () => isHeadroomWrappable,
+  isKnownAgentId: () => isKnownAgentId,
+  isKnownModel: () => isKnownModel,
+  isLinkedAgentId: () => isLinkedAgentId,
+  normalizeAgentId: () => normalizeAgentId,
+  publicToInternal: () => publicToInternal,
+  renderToLines: () => renderToLines,
+  resolveApiBaseUrl: () => resolveApiBaseUrl,
+  toRemoteCommand: () => toRemoteCommand
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/protocol/constants.ts
+var PROTOCOL_VERSION = "2.0.0";
+var OBSERVER_BRIDGE_PORT = 47832;
+var HEARTBEAT_INTERVAL_MS_DEFAULT = 3e4;
+var SSE_SOCKET_TIMEOUT_MS = 35e3;
+
+// src/protocol/renderToLines.ts
+function renderToLines(raw) {
+  const screen = [""];
+  let row = 0;
+  let col = 0;
+  function ensureRow() {
+    while (screen.length <= row) screen.push("");
+  }
+  function writeChar(ch) {
+    ensureRow();
+    if (col < screen[row].length) {
+      screen[row] = screen[row].slice(0, col) + ch + screen[row].slice(col + 1);
+    } else {
+      while (screen[row].length < col) screen[row] += " ";
+      screen[row] += ch;
+    }
+    col++;
+  }
+  let i = 0;
+  while (i < raw.length) {
+    const ch = raw[i];
+    if (ch === "\x1B") {
+      i++;
+      if (i >= raw.length) break;
+      if (raw[i] === "[") {
+        i++;
+        let param = "";
+        while (i < raw.length && !/[@-~]/.test(raw[i])) param += raw[i++];
+        const cmd = raw[i] ?? "";
+        const n = parseInt(param) || 1;
+        if (cmd === "A") {
+          row = Math.max(0, row - n);
+        } else if (cmd === "B") {
+          row += n;
+          ensureRow();
+        } else if (cmd === "C") {
+          col += n;
+        } else if (cmd === "D") {
+          col = Math.max(0, col - n);
+        } else if (cmd === "G") {
+          col = Math.max(0, n - 1);
+        } else if (cmd === "H" || cmd === "f") {
+          const p = param.split(";");
+          row = Math.max(0, (parseInt(p[0] ?? "1") || 1) - 1);
+          col = Math.max(0, (parseInt(p[1] ?? "1") || 1) - 1);
+          ensureRow();
+        } else if (cmd === "J") {
+          if (param === "2" || param === "3") {
+            screen.length = 1;
+            screen[0] = "";
+            row = 0;
+            col = 0;
+          } else if (param === "1") {
+            for (let r = 0; r < row; r++) screen[r] = "";
+            screen[row] = " ".repeat(col) + screen[row].slice(col);
+          } else {
+            screen[row] = screen[row].slice(0, col);
+            screen.splice(row + 1);
+          }
+        } else if (cmd === "K") {
+          ensureRow();
+          if (param === "" || param === "0") screen[row] = screen[row].slice(0, col);
+          else if (param === "1") screen[row] = " ".repeat(col) + screen[row].slice(col);
+          else if (param === "2") screen[row] = "";
+        } else if (cmd === "h" && (param === "?1049" || param === "?47")) {
+          screen.length = 1;
+          screen[0] = "";
+          row = 0;
+          col = 0;
+        } else if (cmd === "l" && (param === "?1049" || param === "?47")) {
+          screen.length = 1;
+          screen[0] = "";
+          row = 0;
+          col = 0;
+        }
+      } else if (raw[i] === "]") {
+        i++;
+        while (i < raw.length) {
+          if (raw[i] === "\x07") break;
+          if (raw[i] === "\x1B" && i + 1 < raw.length && raw[i + 1] === "\\") {
+            i++;
+            break;
+          }
+          i++;
+        }
+      }
+    } else if (ch === "\r") {
+      if (i + 1 < raw.length && raw[i + 1] === "\n") {
+        row++;
+        col = 0;
+        ensureRow();
+        i++;
+      } else {
+        col = 0;
+      }
+    } else if (ch === "\n") {
+      row++;
+      col = 0;
+      ensureRow();
+    } else if (ch >= " " || ch === "	") {
+      writeChar(ch);
+    }
+    i++;
+  }
+  return screen;
+}
+
+// src/protocol/remote-command.ts
+var import_zod = require("zod");
+var remoteCommandSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  sessionId: import_zod.z.string(),
+  pluginId: import_zod.z.string(),
+  type: import_zod.z.string(),
+  // The backend may omit `payload` (or send null) for payload-less commands;
+  // clients have always normalized that to `{}` — keep that behavior here.
+  payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).nullish(),
+  status: import_zod.z.string(),
+  createdAt: import_zod.z.number()
+});
+function toRemoteCommand(raw) {
+  const parsed = remoteCommandSchema.safeParse(raw);
+  if (!parsed.success) return null;
+  const { payload, ...rest } = parsed.data;
+  return { ...rest, payload: payload ?? {} };
+}
+
+// src/models/pricing.ts
+var MODEL_PRICING = {
+  // ── Anthropic / Claude ────────────────────────────────────
+  // The 4.x rows below cover the model ids actually emitted by the CLI
+  // (apps/cli/src/agents/claude/runtime.ts listModels) and the JetBrains
+  // fallback catalog (RemoteCommandRouter.kt). Prices are copied from the
+  // same-family base rows (claude-opus-4 / claude-sonnet-4 /
+  // claude-3-5-haiku) until distinct published rates land.
+  "claude-opus-4-7": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-4-6": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  // Haiku-tier prices copied from claude-3-5-haiku (closest same-tier
+  // sibling in this table) — previously this id matched NO row and was
+  // silently billed at sonnet rates via the unknown-model fallback.
+  "claude-haiku-4-5": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-3-5-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3-5-haiku": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  "claude-3-haiku": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 },
+  // ── Codex / OpenAI ────────────────────────────────────────
+  // Phase 2 placeholder pricing: 0 across the board until OpenAI publishes
+  // confirmed rates for the GPT-5.x catalog. Sync from
+  // developers.openai.com/pricing when available.
+  "gpt-5.5": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "gpt-5.4": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "gpt-5.4-mini": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "gpt-5.3-codex": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "gpt-5.2": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "codex-auto-review": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+};
+var MODEL_CONTEXT_WINDOW = {
+  // ── Anthropic / Claude ────────────────────────────────────
+  "claude-opus-4-7": 1e6,
+  "claude-opus-4-6": 1e6,
+  "claude-sonnet-4-6": 1e6,
+  "claude-haiku-4-5": 2e5,
+  "claude-opus-4": 1e6,
+  "claude-sonnet-4": 1e6,
+  "claude-3-5-sonnet": 2e5,
+  "claude-3-5-haiku": 2e5,
+  "claude-3-haiku": 2e5,
+  // ── Codex / OpenAI ────────────────────────────────────────
+  "gpt-5.5": 272e3,
+  "gpt-5.4": 272e3,
+  "gpt-5.4-mini": 272e3,
+  "gpt-5.3-codex": 272e3,
+  "gpt-5.2": 272e3,
+  "codex-auto-review": 272e3
+};
+var DEFAULT_CONTEXT_WINDOW = 2e5;
+function longestPrefixMatch(table, model) {
+  let best;
+  let bestLen = -1;
+  for (const [prefix, value] of Object.entries(table)) {
+    if (prefix.length > bestLen && model.startsWith(prefix)) {
+      best = value;
+      bestLen = prefix.length;
+    }
+  }
+  return best;
+}
+function isKnownModel(model) {
+  return longestPrefixMatch(MODEL_PRICING, model) !== void 0;
+}
+function getPricing(model) {
+  return longestPrefixMatch(MODEL_PRICING, model) ?? MODEL_PRICING["claude-sonnet-4"];
+}
+function getContextWindow(model) {
+  if (!model) return DEFAULT_CONTEXT_WINDOW;
+  return longestPrefixMatch(MODEL_CONTEXT_WINDOW, model) ?? DEFAULT_CONTEXT_WINDOW;
+}
+
+// src/agents/registry.ts
+var AGENT_REGISTRY = {
+  claude: {
+    id: "claude",
+    displayName: "Claude Code",
+    binaryName: "claude",
+    enabled: true,
+    // Mirrors the backend registry (codeagent-mobile
+    // apps/api-v2/src/codespaces/agent.ts — authoritative for auth
+    // capabilities). `setup_token` is the bare `sk-ant-oat01-…` from
+    // `claude setup-token` → delivered via CLAUDE_CODE_OAUTH_TOKEN.
+    supportedAuthKinds: ["setup_token", "oauth_token", "api_key"],
+    preferredAuthKind: "setup_token",
+    headroomWrappable: true,
+    headroomKind: "claude",
+    // npm adapter `@agentclientprotocol/claude-agent-acp`.
+    acp: true
+  },
+  codex: {
+    id: "codex",
+    displayName: "Codex CLI",
+    binaryName: "codex",
+    enabled: true,
+    supportedAuthKinds: ["oauth_token", "api_key"],
+    preferredAuthKind: "oauth_token",
+    headroomWrappable: true,
+    headroomKind: "codex",
+    // npm adapter `@agentclientprotocol/codex-acp`.
+    acp: true,
+    // OAuth device-code flow; the user_code on the OpenAI page IS a real
+    // human-typed code — surfaces render it (with a copy affordance).
+    deviceFlow: true,
+    showsUserCode: true
+  },
+  copilot: {
+    id: "copilot",
+    displayName: "GitHub Copilot CLI",
+    binaryName: "gh",
+    enabled: false,
+    supportedAuthKinds: ["oauth_token"],
+    preferredAuthKind: "oauth_token",
+    // `headroom init --global copilot` exists even though the agent is
+    // still disabled here (no runtime builder yet).
+    headroomWrappable: true,
+    headroomKind: "copilot",
+    acp: false
+  },
+  coderabbit: {
+    id: "coderabbit",
+    displayName: "CodeRabbit",
+    binaryName: "coderabbit",
+    enabled: true,
+    // Backend registry is authoritative: CodeRabbit links via a real
+    // API key only (no OAuth flow exists in api-v2).
+    supportedAuthKinds: ["api_key"],
+    preferredAuthKind: "api_key",
+    headroomWrappable: false,
+    // Legacy PTY runtime — no ACP adapter registered.
+    acp: false
+  },
+  cursor: {
+    id: "cursor",
+    displayName: "Cursor Agent",
+    binaryName: "cursor-agent",
+    enabled: true,
+    // Backend registry is authoritative: since the Cursor OAuth
+    // device-flow shipped, new links are oauth_token only (the login
+    // blob written to ~/.config/cursor/auth.json). Legacy vaulted
+    // api_key rows may still exist server-side, but the link surface
+    // no longer offers api_key.
+    supportedAuthKinds: ["oauth_token"],
+    preferredAuthKind: "oauth_token",
+    // `headroom wrap cursor` is "manual/print-only" (IDE settings; the
+    // headless cursor-agent CLI has no base-URL override) — runs native.
+    headroomWrappable: false,
+    // Native ACP server: `cursor-agent acp`.
+    acp: true,
+    // Reverse-engineered device/poll flow; `userCode` is the secret PKCE
+    // verifier echoed back on poll — NEVER human-facing.
+    deviceFlow: true,
+    showsUserCode: false
+  },
+  aider: {
+    id: "aider",
+    displayName: "Aider",
+    binaryName: "aider",
+    enabled: true,
+    // Aider is OAuth-less — auth is via ANTHROPIC_API_KEY / OPENAI_API_KEY
+    // / etc. env vars or `~/.aider.conf.yml`. The link flow surfaces
+    // this via the existing --api-key escape hatch in commands/link.ts.
+    supportedAuthKinds: ["api_key"],
+    preferredAuthKind: "api_key",
+    headroomWrappable: false,
+    // Legacy PTY runtime — no ACP adapter registered.
+    acp: false
+  },
+  gemini: {
+    id: "gemini",
+    displayName: "Gemini CLI",
+    binaryName: "gemini",
+    enabled: true,
+    // OAuth via `gemini auth login` (captured by `codeam link gemini`
+    // from ~/.gemini/oauth_creds.json) AND GEMINI_API_KEY are both
+    // accepted by the backend's GeminiProvisioningStrategy and propagated
+    // into codespace deploys.
+    supportedAuthKinds: ["oauth_token", "api_key"],
+    preferredAuthKind: "oauth_token",
+    // Not listed by `headroom wrap --help` — runs native.
+    headroomWrappable: false,
+    // Native ACP server: `gemini --skip-trust --acp`.
+    acp: true
+  }
+};
+function getEnabledAgents() {
+  return Object.values(AGENT_REGISTRY).filter((m) => m.enabled);
+}
+function getAgent(id) {
+  const meta = AGENT_REGISTRY[id];
+  if (!meta) throw new Error(`Unknown agent id: ${id}`);
+  return meta;
+}
+function isKnownAgentId(id) {
+  return id in AGENT_REGISTRY;
+}
+
+// src/agents/identity.ts
+var HOUSE_AGENT_ID = "house-codeagent-cloud";
+var HOUSE_AGENT_PROVIDER = "codeagent_cloud";
+var HOUSE_AGENT_NAME = "CodeAgent Cloud";
+var HOUSE_AGENT_VENDOR = "CodeAgent";
+var HOUSE_AGENT_SUBTITLE = "Included \u2014 no setup";
+var LINKED_AGENT_IDS = [
+  "claude_code",
+  "codex",
+  "cursor",
+  "aider",
+  "coderabbit",
+  "gemini",
+  HOUSE_AGENT_ID
+];
+function isLinkedAgentId(value) {
+  return LINKED_AGENT_IDS.includes(value);
+}
+var PUBLIC_TO_INTERNAL = {
+  claude_code: "claude",
+  // CLI-side extra: self-hosted deploy payloads may carry the internal id.
+  claude: "claude",
+  codex: "codex",
+  // CLI-side extra: copilot has no public LinkedAgentId (backend doesn't
+  // expose it) but the self-hosted path accepts it.
+  copilot: "copilot",
+  cursor: "cursor",
+  aider: "aider",
+  coderabbit: "coderabbit",
+  gemini: "gemini",
+  // The house agent runs Claude Code under the hood (pointed at the
+  // MiniMax proxy). Its internal runtime is therefore `claude`.
+  [HOUSE_AGENT_ID]: "claude"
+};
+var INTERNAL_TO_PUBLIC = {
+  claude: "claude_code",
+  codex: "codex",
+  cursor: "cursor",
+  aider: "aider",
+  coderabbit: "coderabbit",
+  gemini: "gemini"
+};
+function isPublicToInternalKey(v) {
+  return Object.prototype.hasOwnProperty.call(PUBLIC_TO_INTERNAL, v);
+}
+function publicToInternal(publicId) {
+  return isPublicToInternalKey(publicId) ? PUBLIC_TO_INTERNAL[publicId] : null;
+}
+function internalToPublic(internal) {
+  return INTERNAL_TO_PUBLIC[internal] ?? null;
+}
+var TERMINAL_AGENT_PREFIX = "__terminal__:";
+var AGENT_ID_ALIASES = {
+  claude_code: "claude",
+  "claude-code": "claude",
+  "anthropic.claude-code": "claude",
+  "anthropics.claude": "claude",
+  "anthropic.claude-ce": "claude",
+  "anthropic.claude": "claude",
+  "com.anthropic.claudecode": "claude",
+  "com.anthropic.claude": "claude",
+  "openai.chatgpt": "codex",
+  "coderabbitai.coderabbit-vscode": "coderabbit"
+};
+function normalizeAgentId(raw) {
+  const value = (raw ?? "").trim().toLowerCase();
+  if (!value) return null;
+  if (isKnownAgentId(value)) return value;
+  const unprefixed = value.startsWith(TERMINAL_AGENT_PREFIX) ? value.slice(TERMINAL_AGENT_PREFIX.length) : value;
+  if (isKnownAgentId(unprefixed)) return unprefixed;
+  return AGENT_ID_ALIASES[unprefixed] ?? null;
+}
+function headroomKindFor(agentId) {
+  const normalized = (agentId ?? "").toLowerCase().replace(/[_-]/g, "");
+  if (!normalized) return null;
+  for (const meta of Object.values(AGENT_REGISTRY)) {
+    if (meta.headroomKind !== void 0 && normalized.startsWith(meta.id)) {
+      return meta.headroomKind;
+    }
+  }
+  return null;
+}
+function isHeadroomWrappable(agentId) {
+  return headroomKindFor(agentId) !== null;
+}
+
+// src/api-url.ts
+var DEFAULT_API_BASE_URL = "https://api.codeagent-mobile.com";
+var DEV_API_BASE_URL = "https://dev-api.codeagent-mobile.com";
+function resolveApiBaseUrl() {
+  const env = globalThis.process?.env;
+  const explicit = env?.CODEAM_API_URL?.trim();
+  if (explicit) return explicit;
+  const testFlag = env?.CODEAM_TEST_MODE?.trim();
+  if (testFlag === "1" || testFlag?.toLowerCase() === "true") return DEV_API_BASE_URL;
+  return DEFAULT_API_BASE_URL;
+}
+
+// src/headroom/manifest.ts
+var HEADROOM_PROXY_PORT = 8787;
+var HEADROOM_BACKEND_ENV = {
+  HEADROOM_KOMPRESS_BACKEND: "onnx_cpu"
+};
+var HEADROOM_PIP_COMPANIONS = [
+  "fastapi",
+  "uvicorn",
+  "httpx[http2]",
+  "websockets",
+  "zstandard"
+];
+var HEADROOM_EXTRAS_BY_SURFACE = {
+  codespace: ["proxy", "code"],
+  selfHosted: ["proxy", "code"],
+  onDemand: ["proxy", "code", "image"]
+};
+function headroomPipPackage(extras) {
+  return `headroom-ai[${extras.join(",")}]`;
+}
+var HEADROOM_MODELS = [
+  {
+    repo: "chopratejas/kompress-v2-base",
+    allowPatterns: ["*.json", "onnx/*.onnx", "kompress-int8-wo.onnx"]
+  },
+  {
+    repo: "answerdotai/ModernBERT-base",
+    allowPatterns: ["*.json", "tokenizer*", "*.txt", "vocab*", "merges*"]
+  }
+];
+function headroomSnapshotDownloadLine(model, opts = {}) {
+  const sep = opts.spaceAfterComma ? ", " : ",";
+  const patterns = model.allowPatterns.map((p) => `"${p}"`).join(sep);
+  return `snapshot_download("${model.repo}", allow_patterns=[${patterns}])`;
+}
+function headroomModelPredownloadScript(opts = {}) {
+  return [
+    "from huggingface_hub import snapshot_download",
+    ...HEADROOM_MODELS.map((m) => headroomSnapshotDownloadLine(m, opts))
+  ].join("\n");
+}
+
+// src/types/events.ts
+var USER_EVENTS = {
+  PAIRED_SESSION_STATUS: "paired_session_status",
+  PAIRED_SESSION_ADDED: "paired_session_added",
+  PAIRED_SESSION_REMOVED: "paired_session_removed",
+  PAIRED_SESSION_BRANCH_CHANGED: "paired_session_branch_changed",
+  SHARED_WITH_ME_ADDED: "shared_with_me_added",
+  SHARED_WITH_ME_REVOKED: "shared_with_me_revoked",
+  USAGE_CHANGED: "usage_changed",
+  TASK_DONE: "task_done",
+  HUNK_PENDING_REVIEW_ADDED: "hunk_pending_review_added",
+  HUNK_REVIEW_RESOLVED: "hunk_review_resolved",
+  FILE_CHANGED: "file_changed",
+  FILES_BATCH_CHANGED: "files_batch_changed",
+  AGENT_STREAMING_CHUNK: "agent_streaming_chunk",
+  AGENT_AWAITING_ANSWER: "agent_awaiting_answer",
+  AWAITING_INPUT_ADDED: "awaiting_input_added",
+  AGENT_ANSWER_RESOLVED: "agent_answer_resolved",
+  TEMPLATE_ADDED: "template_added",
+  TEMPLATE_REMOVED: "template_removed",
+  TEMPLATE_UPDATED: "template_updated",
+  AGENT_TASK_DISPATCHED: "agent_task_dispatched",
+  AGENT_TASK_COMPLETED: "agent_task_completed",
+  LINKED_AGENT_ADDED: "linked_agent_added",
+  QUOTA_REACHED: "quota_reached",
+  LINKED_AGENT_LINK_FAILED: "linked_agent_link_failed",
+  CODESPACE_AGENT_INSTALLED: "codespace_agent_installed",
+  AGENT_CREDENTIALS_REFRESHED: "agent_credentials_refreshed",
+  CREDENTIAL_INVALID: "credential_invalid",
+  CODESPACE_WAKING: "codespace_waking",
+  CODESPACE_BILLING_BLOCKED: "codespace_billing_blocked",
+  COST_SAVING_UPDATED: "cost_saving_updated",
+  COMMAND_COMPLETED: "command_completed",
+  AI_SUMMARY_PENDING: "ai_summary_pending",
+  AI_SUMMARY_READY: "ai_summary_ready",
+  AI_INSIGHT_PENDING: "ai_insight_pending",
+  AI_INSIGHT_READY: "ai_insight_ready",
+  PUSH_TOKEN_INVALIDATED: "push_token_invalidated",
+  PREVIEW_DETECTION_PENDING: "preview_detection_pending",
+  PREVIEW_DETECTION_READY: "preview_detection_ready",
+  PREVIEW_STARTING: "preview_starting",
+  PREVIEW_READY: "preview_ready",
+  PREVIEW_STOPPED: "preview_stopped",
+  PREVIEW_ERROR: "preview_error",
+  PREVIEW_PROGRESS: "preview_progress",
+  BEADS_STATE_CHANGED: "beads_state_changed",
+  BEADS_PROVISIONING: "beads_provisioning",
+  BEADS_TEAM_MEMORY_CHANGED: "beads_team_memory_changed",
+  AUDIT_EVENT_ADDED: "audit_event_added",
+  SELF_HOSTED_HOST_ADDED: "self_hosted_host_added",
+  SELF_HOSTED_HOST_STATUS: "self_hosted_host_status",
+  SELF_HOSTED_HOST_REMOVED: "self_hosted_host_removed",
+  SELF_HOSTED_HOST_TELEMETRY: "self_hosted_host_telemetry",
+  SELF_HOSTED_HOST_METRICS: "self_hosted_host_metrics",
+  SELF_HOSTED_HOST_SESSIONS: "self_hosted_host_sessions",
+  SELF_HOSTED_DEPLOY_PROGRESS: "self_hosted_deploy_progress",
+  REFERRAL_REWARD_EARNED: "referral_reward_earned",
+  HEADROOM_PROGRESS: "headroom_progress",
+  HEADROOM_STATUS: "headroom_status",
+  BEADS_STATUS: "beads_status",
+  LINKED_AGENT_HEADROOM_BUDGET_UPDATED: "linked_agent_headroom_budget_updated",
+  CLI_UPDATE_AVAILABLE: "cli_update_available",
+  AGENT_INSTALL_PROGRESS: "agent_install_progress",
+  AGENT_INSTALL_FAILED: "agent_install_failed",
+  CLI_UPDATE_PROGRESS: "cli_update_progress",
+  CLI_UPDATE_FAILED: "cli_update_failed"
+};
+
+// src/preview-prompts.ts
+var PREVIEW_DETECT_PROMPT = `
+Analyze the project in the current working directory and return how to start
+its development server for in-app preview.
+
+Read package.json, Procfile, Dockerfile, docker-compose.yml, manage.py, app.json,
+mix.exs, Cargo.toml, go.mod, requirements.txt, Gemfile, and any other framework
+markers you find at depth <= 2.
+
+Return ONLY a JSON object on stdout (no prose, no markdown fences):
+
+{
+  "framework": "<name, or 'unsupported'>",
+  "command": "<executable>",
+  "args": ["..."],
+  "port": <number>,
+  "ready_pattern": "<regex matching the server-ready stdout line>",
+  "env": { "HOST": "0.0.0.0" },
+  "setup_commands": [{ "cmd": "<executable>", "args": ["..."] }],
+  "notes": "<one-line caveat or null>"
+}
+
+Rules:
+- Pick the script the developer would run locally to see the app (typically "dev", "start", "serve").
+- Prefer binding to 0.0.0.0 \u2014 most frameworks default to localhost which the tunnel cannot reach.
+- For Expo: framework="Expo", command="npx", args=["expo","start","--tunnel"], port=8081, notes="Scan QR with Expo Go".
+- If no dev server applies (CLI library, lambda, batch script): {"framework":"unsupported","notes":"<reason>"}.
+
+CRITICAL \u2014 setup_commands:
+- DO NOT include an install command (npm install, pnpm install, yarn install,
+  yarn, bun install) in setup_commands. A lockfile-aware pre-flight installer
+  runs BEFORE setup_commands and picks the correct package manager from the
+  lockfile present (pnpm-lock.yaml -> pnpm, yarn.lock -> yarn, bun.lockb -> bun,
+  else npm). Emitting an install here either duplicates that work or, worse,
+  uses the WRONG package manager on top of node_modules just populated by the
+  pre-flight, which crashes (e.g. npm errors with "Cannot read properties of
+  null (reading 'matches')" when run over pnpm's .pnpm/ layout).
+- ONLY include setup_commands for genuinely non-install work the project needs
+  before its dev server can boot: prisma generate, codegen, prebuild scripts,
+  database migrations against a local SQLite, etc.
+- Each setup_commands entry MUST be an object {"cmd": "...", "args": ["..."]} \u2014
+  e.g. {"cmd": "npx", "args": ["prisma", "generate"]}. NOT a bare string.
+- For most projects, setup_commands should be an empty array [].
+
+OUTPUT JSON ONLY. NO MARKDOWN. NO COMMENTARY.
+`.trim();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_REGISTRY,
+  DEFAULT_API_BASE_URL,
+  DEV_API_BASE_URL,
+  HEADROOM_BACKEND_ENV,
+  HEADROOM_EXTRAS_BY_SURFACE,
+  HEADROOM_MODELS,
+  HEADROOM_PIP_COMPANIONS,
+  HEADROOM_PROXY_PORT,
+  HEARTBEAT_INTERVAL_MS_DEFAULT,
+  HOUSE_AGENT_ID,
+  HOUSE_AGENT_NAME,
+  HOUSE_AGENT_PROVIDER,
+  HOUSE_AGENT_SUBTITLE,
+  HOUSE_AGENT_VENDOR,
+  INTERNAL_TO_PUBLIC,
+  LINKED_AGENT_IDS,
+  MODEL_CONTEXT_WINDOW,
+  MODEL_PRICING,
+  OBSERVER_BRIDGE_PORT,
+  PREVIEW_DETECT_PROMPT,
+  PROTOCOL_VERSION,
+  PUBLIC_TO_INTERNAL,
+  SSE_SOCKET_TIMEOUT_MS,
+  TERMINAL_AGENT_PREFIX,
+  USER_EVENTS,
+  getAgent,
+  getContextWindow,
+  getEnabledAgents,
+  getPricing,
+  headroomKindFor,
+  headroomModelPredownloadScript,
+  headroomPipPackage,
+  headroomSnapshotDownloadLine,
+  internalToPublic,
+  isHeadroomWrappable,
+  isKnownAgentId,
+  isKnownModel,
+  isLinkedAgentId,
+  normalizeAgentId,
+  publicToInternal,
+  renderToLines,
+  resolveApiBaseUrl,
+  toRemoteCommand
+});
+//# sourceMappingURL=index.js.map