@leuria/cli 0.1.0

package/dist/chunk-BXSAYWR3.js

@@ -0,0 +1,3433 @@
+// src/acp/registry.ts
+var REGISTRY_URL = process.env.ACP_REGISTRY_URL ?? "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+function platformKey() {
+  const os = { darwin: "darwin", linux: "linux", win32: "windows" };
+  const arch = { arm64: "aarch64", x64: "x86_64" };
+  return `${os[process.platform] ?? process.platform}-${arch[process.arch] ?? process.arch}`;
+}
+var TTL_MS = 10 * 6e4;
+var FAIL_TTL_MS = 6e4;
+var cache = null;
+var failedAt = 0;
+async function fetchRegistry() {
+  const now = Date.now();
+  if (cache && now - cache.at < TTL_MS) return cache.agents;
+  if (now - failedAt < FAIL_TTL_MS) return [];
+  try {
+    const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(5e3) });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const payload = await res.json();
+    const agents = (payload.agents ?? []).filter(
+      (a) => typeof a === "object" && a !== null && typeof a.id === "string" && typeof a.distribution === "object"
+    );
+    cache = { at: now, agents };
+    failedAt = 0;
+    return agents;
+  } catch {
+    failedAt = now;
+    return [];
+  }
+}
+var ALIASES = {
+  "claude-acp": ["claude-code-acp"],
+  "claude-code-acp": ["claude-acp"]
+};
+async function getRegistryEntry(id) {
+  const agents = await fetchRegistry();
+  const ids = [id, ...ALIASES[id] ?? []];
+  for (const candidate of ids) {
+    const entry = agents.find((a) => a.id === candidate);
+    if (entry) return entry;
+  }
+  return null;
+}
+
+// src/home.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_PORT = 19570;
+var DEFAULT_AGENT = "claude-acp";
+function parseEmbedChoice(value) {
+  if (value === "off") return "off";
+  const { provider, model } = value ?? {};
+  return typeof provider === "string" && typeof model === "string" && provider && model ? { provider, model } : void 0;
+}
+function leuriaHome() {
+  return process.env.LEURIA_HOME ?? join(homedir(), ".leuria");
+}
+function homePath(...parts) {
+  return join(leuriaHome(), ...parts);
+}
+function loadConfig() {
+  const stored = readJson(homePath("config.json")) ?? {};
+  return {
+    port: typeof stored.port === "number" ? stored.port : DEFAULT_PORT,
+    agent: typeof stored.agent === "string" && stored.agent ? stored.agent : DEFAULT_AGENT,
+    ...Array.isArray(stored.ais) ? { ais: stored.ais.filter((a) => typeof a === "string") } : {},
+    ...stored.models && typeof stored.models === "object" ? { models: stored.models } : {},
+    ...stored.ready && typeof stored.ready === "object" ? { ready: stored.ready } : {},
+    ...parseEmbedChoice(stored.embed) ? { embed: parseEmbedChoice(stored.embed) } : {}
+  };
+}
+function isKnownReady(id) {
+  return Boolean(loadConfig().ready?.[id]);
+}
+function rememberReady(id, ok) {
+  const config = loadConfig();
+  const ready = { ...config.ready };
+  const last = ready[id];
+  if (ok) {
+    if (last && Date.now() - Date.parse(last) < 864e5) return;
+    ready[id] = (/* @__PURE__ */ new Date()).toISOString();
+  } else {
+    if (!last) return;
+    delete ready[id];
+  }
+  saveConfig({ ...config, ready });
+}
+function saveConfig(config) {
+  writeJson(homePath("config.json"), config);
+}
+function readJson(path2) {
+  if (!existsSync(path2)) return null;
+  try {
+    return JSON.parse(readFileSync(path2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJson(path2, data) {
+  mkdirSync(leuriaHome(), { recursive: true, mode: 448 });
+  const tmp = `${path2}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, { mode: 384 });
+  renameSync(tmp, path2);
+  try {
+    chmodSync(path2, 384);
+  } catch {
+  }
+}
+
+// src/llm/providers.ts
+function parseParams(value) {
+  if (typeof value !== "string") return void 0;
+  const moe = /^(\d+)x(\d+(?:\.\d+)?)\s*B$/i.exec(value.trim());
+  if (moe) return Number(moe[1]) * Number(moe[2]);
+  const plain = /^(\d+(?:\.\d+)?)\s*([BM])$/i.exec(value.trim());
+  if (!plain) return void 0;
+  return plain[2].toUpperCase() === "M" ? Number(plain[1]) / 1e3 : Number(plain[1]);
+}
+var BUILTIN = [
+  { id: "lmstudio", kind: "lmstudio", name: "LM Studio", baseUrl: "http://127.0.0.1:1234/v1" },
+  { id: "ollama", kind: "ollama", name: "Ollama", baseUrl: "http://127.0.0.1:11434/v1" }
+];
+var EMBEDDING = /embed|e5-|bge-|gte-|nomic-embed|jina-embed|mxbai-embed/i;
+function isLlmId(id) {
+  return id.startsWith("llm:");
+}
+function llmId(providerId, model) {
+  return `llm:${providerId}/${model}`;
+}
+function parseLlmId(id) {
+  if (!isLlmId(id)) return null;
+  const rest = id.slice(4);
+  const slash = rest.indexOf("/");
+  if (slash === -1) return rest ? { providerId: rest } : null;
+  if (slash === 0 || slash === rest.length - 1) return null;
+  return { providerId: rest.slice(0, slash), model: rest.slice(slash + 1) };
+}
+function defaultModel(models) {
+  return (models.find((m) => m.loaded) ?? models.find((m) => !m.remote) ?? models[0])?.id;
+}
+function path() {
+  return homePath("providers.json");
+}
+function listProviders() {
+  const saved = readJson(path())?.providers ?? [];
+  const ids = new Set(saved.map((p) => p.id));
+  return [...BUILTIN.filter((b) => !ids.has(b.id)), ...saved];
+}
+function getProvider(id) {
+  return listProviders().find((p) => p.id === id);
+}
+function saveProvider(input) {
+  const baseUrl = normalizeBaseUrl(input.baseUrl);
+  const id = input.id ?? slug(input.name);
+  if (!id) throw new Error("A name is required");
+  const provider = {
+    id,
+    kind: input.kind ?? "openai",
+    name: input.name.trim(),
+    baseUrl,
+    ...input.apiKey?.trim() ? { apiKey: input.apiKey.trim() } : {}
+  };
+  const saved = (readJson(path())?.providers ?? []).filter((p) => p.id !== id);
+  writeJson(path(), { providers: [...saved, provider] });
+  return provider;
+}
+function removeProvider(id) {
+  const saved = readJson(path())?.providers ?? [];
+  const kept = saved.filter((p) => p.id !== id);
+  if (kept.length === saved.length) return false;
+  writeJson(path(), { providers: kept });
+  return true;
+}
+function normalizeBaseUrl(url) {
+  let value = url.trim().replace(/\/+$/, "");
+  if (!/^https?:\/\//i.test(value)) value = `http://${value}`;
+  const parsed = new URL(value);
+  if (!/\/v\d+[a-z0-9]*(\/|$)/.test(parsed.pathname)) parsed.pathname = `${parsed.pathname.replace(/\/+$/, "")}/v1`;
+  return parsed.toString().replace(/\/+$/, "");
+}
+function slug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function authHeaders(provider) {
+  return provider.apiKey ? { Authorization: `Bearer ${provider.apiKey}` } : {};
+}
+async function listModels(provider, timeoutMs = 3e3) {
+  if (provider.kind === "lmstudio") {
+    const root = provider.baseUrl.replace(/\/v\d+$/, "");
+    const native = await fetch(`${root}/api/v1/models`, { headers: authHeaders(provider), signal: AbortSignal.timeout(timeoutMs) }).then((r) => r.ok ? r.json() : null).catch(() => null);
+    if (native?.models) {
+      return native.models.filter((m) => m.type === "llm").map((m) => ({
+        id: m.key,
+        loaded: (m.loaded_instances?.length ?? 0) > 0,
+        meta: {
+          tools: m.capabilities?.trained_for_tool_use,
+          images: m.capabilities?.vision,
+          context: m.max_context_length,
+          params: parseParams(m.params_string)
+        }
+      }));
+    }
+  }
+  let remote = /* @__PURE__ */ new Set();
+  const sizes = /* @__PURE__ */ new Map();
+  if (provider.kind === "ollama") {
+    const root = provider.baseUrl.replace(/\/v\d+$/, "");
+    const tags = await fetch(`${root}/api/tags`, { signal: AbortSignal.timeout(timeoutMs) }).then((r) => r.ok ? r.json() : null).catch(() => null);
+    remote = new Set((tags?.models ?? []).filter((m) => m.remote_host).map((m) => m.name));
+    for (const m of tags?.models ?? []) {
+      const params = parseParams(m.details?.parameter_size);
+      if (params) sizes.set(m.name, params);
+    }
+  }
+  let res;
+  try {
+    res = await fetch(`${provider.baseUrl}/models`, { headers: authHeaders(provider), signal: AbortSignal.timeout(timeoutMs) });
+  } catch {
+    throw new Error(unreachable(provider));
+  }
+  if (res.status === 401 || res.status === 403) throw new Error(`${provider.name} refused the API key.`);
+  if (res.status === 404) throw new Error(`Nothing answered at ${provider.baseUrl}. Check the address, then try again.`);
+  if (!res.ok) throw new Error(`${provider.name} had a problem. Try again in a moment.`);
+  const body = await res.json().catch(() => null);
+  if (!Array.isArray(body?.data)) throw new Error(`That address doesn't look like an AI service. Check it, then try again.`);
+  return body.data.filter((m) => typeof m.id === "string").filter((m) => m.type !== "embedding" && !EMBEDDING.test(m.id)).map((m) => ({
+    id: m.id,
+    ...remote.has(m.id) ? { remote: true } : {},
+    ...sizes.has(m.id) ? { meta: { params: sizes.get(m.id) } } : {}
+  }));
+}
+function unreachable(provider) {
+  if (provider.kind === "lmstudio") return "Couldn't reach LM Studio. Open it and start its local server, then try again.";
+  if (provider.kind === "ollama") return "Couldn't reach Ollama. Open it, then try again.";
+  return `Couldn't reach ${provider.name} at ${provider.baseUrl}.`;
+}
+async function detectLlms() {
+  return Promise.all(
+    listProviders().map(async (provider) => {
+      try {
+        return { provider, running: true, models: await listModels(provider, 1500) };
+      } catch (error) {
+        return { provider, running: false, models: [], error: error instanceof Error ? error.message : String(error) };
+      }
+    })
+  );
+}
+function llmDisplayName(id) {
+  const parsed = parseLlmId(id);
+  if (!parsed) return id;
+  const provider = getProvider(parsed.providerId);
+  if (!parsed.model) return provider?.name ?? parsed.providerId;
+  const model = parsed.model.split("/").pop() ?? parsed.model;
+  return `${model} \xB7 ${provider?.name ?? parsed.providerId}`;
+}
+
+// src/policy.ts
+var WEBMCP_SERVER_NAME = "webmcp";
+var ALLOWED_TOOL_PREFIXES = [`mcp__${WEBMCP_SERVER_NAME}__`, `mcp.${WEBMCP_SERVER_NAME}.`];
+var BUILT_IN_TOOLS = [
+  "Agent",
+  "Bash",
+  "BashOutput",
+  "Edit",
+  "ExitPlanMode",
+  "Glob",
+  "Grep",
+  "KillShell",
+  "MultiEdit",
+  "NotebookEdit",
+  "Read",
+  "Task",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch",
+  "Write"
+];
+function buildSessionMeta(config = {}) {
+  const options = {
+    tools: [],
+    allowedTools: [`mcp__${WEBMCP_SERVER_NAME}`],
+    disallowedTools: BUILT_IN_TOOLS,
+    settingSources: [],
+    strictMcpConfig: true,
+    allowDangerouslySkipPermissions: false
+  };
+  if (config.model) options.model = config.model;
+  if (config.maxTurns) options.maxTurns = config.maxTurns;
+  const meta = { claudeCode: { options } };
+  if (config.systemPrompt) meta.systemPrompt = config.systemPrompt;
+  return meta;
+}
+function decidePermission(params) {
+  const p = params ?? {};
+  const toolName = extractToolName(p);
+  const allow = ALLOWED_TOOL_PREFIXES.some(
+    (prefix) => toolName.startsWith(prefix)
+  );
+  const options = Array.isArray(p.options) ? p.options : [];
+  const wanted = allow ? ["allow_once", "allow_always"] : ["reject_once", "reject_always"];
+  const option = options.find(
+    (o) => typeof o.kind === "string" && wanted.includes(o.kind)
+  );
+  if (option && typeof option.optionId === "string") {
+    return {
+      allow,
+      toolName,
+      response: {
+        outcome: { outcome: "selected", optionId: option.optionId }
+      }
+    };
+  }
+  return {
+    allow: false,
+    toolName,
+    response: { outcome: { outcome: "cancelled" } }
+  };
+}
+function extractToolName(p) {
+  const toolCall = p.toolCall ?? {};
+  const meta = toolCall._meta ?? {};
+  const claudeCode = meta.claudeCode ?? {};
+  const candidates = [claudeCode.toolName, p.toolName, toolCall.title];
+  const name = candidates.find(
+    (c) => typeof c === "string" && c.length > 0
+  );
+  return name ?? "unknown";
+}
+
+// src/agents.ts
+import { execFile as execFile2 } from "child_process";
+import { createHash } from "crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, join as join3 } from "path";
+import { promisify as promisify2 } from "util";
+
+// src/codex.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var ENABLED_FEATURES = /* @__PURE__ */ new Set(["code_mode_host"]);
+function codexHome() {
+  return homePath("codex");
+}
+async function prepareCodexHome(agent) {
+  const home = codexHome();
+  mkdirSync2(home, { recursive: true, mode: 448 });
+  const launcher = join2(agent.dir, "node_modules", "@openai", "codex", "bin", "codex.js");
+  const stamp = join2(home, ".leuria-config-for");
+  if (existsSync2(stamp) && readFileSync2(stamp, "utf-8") === agent.version && existsSync2(join2(home, "config.toml"))) return;
+  const { stdout } = await execFileAsync(process.execPath, [launcher, "features", "list"], {
+    env: { ...process.env, CODEX_HOME: home, BUN_BE_BUN: "1" },
+    timeout: 6e4
+  });
+  const features = stdout.split("\n").map((line) => line.trim().split(/\s+/)[0] ?? "").filter((name) => /^[a-z0-9_]+$/.test(name));
+  if (features.length < 10) throw new Error("Could not read Codex's feature list");
+  const lines = [
+    "# Generated by Leuria for its locked-down Codex. Do not edit: it is rewritten on upgrade.",
+    'sandbox_mode = "read-only"',
+    'approval_policy = "never"',
+    'web_search = "disabled"',
+    "",
+    "[features]",
+    ...features.map((name) => `${name} = ${ENABLED_FEATURES.has(name)}`),
+    ""
+  ];
+  writeFileSync2(join2(home, "config.toml"), lines.join("\n"), { mode: 384 });
+  writeFileSync2(stamp, agent.version);
+}
+var codexProfile = {
+  home: codexHome,
+  prepare: prepareCodexHome,
+  configure: (setup) => ({
+    env: {
+      // Leuria's own Codex home: its sign-in (through ACP authenticate) lands here.
+      CODEX_HOME: codexHome(),
+      HOME: setup.sandbox,
+      USERPROFILE: setup.sandbox,
+      INITIAL_AGENT_MODE: "read-only",
+      CODEX_CONFIG: JSON.stringify({
+        mcp_servers: {
+          [WEBMCP_SERVER_NAME]: {
+            url: setup.mcpUrl,
+            http_headers: { Authorization: `Bearer ${setup.mcpToken}` },
+            default_tools_approval_mode: "approve"
+          }
+        },
+        ...setup.systemPrompt ? { developer_instructions: setup.systemPrompt } : {}
+      })
+    },
+    // Declared through CODEX_CONFIG above, with approval; not through ACP.
+    mcpServers: [],
+    meta: {}
+  })
+};
+
+// src/gemini.ts
+import { mkdirSync as mkdirSync3 } from "fs";
+function geminiHome() {
+  return homePath("gemini");
+}
+var geminiProfile = {
+  home: geminiHome,
+  configure: () => {
+    mkdirSync3(geminiHome(), { recursive: true, mode: 448 });
+    return { env: { GEMINI_CLI_HOME: geminiHome(), GEMINI_FORCE_FILE_STORAGE: "true" } };
+  }
+};
+
+// src/profiles.ts
+var PROFILES = {
+  "codex-acp": codexProfile,
+  gemini: geminiProfile
+};
+function profileFor(id) {
+  return PROFILES[id];
+}
+
+// src/agents.ts
+var execFileAsync2 = promisify2(execFile2);
+var MANIFEST = "leuria-agent.json";
+function agentsDir() {
+  return homePath("agents");
+}
+function installedAgent(id) {
+  const root = agentsDir();
+  if (!existsSync3(root)) return null;
+  const versions = readdirSync(root).filter((name) => name.startsWith(`${id}@`) && existsSync3(join3(root, name, MANIFEST))).sort(compareVersions);
+  const latest = versions[versions.length - 1];
+  if (!latest) return null;
+  const agent = JSON.parse(readFileSync3(join3(root, latest, MANIFEST), "utf-8"));
+  return { ...agent, launchArgs: agent.launchArgs ?? [] };
+}
+function ensureAgent(id, options = {}) {
+  const key = `${id}:${options.update ? "update" : "any"}`;
+  const running = installing.get(key);
+  if (running) return running;
+  const work = ensureAgentOnce(id, options).finally(() => installing.delete(key));
+  installing.set(key, work);
+  return work;
+}
+var installing = /* @__PURE__ */ new Map();
+async function ensureAgentOnce(id, options) {
+  const installed = installedAgent(id);
+  if (installed && !options.update) return installed;
+  const entry = await getRegistryEntry(id);
+  if (!entry) {
+    if (installed) return installed;
+    throw new Error(`"${id}" is not in the ACP registry (or the registry is unreachable). Run \`leuria agents\` to list agents.`);
+  }
+  if (installed?.version === entry.version) return installed;
+  options.onProgress?.(`Installing ${entry.name} ${entry.version} from the ACP registry\u2026`);
+  const agent = await install(entry);
+  await profileFor(id)?.prepare?.(agent);
+  return agent;
+}
+async function resolveAgentCommand(id, model) {
+  if (isLlmId(id)) {
+    const parsed = parseLlmId(id);
+    const provider = parsed && getProvider(parsed.providerId);
+    if (!parsed || !provider) throw new Error(`Unknown AI "${id}". Choose it again in Leuria.`);
+    const chosen = parsed.model ?? model ?? loadConfig().models?.[id] ?? defaultModel(await listModels(provider));
+    if (!chosen) throw new Error(`${provider.name} has no model to answer with. Open it and load one.`);
+    return { id, command: "", args: [], llm: { provider, model: chosen }, name: llmDisplayName(id) };
+  }
+  const agent = await ensureAgent(id);
+  return {
+    id,
+    command: agent.command,
+    args: [...agent.launchArgs, ...agent.args],
+    env: agent.env,
+    model: model ?? loadConfig().models?.[id],
+    name: agent.name,
+    configure: profileFor(id)?.configure
+  };
+}
+function resolveSiteAgent(grant, defaultAgent) {
+  const id = grant?.agent ?? defaultAgent;
+  return resolveAgentCommand(id, grant?.model?.agent === id ? grant.model.id : void 0);
+}
+var DISPLAY_NAMES = {
+  "codex-acp": "ChatGPT (Codex)",
+  "claude-acp": "Claude",
+  gemini: "Gemini",
+  "github-copilot-cli": "GitHub Copilot"
+};
+function agentName(id) {
+  if (isLlmId(id)) return llmDisplayName(id);
+  return DISPLAY_NAMES[id] ?? installedAgent(id)?.name ?? id;
+}
+function resetAgent(id) {
+  if (isLlmId(id)) return;
+  const home = profileFor(id)?.home?.();
+  if (home) rmSync(home, { recursive: true, force: true });
+  const root = agentsDir();
+  if (!existsSync3(root)) return;
+  for (const name of readdirSync(root)) {
+    if (name.startsWith(`${id}@`)) rmSync(join3(root, name), { recursive: true, force: true });
+  }
+}
+function isAvailable(id) {
+  if (isLlmId(id)) {
+    const parsed = parseLlmId(id);
+    return Boolean(parsed && getProvider(parsed.providerId));
+  }
+  return installedAgent(id) !== null;
+}
+async function listAgents() {
+  return (await fetchRegistry()).map((entry) => ({ ...entry, installed: installedAgent(entry.id)?.version }));
+}
+async function install(entry) {
+  const dir = join3(agentsDir(), `${entry.id}@${entry.version}`);
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync4(dir, { recursive: true });
+  const d = entry.distribution;
+  const binary = d.binary?.[platformKey()];
+  let launch;
+  try {
+    if (d.npx) launch = await installPackage(dir, d.npx.package, d.npx.args ?? [], d.npx.env ?? {});
+    else if (binary) launch = await installBinary(dir, binary);
+    else if (d.uvx) launch = { command: "uvx", launchArgs: [d.uvx.package], args: d.uvx.args ?? [], env: d.uvx.env ?? {} };
+    else throw new Error(`${entry.name} has no distribution for ${platformKey()}`);
+  } catch (error) {
+    rmSync(dir, { recursive: true, force: true });
+    throw error;
+  }
+  const agent = { id: entry.id, name: entry.name, version: entry.version, dir, ...launch };
+  writeFileSync3(join3(dir, MANIFEST), `${JSON.stringify(agent, null, 2)}
+`);
+  return agent;
+}
+async function installPackage(dir, spec, args, env) {
+  writeFileSync3(join3(dir, "package.json"), '{ "private": true }\n');
+  if (process.versions.bun) {
+    await execFileAsync2(process.execPath, ["add", spec], { cwd: dir, env: { ...process.env, BUN_BE_BUN: "1" }, timeout: 5 * 6e4 });
+  } else {
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    await execFileAsync2(npm, ["install", "--no-audit", "--no-fund", "--omit=dev", "--loglevel=error", spec], {
+      cwd: dir,
+      timeout: 5 * 6e4,
+      shell: process.platform === "win32"
+    });
+  }
+  const name = spec.lastIndexOf("@") > 0 ? spec.slice(0, spec.lastIndexOf("@")) : spec;
+  const pkgDir = join3(dir, "node_modules", ...name.split("/"));
+  const manifest = JSON.parse(readFileSync3(join3(pkgDir, "package.json"), "utf-8"));
+  const bins = typeof manifest.bin === "string" ? { [name]: manifest.bin } : manifest.bin ?? {};
+  const binName = Object.keys(bins).find((b) => name.endsWith(b)) ?? Object.keys(bins)[0];
+  if (!binName) throw new Error(`${spec} has no executable`);
+  const entry = join3(pkgDir, bins[binName]);
+  const isScript = /\.[cm]?js$/.test(entry) || /^#!.*\b(node|bun)\b/.test(readFileSync3(entry, "utf-8").slice(0, 100));
+  return isScript ? { command: process.execPath, launchArgs: [entry], args, env } : { command: entry, launchArgs: [], args, env };
+}
+async function installBinary(dir, target) {
+  const res = await fetch(target.archive, { signal: AbortSignal.timeout(5 * 6e4) });
+  if (!res.ok) throw new Error(`Download failed (${res.status}): ${target.archive}`);
+  const bytes = Buffer.from(await res.arrayBuffer());
+  if (target.sha256) {
+    const actual = createHash("sha256").update(bytes).digest("hex");
+    if (actual !== target.sha256.toLowerCase()) throw new Error(`Checksum mismatch for ${target.archive}`);
+  }
+  const name = new URL(target.archive).pathname.split("/").pop() ?? "archive";
+  const command = join3(dir, target.cmd.replace(/^\.\//, ""));
+  if (/\.zip$/i.test(name)) {
+    const file = join3(dir, name);
+    writeFileSync3(file, bytes);
+    if (process.platform === "linux") await execFileAsync2("unzip", ["-q", file, "-d", dir]);
+    else await execFileAsync2("tar", ["-xf", file, "-C", dir]);
+  } else if (/\.(tar\.gz|tgz|tar\.bz2|tbz2)$/i.test(name)) {
+    const file = join3(dir, name);
+    writeFileSync3(file, bytes);
+    await execFileAsync2("tar", ["-xf", file, "-C", dir]);
+  } else {
+    mkdirSync4(dirname(command), { recursive: true });
+    writeFileSync3(command, bytes);
+  }
+  if (!existsSync3(command)) throw new Error(`${target.cmd} not found in ${target.archive}`);
+  if (process.platform !== "win32") chmodSync2(command, 493);
+  return { command, launchArgs: [], args: target.args ?? [], env: target.env ?? {} };
+}
+function compareVersions(a, b) {
+  const parse = (s) => (s.split("@").pop() ?? "").split(/[.-]/).map((p) => /^\d+$/.test(p) ? Number(p) : p);
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x === y) continue;
+    if (typeof x === "number" && typeof y === "number") return x - y;
+    return String(x) < String(y) ? -1 : 1;
+  }
+  return 0;
+}
+
+// src/version.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+// src/auth.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join5 } from "path";
+
+// src/acp/acp-client.ts
+import { spawn } from "child_process";
+import { Readable, Writable } from "stream";
+var rawParams = {
+  // biome-ignore lint/suspicious/noExplicitAny: ACP payloads are untyped here
+  parse: (value) => value
+};
+function readModels(source) {
+  const configOptions = Array.isArray(source?.configOptions) ? source.configOptions : [];
+  const option = configOptions.find((o) => o?.category === "model" && o?.type !== "boolean" && Array.isArray(o?.options));
+  if (option) {
+    const flat = option.options.flatMap((o) => Array.isArray(o?.options) ? o.options : [o]);
+    return {
+      configId: String(option.id),
+      current: typeof option.currentValue === "string" ? option.currentValue : void 0,
+      options: flat.filter((o) => typeof o?.value === "string").map((o) => ({ id: o.value, name: String(o.name ?? o.value), ...o.description ? { description: String(o.description) } : {} }))
+    };
+  }
+  const legacy = source?.models;
+  if (Array.isArray(legacy?.availableModels) && legacy.availableModels.length) {
+    return {
+      current: typeof legacy.currentModelId === "string" ? legacy.currentModelId : void 0,
+      options: legacy.availableModels.filter((m) => typeof m?.modelId === "string").map((m) => ({ id: m.modelId, name: String(m.name ?? m.modelId), ...m.description ? { description: String(m.description) } : {} }))
+    };
+  }
+  return null;
+}
+var REMOVED_ENV_VARS = ["CLAUDECODE"];
+var AUTH_REQUIRED = -32e3;
+function errorText(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object" && "message" in error) return String(error.message);
+  return String(error);
+}
+var AcpLiveSession = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  child = null;
+  // biome-ignore lint/suspicious/noExplicitAny: SDK connection type is internal
+  connection = null;
+  acpSessionId = null;
+  alive = false;
+  imagesSupported = false;
+  /** `initialize` result, once connected. */
+  info = null;
+  /** Models the agent offers, from `session/new` (and later updates). */
+  models = null;
+  get isAlive() {
+    return this.alive && this.child !== null && !this.child.killed;
+  }
+  /** Spawn the agent, initialize ACP and create a session. */
+  async start() {
+    const connected = await this.connect();
+    if (connected.error) return connected;
+    return this.newSession();
+  }
+  /** Spawn the agent and run `initialize`. */
+  async connect() {
+    const sdk = await import("@agentclientprotocol/sdk");
+    const env = { ...process.env, ...this.options.envVars };
+    for (const key of REMOVED_ENV_VARS) delete env[key];
+    if (process.versions.bun) env.BUN_BE_BUN = "1";
+    const child = spawn(this.options.command, this.options.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+      cwd: this.options.cwd,
+      shell: process.platform === "win32",
+      // Its own process group, so close() also stops what the agent starts
+      // (Gemini relaunches itself as a child process).
+      detached: process.platform !== "win32"
+    });
+    this.child = child;
+    child.on("error", (err) => this.options.onSpawnError?.(err));
+    child.stdin?.on("error", (err) => {
+      if (err.code !== "EPIPE" && err.code !== "ERR_STREAM_DESTROYED") {
+        this.options.onSpawnError?.(err);
+      }
+    });
+    child.on("exit", (code, signal) => {
+      this.alive = false;
+      this.options.onExit?.(code, signal);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) this.options.onStderr?.(text);
+    });
+    try {
+      const stream = sdk.ndJsonStream(
+        Writable.toWeb(child.stdin),
+        Readable.toWeb(child.stdout)
+      );
+      this.connection = this.buildClientApp(sdk).connect(stream);
+      const init = await this.connection.agent.request("initialize", {
+        protocolVersion: sdk.PROTOCOL_VERSION,
+        clientInfo: { name: "leuria", version: VERSION },
+        clientCapabilities: {
+          fs: { readTextFile: false, writeTextFile: false },
+          terminal: false,
+          auth: { terminal: this.options.terminalAuth === true }
+        }
+      });
+      this.imagesSupported = init?.agentCapabilities?.promptCapabilities?.image === true;
+      this.info = {
+        authMethods: init.authMethods ?? [],
+        agentCapabilities: init.agentCapabilities ?? {},
+        agentInfo: init.agentInfo
+      };
+      return {};
+    } catch (error) {
+      this.close();
+      return { error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  /** ACP `authenticate` with one of the advertised methods (the agent runs its own flow). */
+  async authenticate(methodId) {
+    if (!this.connection) return { error: "Not connected" };
+    try {
+      await this.connection.agent.request("authenticate", { methodId });
+      return {};
+    } catch (error) {
+      return { error: errorText(error) };
+    }
+  }
+  /** ACP `session/new`. An `auth_required` error means the visitor must sign in. */
+  async newSession() {
+    if (!this.connection) return { error: "Not connected" };
+    try {
+      const mcp = this.options.mcpServers;
+      const mcpCapabilities = this.info?.agentCapabilities.mcpCapabilities ?? {};
+      const session = await this.connection.agent.request("session/new", {
+        cwd: this.options.cwd,
+        mcpServers: typeof mcp === "function" ? mcp(mcpCapabilities) : mcp ?? [],
+        _meta: this.options.sessionMeta ?? buildSessionMeta(this.options.sessionConfig)
+      });
+      this.acpSessionId = session.sessionId;
+      this.alive = true;
+      this.models = readModels(session) ?? this.models;
+      const wanted = this.options.model;
+      if (wanted && wanted !== this.models?.current && this.models?.options.some((m) => m.id === wanted)) {
+        const set = await this.setModel(wanted);
+        if (set.error) this.options.onStderr?.(`could not switch to model ${wanted}: ${set.error}`);
+      }
+      return {};
+    } catch (error) {
+      const code = error?.code;
+      const text = errorText(error);
+      this.close();
+      const aboutSignIn = /auth|sign.?in|log.?in|api.?key|credential|unauthori[sz]ed/i.test(text);
+      return { error: text, authRequired: aboutSignIn || code === AUTH_REQUIRED && !text.trim() };
+    }
+  }
+  /** Switch the session's model: ACP v1 `session/set_config_option`, or the older `session/set_model`. */
+  async setModel(modelId) {
+    if (!this.connection || !this.acpSessionId) return { error: "No session" };
+    try {
+      if (this.models?.configId) {
+        const res = await this.connection.agent.request("session/set_config_option", {
+          sessionId: this.acpSessionId,
+          configId: this.models.configId,
+          value: modelId
+        });
+        this.models = readModels(res) ?? { ...this.models, current: modelId };
+      } else {
+        await this.connection.agent.request("session/set_model", { sessionId: this.acpSessionId, modelId });
+        if (this.models) this.models = { ...this.models, current: modelId };
+      }
+      return {};
+    } catch (error) {
+      return { error: errorText(error) };
+    }
+  }
+  /** Send one prompt turn; resolves when the agent ends the turn. */
+  async prompt(text, attachments = []) {
+    if (!this.isAlive || !this.connection || !this.acpSessionId) {
+      return { error: "Session is not alive" };
+    }
+    try {
+      await this.connection.agent.request("session/prompt", {
+        sessionId: this.acpSessionId,
+        prompt: this.promptBlocks(text, attachments)
+      });
+      return {};
+    } catch (error) {
+      return { error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  /** ACP content blocks: the text, then each attachment. */
+  promptBlocks(text, attachments) {
+    const blocks = [];
+    if (text) blocks.push({ type: "text", text });
+    for (const file of attachments) {
+      if (file.type === "image" && this.imagesSupported) {
+        blocks.push({ type: "image", mimeType: file.mimeType, data: file.data });
+      } else if (file.type === "image") {
+        blocks.push({ type: "text", text: `[Image ${file.name ?? ""} omitted: this agent does not accept images]` });
+      } else {
+        blocks.push({ type: "text", text: `<file name="${file.name ?? "attachment"}">
+${file.text}
+</file>` });
+      }
+    }
+    return blocks;
+  }
+  /** Ask the agent to stop the current turn, keeping the session. */
+  async cancelTurn() {
+    if (!this.connection || !this.acpSessionId) return;
+    try {
+      await this.connection.agent.notify("session/cancel", {
+        sessionId: this.acpSessionId
+      });
+    } catch {
+    }
+  }
+  close() {
+    this.alive = false;
+    try {
+      this.connection?.close();
+    } catch {
+    }
+    if (this.child && !this.child.killed) killTree(this.child);
+    this.child = null;
+    this.connection = null;
+    this.acpSessionId = null;
+  }
+  buildClientApp(sdk) {
+    const { onChunk, onThought, onToolCall, onPermission } = this.options;
+    const handleSessionUpdate = (params) => {
+      const update = params?.update;
+      if (!update) return;
+      const type = update.sessionUpdate;
+      if (type === "config_option_update") {
+        this.models = readModels(update) ?? this.models;
+        return;
+      }
+      if (type === "agent_message_chunk" && update.content?.type === "text") {
+        const text = update.content.text ?? "";
+        if (text) onChunk?.(text);
+        return;
+      }
+      if (type === "agent_thought_chunk" && update.content?.type === "text") {
+        const text = update.content.text ?? "";
+        if (text) onThought?.(text);
+        return;
+      }
+      if (type === "tool_call" || type === "tool_call_update") {
+        onToolCall?.({
+          toolCallId: String(update.toolCallId ?? ""),
+          title: typeof update.title === "string" ? update.title : void 0,
+          kind: typeof update.kind === "string" ? update.kind : void 0,
+          status: typeof update.status === "string" ? update.status : void 0,
+          toolName: typeof update._meta?.claudeCode?.toolName === "string" ? update._meta.claudeCode.toolName : void 0
+        });
+      }
+    };
+    return sdk.client({ name: "leuria" }).onNotification(
+      "session/update",
+      rawParams,
+      (ctx) => handleSessionUpdate(ctx.params)
+    ).onRequest("session/request_permission", rawParams, (ctx) => {
+      const decision = decidePermission(ctx.params);
+      onPermission?.(decision);
+      return decision.response;
+    }).onRequest("session/prompt", rawParams, () => ({
+      stopReason: "cancelled"
+    }));
+  }
+};
+function killTree(child) {
+  try {
+    if (process.platform === "win32" && child.pid) {
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+    } else if (child.pid) {
+      process.kill(-child.pid, "SIGTERM");
+    } else {
+      child.kill();
+    }
+  } catch {
+    try {
+      child.kill();
+    } catch {
+    }
+  }
+}
+
+// src/browser-link.ts
+import { execFileSync } from "child_process";
+import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync5, mkdtempSync, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { tmpdir } from "os";
+import { delimiter, join as join4 } from "path";
+function realCommand(name) {
+  if (name === "open" && existsSync4("/usr/bin/open")) return "/usr/bin/open";
+  try {
+    return execFileSync("/bin/sh", ["-c", `command -v ${name}`], { encoding: "utf-8" }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function catchBrowserLinks(onUrl, options = {}) {
+  if (process.platform === "win32") return null;
+  const basePath = options.basePath ?? process.env.PATH ?? "";
+  const findReal = options.real ?? realCommand;
+  const dir = mkdtempSync(join4(tmpdir(), "leuria-open-"));
+  const bin = join4(dir, "bin");
+  const log = join4(dir, "opened.txt");
+  mkdirSync5(bin);
+  writeFileSync4(log, "");
+  for (const name of ["open", "xdg-open"]) {
+    const real = findReal(name);
+    if (!real) continue;
+    const script = `#!/bin/sh
+for arg in "$@"; do printf '%s\\n' "$arg" >> '${log}'; done
+exec '${real}' "$@"
+`;
+    writeFileSync4(join4(bin, name), script);
+    chmodSync3(join4(bin, name), 493);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const timer = setInterval(() => {
+    let lines;
+    try {
+      lines = readFileSync4(log, "utf-8").split("\n");
+    } catch {
+      return;
+    }
+    for (const line of lines) {
+      if (/^https?:\/\//.test(line) && !seen.has(line)) {
+        seen.add(line);
+        onUrl(line);
+      }
+    }
+  }, 300);
+  return {
+    env: { PATH: `${bin}${delimiter}${basePath}` },
+    stop() {
+      clearInterval(timer);
+      rmSync2(dir, { recursive: true, force: true });
+    }
+  };
+}
+
+// src/auth.ts
+function knownModels() {
+  return readJson(homePath("models.json")) ?? {};
+}
+function rememberModels(id, models) {
+  const all = knownModels();
+  if (JSON.stringify(all[id]) === JSON.stringify(models)) return;
+  writeJson(homePath("models.json"), { ...all, [id]: models });
+}
+async function agentModels(id) {
+  if (isLlmId(id)) {
+    const parsed = parseLlmId(id);
+    const provider = parsed && !parsed.model ? getProvider(parsed.providerId) : void 0;
+    if (!provider) return null;
+    const models = await listModels(provider).catch(() => null);
+    return models?.length ? withChoice(id, llmModels(models, id)).models ?? null : null;
+  }
+  if (!knownModels()[id]) await checkSignIn(id);
+  return withChoice(id, knownModels()[id] ?? null).models ?? null;
+}
+function seenAgentModels(id) {
+  return withChoice(id, knownModels()[id] ?? null).models ?? null;
+}
+function aiLabel(id, model) {
+  const name = agentName(id);
+  if (isLlmId(id) && parseLlmId(id)?.model) return name;
+  if (isLlmId(id)) return model ? `${name} \xB7 ${model.split("/").pop()}` : name;
+  if (!model) return name;
+  const known = knownModels()[id]?.options.find((m) => m.id === model);
+  return known ? `${name} \xB7 ${known.name}` : name;
+}
+function rememberAgentState(id, state) {
+  if (isLlmId(id)) return;
+  rememberReady(id, state.ok);
+  if (state.models?.options.length) rememberModels(id, state.models);
+}
+function llmModels(models, id) {
+  return {
+    current: loadConfig().models?.[id] ?? defaultModel(models),
+    options: models.map((m) => ({
+      id: m.id,
+      name: m.id.split("/").pop() ?? m.id,
+      ...m.loaded ? { description: "Loaded: answers at once" } : m.remote ? { description: "Runs online" } : {}
+    }))
+  };
+}
+function withChoice(id, models) {
+  if (models?.options.length) rememberModels(id, models);
+  if (!models || models.options.length === 0) return {};
+  const chosen = loadConfig().models?.[id];
+  const current = chosen && models.options.some((m) => m.id === chosen) ? chosen : models.current;
+  return { models: { ...models, current } };
+}
+function isTerminal(method) {
+  return "type" in method && method.type === "terminal";
+}
+function agentMethods(methods) {
+  return methods.filter((m) => !isTerminal(m));
+}
+function preferredMethod(methods, options = {}) {
+  const usable = options.terminal ? methods : agentMethods(methods);
+  const isKey = (m) => /api.?key/i.test(`${m.id} ${m.name}`) || Boolean(m._meta?.["api-key"]);
+  return usable.find((m) => !isKey(m)) ?? usable[0];
+}
+async function open(id, onProgress, terminalAuth = false, extraEnv = {}) {
+  const agent = await ensureAgent(id, { onProgress });
+  const sandbox = mkdtempSync2(join5(tmpdir2(), "leuria-auth-"));
+  const custom = profileFor(id)?.configure?.({ sandbox, mcpUrl: "http://127.0.0.1:9/unused", mcpToken: "unused" });
+  const env = { ...agent.env, ...custom?.env, ...extraEnv };
+  const session = new AcpLiveSession({
+    command: agent.command,
+    args: [...agent.launchArgs, ...agent.args],
+    cwd: sandbox,
+    envVars: env,
+    mcpServers: [],
+    sessionMeta: custom?.meta,
+    terminalAuth
+  });
+  const close = () => {
+    session.close();
+    rmSync3(sandbox, { recursive: true, force: true });
+  };
+  return { agent, session, close, env, sandbox };
+}
+async function checkLlm(id) {
+  const parsed = parseLlmId(id);
+  const provider = parsed && getProvider(parsed.providerId);
+  if (!parsed || !provider) return { ok: false, detail: "This AI is not set up anymore. Choose it again.", methods: [] };
+  try {
+    const models = await listModels(provider);
+    if (parsed.model && !models.some((m) => m.id === parsed.model)) {
+      return { ok: false, detail: `${provider.name} doesn't have "${parsed.model}" anymore.`, methods: [] };
+    }
+    if (models.length === 0) return { ok: false, detail: `${provider.name} has no model to answer with. Open it and load one.`, methods: [] };
+    return { ok: true, detail: "ready", methods: [], ...parsed.model ? {} : withChoice(id, llmModels(models, id)) };
+  } catch (error) {
+    return { ok: false, detail: error instanceof Error ? error.message : String(error), methods: [] };
+  }
+}
+function checkTimeoutMs() {
+  const value = Number(process.env.LEURIA_CHECK_TIMEOUT_MS);
+  return Number.isFinite(value) && value > 0 ? value : 15e3;
+}
+async function checkSignIn(id, onProgress) {
+  if (isLlmId(id)) return checkLlm(id);
+  const { session, close } = await open(id, onProgress);
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      resolve({ ok: false, detail: `${agentName(id)} didn't answer. It may need to be set up in its own app first.`, methods: [] });
+    }, checkTimeoutMs());
+  });
+  try {
+    const status = await Promise.race([timedOut, check()]);
+    rememberReady(id, status.ok);
+    return status;
+  } finally {
+    clearTimeout(timer);
+    close();
+  }
+  async function check() {
+    const connected = await session.connect();
+    if (connected.error) return { ok: false, detail: `the agent did not start: ${connected.error}`, methods: [] };
+    const methods = agentMethods(session.info?.authMethods ?? []);
+    const created = await session.newSession();
+    if (!created.error) return { ok: true, detail: "ready", methods, ...withChoice(id, session.models) };
+    return { ok: false, detail: created.authRequired ? "not signed in" : created.error, methods };
+  }
+}
+async function signIn(id, options = {}) {
+  if (isLlmId(id)) return checkLlm(id);
+  const link = options.onUrl && !options.terminal ? catchBrowserLinks(options.onUrl) : null;
+  let opened;
+  try {
+    opened = await open(id, options.onProgress, options.terminal, link?.env);
+  } catch (error) {
+    link?.stop();
+    throw error;
+  }
+  const { agent, session, env, sandbox } = opened;
+  const close = () => {
+    opened.close();
+    link?.stop();
+  };
+  const cancelled = new Promise((resolve) => {
+    const onAbort = () => {
+      resolve({ ok: false, detail: "cancelled", methods: [] });
+      close();
+    };
+    if (options.signal?.aborted) onAbort();
+    else options.signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([cancelled, run()]);
+  } finally {
+    close();
+  }
+  async function run() {
+    const connected = await session.connect();
+    if (connected.error) return { ok: false, detail: `the agent did not start: ${connected.error}`, methods: [] };
+    const all = session.info?.authMethods ?? [];
+    const methods = options.terminal ? all : agentMethods(all);
+    if (methods.length === 0) {
+      return { ok: false, detail: `${agent.name} offers no sign-in method Leuria can run; sign in with its own tool.`, methods };
+    }
+    const method = options.methodId ? methods.find((m) => m.id === options.methodId) : preferredMethod(methods, { terminal: options.terminal });
+    if (!method) return { ok: false, detail: `Unknown method. Available: ${methods.map((m) => m.id).join(", ")}`, methods };
+    options.onProgress?.(`Signing in to ${agent.name} with ${method.name}${method.description ? ` (${method.description})` : ""}\u2026`);
+    if (isTerminal(method)) {
+      session.close();
+      const code = await new Promise((resolve, reject) => {
+        const child = spawn2(agent.command, [...agent.launchArgs, ...method.args ?? []], {
+          stdio: "inherit",
+          cwd: sandbox,
+          env: { ...process.env, ...env, ...method.env ?? {} }
+        });
+        child.on("error", reject);
+        child.on("exit", resolve);
+      });
+      if (code !== 0) return { ok: false, detail: `the sign-in ended with code ${code}`, methods };
+      return checkSignIn(id, options.onProgress);
+    }
+    const auth = await session.authenticate(method.id);
+    if (auth.error) return { ok: false, detail: auth.error, methods };
+    const created = await session.newSession();
+    if (created.error) return { ok: false, detail: created.error, methods };
+    rememberReady(id, true);
+    return { ok: true, detail: `signed in with ${method.name}`, methods, ...withChoice(id, session.models) };
+  }
+}
+
+// src/detect.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var CLI_TO_REGISTRY_ID = {
+  claude: "claude-acp",
+  codex: "codex-acp",
+  opencode: "opencode",
+  vibe: "mistral-vibe",
+  gemini: "gemini",
+  copilot: "github-copilot-cli",
+  pi: "pi-acp",
+  goose: "goose",
+  qwen: "qwen-code"
+};
+function onPath(command) {
+  try {
+    execFileSync2(process.platform === "win32" ? "where" : "which", [command], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectInstalledClis() {
+  return Object.entries(CLI_TO_REGISTRY_ID).filter(([cli]) => onPath(cli)).map(([, id]) => id);
+}
+
+// src/grants.ts
+import { createHash as createHash2, randomBytes, timingSafeEqual } from "crypto";
+import { statSync } from "fs";
+var GrantStore = class {
+  /** `path: null` keeps grants in memory only (tests, `leuria test`). */
+  constructor(path2 = homePath("grants.json")) {
+    this.path = path2;
+    this.reload();
+  }
+  path;
+  grants = [];
+  loadedMtime = -1;
+  removedListeners = /* @__PURE__ */ new Set();
+  changedListeners = /* @__PURE__ */ new Set();
+  /** Called with each origin whose grant disappears, here or in another process. */
+  onRemoved(listener) {
+    this.removedListeners.add(listener);
+  }
+  /** Called with each origin whose AI or model changes. */
+  onChanged(listener) {
+    this.changedListeners.add(listener);
+  }
+  list() {
+    this.reload();
+    return [...this.grants];
+  }
+  has(origin) {
+    this.reload();
+    return this.grants.some((g) => g.origin === normalizeOrigin(origin));
+  }
+  get(origin) {
+    this.reload();
+    try {
+      const normalized = normalizeOrigin(origin);
+      return this.grants.find((g) => g.origin === normalized);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Use `agent` for this site, or the default AI when `undefined`. */
+  setAgent(origin, agent) {
+    this.reload();
+    const grant = this.grants.find((g) => g.origin === normalizeOrigin(origin));
+    if (!grant) return false;
+    if (agent) grant.agent = agent;
+    else delete grant.agent;
+    this.save();
+    for (const listener of this.changedListeners) listener(grant.origin);
+    return true;
+  }
+  /** Use `model` of `agent` for this site, or that AI's own choice when `undefined`. */
+  setModel(origin, model) {
+    this.reload();
+    const grant = this.grants.find((g) => g.origin === normalizeOrigin(origin));
+    if (!grant) return false;
+    if (model) grant.model = model;
+    else delete grant.model;
+    this.save();
+    for (const listener of this.changedListeners) listener(grant.origin);
+    return true;
+  }
+  /** Create or replace the origin's grant; returns the new token. Keeps the site's AI and model choice; `needs` replaces what it declared. */
+  create(origin, app, needs) {
+    this.reload();
+    const normalized = normalizeOrigin(origin);
+    const token = randomBytes(32).toString("base64url");
+    const previous = this.grants.find((g) => g.origin === normalized);
+    this.grants = this.grants.filter((g) => g.origin !== normalized);
+    this.grants.push({
+      origin: normalized,
+      app,
+      tokenHash: hashToken(token),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...previous?.agent ? { agent: previous.agent } : {},
+      ...previous?.model ? { model: previous.model } : {},
+      ...needs ? { needs } : {}
+    });
+    this.save();
+    return token;
+  }
+  /** True when `token` is the origin's current token. */
+  verify(origin, token) {
+    if (!token) return false;
+    this.reload();
+    const grant = this.grants.find((g) => g.origin === normalizeOrigin(origin));
+    if (!grant) return false;
+    const expected = Buffer.from(grant.tokenHash, "hex");
+    const actual = Buffer.from(hashToken(token), "hex");
+    if (!timingSafeEqual(expected, actual)) return false;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (!grant.lastUsedAt || Date.parse(now) - Date.parse(grant.lastUsedAt) > 6e4) {
+      grant.lastUsedAt = now;
+      this.save();
+    }
+    return true;
+  }
+  revoke(origin) {
+    this.reload();
+    const normalized = normalizeOrigin(origin);
+    const before = this.grants.length;
+    this.grants = this.grants.filter((g) => g.origin !== normalized);
+    if (this.grants.length === before) return false;
+    this.save();
+    for (const listener of this.removedListeners) listener(normalized);
+    return true;
+  }
+  /** Pick up changes made by another process, such as `leuria sites revoke`. */
+  reload() {
+    if (!this.path) return;
+    let mtime;
+    try {
+      mtime = statSync(this.path).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    if (mtime === this.loadedMtime) return;
+    const previous = new Set(this.grants.map((g) => g.origin));
+    this.grants = readJson(this.path)?.grants ?? [];
+    const firstLoad = this.loadedMtime === -1;
+    this.loadedMtime = mtime;
+    if (firstLoad) return;
+    for (const grant of this.grants) previous.delete(grant.origin);
+    for (const origin of previous) {
+      for (const listener of this.removedListeners) listener(origin);
+    }
+  }
+  save() {
+    if (!this.path) return;
+    writeJson(this.path, { grants: this.grants });
+    try {
+      this.loadedMtime = statSync(this.path).mtimeMs;
+    } catch {
+    }
+  }
+};
+function hashToken(token) {
+  return createHash2("sha256").update(token).digest("hex");
+}
+function normalizeOrigin(origin) {
+  const url = new URL(origin.trim());
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Not a web origin: ${origin}`);
+  }
+  return url.origin.toLowerCase();
+}
+
+// src/server.ts
+import { timingSafeEqual as timingSafeEqual3 } from "crypto";
+import * as http from "http";
+
+// src/http-utils.ts
+var MAX_BODY_BYTES = 16 * 1024 * 1024;
+function sendJson(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("Body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function writeSse(res, event, data) {
+  try {
+    res.write(`event: ${event}
+data: ${JSON.stringify(data ?? null)}
+
+`);
+  } catch {
+  }
+}
+
+// src/llm/embeddings.ts
+var NoEmbedderError = class extends Error {
+  constructor() {
+    super("No embedding model on this computer. Load one in LM Studio or Ollama.");
+    this.name = "NoEmbedderError";
+  }
+};
+function isLocal(provider) {
+  if (provider.kind !== "lmstudio" && provider.kind !== "ollama") return false;
+  const host = new URL(provider.baseUrl).hostname;
+  return host === "127.0.0.1" || host === "localhost" || host === "[::1]";
+}
+async function listEmbeddingModels(provider, timeoutMs = 1500) {
+  const root = provider.baseUrl.replace(/\/v\d+$/, "");
+  const get = (url) => fetch(url, { headers: authHeaders(provider), signal: AbortSignal.timeout(timeoutMs) }).then((r) => r.ok ? r.json() : null).catch(() => null);
+  if (provider.kind === "lmstudio") {
+    const native = await get(`${root}/api/v1/models`);
+    if (native?.models) {
+      return native.models.filter((m) => m.type === "embedding").map((m) => ({ id: m.key, loaded: (m.loaded_instances?.length ?? 0) > 0 })).sort((a, b) => Number(b.loaded) - Number(a.loaded));
+    }
+  }
+  if (provider.kind === "ollama") {
+    const tags = await get(`${root}/api/tags`);
+    return (tags?.models ?? []).filter((m) => !m.remote_host && EMBEDDING.test(m.name)).map((m) => ({ id: m.name }));
+  }
+  const list = await get(`${provider.baseUrl}/models`);
+  return (list?.data ?? []).filter((m) => typeof m.id === "string").filter((m) => m.type === "embedding" || EMBEDDING.test(m.id)).map((m) => ({ id: m.id }));
+}
+async function listLocalEmbedders() {
+  const found = await Promise.all(
+    listProviders().filter(isLocal).map(async (provider) => (await listEmbeddingModels(provider)).map((model) => ({ provider, model })))
+  );
+  return found.flat();
+}
+function withPrefix(model, text, kind) {
+  if (/nomic-embed/i.test(model)) return `${kind === "query" ? "search_query" : "search_document"}: ${text}`;
+  if (/(^|[/-])e5-/i.test(model)) return `${kind === "query" ? "query" : "passage"}: ${text}`;
+  if (kind === "query" && /bge-.*en|mxbai-embed/i.test(model)) return `Represent this sentence for searching relevant passages: ${text}`;
+  return text;
+}
+var CACHE_MS = 1e4;
+function localEmbeddings(choice = () => loadConfig().embed) {
+  let cached;
+  const find = () => {
+    const chosen = choice();
+    const key = JSON.stringify(chosen ?? "auto");
+    if (!cached || cached.key !== key || Date.now() - cached.at > CACHE_MS) {
+      const value = (async () => {
+        if (chosen === "off") return void 0;
+        if (chosen) {
+          const provider = listProviders().find((p) => p.id === chosen.provider);
+          if (!provider || !isLocal(provider)) return void 0;
+          const models = await listEmbeddingModels(provider);
+          return models.some((m) => m.id === chosen.model) ? { provider, model: chosen.model } : void 0;
+        }
+        for (const provider of listProviders().filter(isLocal)) {
+          const [model] = await listEmbeddingModels(provider);
+          if (model) return { provider, model: model.id };
+        }
+        return void 0;
+      })();
+      cached = { at: Date.now(), key, value };
+    }
+    return cached.value;
+  };
+  return {
+    find,
+    embed: async (texts, kind) => {
+      const embedder = await find();
+      if (!embedder) throw new NoEmbedderError();
+      const { provider, model } = embedder;
+      const res = await fetch(`${provider.baseUrl}/embeddings`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...authHeaders(provider) },
+        body: JSON.stringify({ model, input: texts.map((t) => withPrefix(model, t, kind)) }),
+        signal: AbortSignal.timeout(12e4)
+      }).catch(() => null);
+      if (!res?.ok) {
+        cached = void 0;
+        throw new Error(`${provider.name} couldn't embed the texts.`);
+      }
+      const body = await res.json();
+      const data = [...body.data ?? []].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+      if (data.length !== texts.length || data.some((d) => !Array.isArray(d.embedding))) {
+        throw new Error(`${provider.name} returned an unexpected answer.`);
+      }
+      return { model, vectors: data.map((d) => d.embedding) };
+    }
+  };
+}
+var MAX_EMBED_TEXTS = 256;
+var MAX_EMBED_CHARS = 8e3;
+function parseEmbedBody(body) {
+  const { texts, kind } = body ?? {};
+  if (!Array.isArray(texts) || texts.length === 0 || !texts.every((t) => typeof t === "string")) {
+    throw new Error("texts must be a non-empty array of strings");
+  }
+  if (texts.length > MAX_EMBED_TEXTS) throw new Error(`At most ${MAX_EMBED_TEXTS} texts per request`);
+  if (kind !== void 0 && kind !== "query" && kind !== "document") throw new Error('kind must be "query" or "document"');
+  return { texts: texts.map((t) => t.slice(0, MAX_EMBED_CHARS)), kind: kind ?? "document" };
+}
+
+// src/pairing.ts
+import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+
+// src/needs.ts
+var EFFORTS = ["light", "standard", "deep"];
+function parseNeeds(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const raw = input;
+  const needs = {};
+  const flag = (value) => value === true || value === "1" || value === "true";
+  if (flag(raw.tools)) needs.tools = true;
+  if (flag(raw.images)) needs.images = true;
+  if (typeof raw.effort === "string" && EFFORTS.includes(raw.effort)) needs.effort = raw.effort;
+  const context = Number(raw.context);
+  if (Number.isFinite(context) && context > 0) needs.context = Math.min(Math.round(context), 1e7);
+  return Object.keys(needs).length ? needs : void 0;
+}
+
+// src/pairing.ts
+var REQUEST_TTL_MS = 5 * 6e4;
+var MAX_PENDING = 20;
+var WAIT_MS = 25e3;
+var DENIED_COOLDOWN_MS = 3e4;
+var NONCE = /^[A-Za-z0-9_-]{22,128}$/;
+var hashNonce = (nonce) => createHash3("sha256").update(nonce).digest();
+var Pairing = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  requests = /* @__PURE__ */ new Map();
+  deniedAt = /* @__PURE__ */ new Map();
+  /** A link named this origin and it hasn't collected its answer yet: it may be answered. */
+  hasRequest(origin) {
+    this.expire();
+    return [...this.requests.values()].some((r) => r.origin === origin);
+  }
+  /**
+   * A `leuria://connect` link reached the desktop app. Returns the request,
+   * or why it was refused. A repeated link for the same site replaces the
+   * nonce (the page tried again) instead of asking twice.
+   */
+  link(input) {
+    this.expire();
+    let origin;
+    try {
+      origin = normalizeOrigin(String(input.origin ?? ""));
+    } catch {
+      return { error: "The link doesn't name a website." };
+    }
+    if (this.options.selfOrigins.has(origin)) return { error: "The link doesn't name a website." };
+    if (typeof input.nonce !== "string" || !NONCE.test(input.nonce)) return { error: "The link is incomplete." };
+    const app = typeof input.app === "string" && input.app.trim() ? input.app.trim().slice(0, 80) : void 0;
+    const request = this.open(origin, app, input.nonce, parseNeeds(input.needs));
+    return "error" in request ? request : { requestId: request.id };
+  }
+  /** Returns true when the request was a pairing route. */
+  async handle(req, res, pathname) {
+    const segments = pathname.split("/").filter(Boolean);
+    if (segments[0] !== "connect") return false;
+    this.expire();
+    const origin = req.headers.origin;
+    const id = segments[1];
+    const action = segments[2];
+    if (req.method === "POST" && id === "claim" && segments.length === 2) {
+      await this.claim(req, res, origin);
+      return true;
+    }
+    if (!id) return false;
+    const request = this.requests.get(id);
+    if (req.method === "GET" && segments.length === 2) {
+      this.renderPage(res, request);
+      return true;
+    }
+    if (req.method === "GET" && action === "state") {
+      if (origin && !this.options.selfOrigins.has(origin)) {
+        sendJson(res, 403, { error: "Forbidden" });
+        return true;
+      }
+      sendJson(res, 200, { decision: request?.decision ?? "expired" });
+      return true;
+    }
+    if (req.method === "POST" && action === "decide") {
+      if (!origin || !this.options.selfOrigins.has(origin)) {
+        sendJson(res, 403, { error: "Forbidden" });
+        return true;
+      }
+      if (!request || request.decision !== "pending") {
+        sendJson(res, 410, { error: "This request has expired. Ask the site again." });
+        return true;
+      }
+      const body = await parseBody(req);
+      this.decide(request, body.allow === true);
+      sendJson(res, 200, { decision: request.decision, origin: request.origin });
+      return true;
+    }
+    return false;
+  }
+  /** The page collects the visitor's answer, with the nonce of its link. */
+  async claim(req, res, rawOrigin) {
+    let origin;
+    try {
+      origin = rawOrigin && !this.options.selfOrigins.has(rawOrigin) ? normalizeOrigin(rawOrigin) : void 0;
+    } catch {
+      origin = void 0;
+    }
+    if (!origin) {
+      sendJson(res, 400, { error: "Pairing must come from a web page" });
+      return;
+    }
+    const body = await parseBody(req);
+    const nonce = body.nonce;
+    if (typeof nonce !== "string" || !NONCE.test(nonce)) {
+      sendJson(res, 400, { error: "A nonce is required" });
+      return;
+    }
+    const hash = hashNonce(nonce);
+    let request = [...this.requests.values()].find((r) => r.origin === origin && timingSafeEqual2(r.nonce, hash));
+    if (!request) {
+      if (this.options.linksOnly) {
+        sendJson(res, 404, { error: "Unknown pairing request" });
+        return;
+      }
+      const app = typeof body.app === "string" && body.app.trim() ? body.app.trim().slice(0, 80) : void 0;
+      const opened = this.open(origin, app, nonce, parseNeeds(body.needs));
+      if ("error" in opened) {
+        sendJson(res, opened.status, { error: opened.error });
+        return;
+      }
+      request = opened;
+    }
+    await this.wait(request);
+    if (!timingSafeEqual2(request.nonce, hash)) {
+      sendJson(res, 404, { error: "Unknown pairing request" });
+      return;
+    }
+    if (request.decision === "allowed" && request.token) {
+      const token = request.token;
+      request.token = void 0;
+      this.requests.delete(request.id);
+      sendJson(res, 200, { status: "allowed", token });
+    } else if (request.decision === "denied") {
+      this.requests.delete(request.id);
+      sendJson(res, 200, { status: "denied" });
+    } else {
+      sendJson(res, 200, { status: "pending" });
+    }
+  }
+  /** Ask the visitor about `origin`, or update the question already asked. */
+  open(origin, app, nonce, needs) {
+    const denied = this.deniedAt.get(origin);
+    if (denied && Date.now() - denied < DENIED_COOLDOWN_MS) return { error: "The visitor just said no to this site", status: 429 };
+    const existing = [...this.requests.values()].find((r) => r.origin === origin && r.decision === "pending");
+    if (existing) {
+      existing.nonce = hashNonce(nonce);
+      if (app) existing.app = app;
+      if (needs) existing.needs = needs;
+      this.options.onRequest?.(this.info(existing));
+      return existing;
+    }
+    if ([...this.requests.values()].filter((r) => r.decision === "pending").length >= MAX_PENDING) {
+      return { error: "Too many pending pairing requests", status: 429 };
+    }
+    const request = {
+      id: randomBytes2(18).toString("base64url"),
+      origin,
+      app,
+      createdAt: Date.now(),
+      decision: "pending",
+      nonce: hashNonce(nonce),
+      needs,
+      waiters: /* @__PURE__ */ new Set()
+    };
+    this.requests.set(request.id, request);
+    this.options.logger.info("pairing requested", { origin, app });
+    this.options.onRequest?.(this.info(request));
+    return request;
+  }
+  info(request) {
+    return {
+      requestId: request.id,
+      origin: request.origin,
+      app: request.app,
+      ...request.needs ? { needs: request.needs } : {},
+      approveUrl: `http://127.0.0.1:${this.options.port}/connect/${request.id}`
+    };
+  }
+  /** Requests waiting for the visitor, e.g. for the desktop app. */
+  pending() {
+    this.expire();
+    return [...this.requests.values()].filter((r) => r.decision === "pending").map((r) => this.info(r));
+  }
+  /**
+   * Decide from a trusted place (the desktop app's native window).
+   * `granted` runs on Allow once the grant exists, before the site gets
+   * its token: e.g. to set the site's AI and model from the first message.
+   */
+  decideById(requestId, allow, granted) {
+    this.expire();
+    const request = this.requests.get(requestId);
+    if (!request || request.decision !== "pending") return false;
+    this.decide(request, allow, granted);
+    return true;
+  }
+  decide(request, allow, granted) {
+    if (allow) {
+      request.token = this.options.grants.create(request.origin, request.app, request.needs);
+      granted?.(request.origin);
+      request.decision = "allowed";
+    } else {
+      request.decision = "denied";
+      this.deniedAt.set(request.origin, Date.now());
+    }
+    this.options.logger.info("pairing decided", {
+      origin: request.origin,
+      decision: request.decision
+    });
+    for (const wake of request.waiters) wake();
+    request.waiters.clear();
+    this.options.onDecided?.({ requestId: request.id, origin: request.origin, allowed: allow });
+  }
+  wait(request) {
+    if (request.decision !== "pending") return Promise.resolve();
+    return new Promise((resolve) => {
+      const wake = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        request.waiters.delete(wake);
+        resolve();
+      }, WAIT_MS);
+      request.waiters.add(wake);
+    });
+  }
+  expire() {
+    const now = Date.now();
+    for (const [id, request] of this.requests) {
+      if (now - request.createdAt > REQUEST_TTL_MS) {
+        for (const wake of request.waiters) wake();
+        this.requests.delete(id);
+      }
+    }
+    for (const [origin, at] of this.deniedAt) if (now - at > DENIED_COOLDOWN_MS) this.deniedAt.delete(origin);
+  }
+  renderPage(res, request) {
+    const body = request && request.decision === "pending" ? approvePage(request, this.options.agentName()) : messagePage("This request has expired", "Go back to the site and try connecting again.");
+    res.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store",
+      // Never framed, so a site cannot overlay or click-jack it.
+      "X-Frame-Options": "DENY",
+      "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'",
+      "Referrer-Policy": "no-referrer"
+    });
+    res.end(body);
+  }
+};
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+var STYLE = `
+:root { color-scheme: light dark; --bg: #fcfcfe; --surface: #ffffff; --text: #1d2035; --muted: #5f6275; --border: #d6d8e5; --sunken: #f7f7fb;
+  --ink: #14172b; --ink-hover: #262a45; --on-ink: #ffffff; --live: #019163; --focus: #8169dd;
+  --atmo-base: #eef0f7; --atmo-lavender: #d9d0ff; --atmo-ice: #cde8f7; --atmo-mint: #d3f3e6; --atmo-blush: #f9dce6;
+  --shadow: 0 32px 72px -20px rgba(20, 23, 43, 0.35), 0 0 0 1px rgba(20, 23, 43, 0.05); }
+@media (prefers-color-scheme: dark) { :root { --bg: #0d0e13; --surface: #13141a; --text: #ebecf2; --muted: #babdcb; --border: #323443; --sunken: #0d0e13;
+  --ink: #eef0f7; --ink-hover: #d9dcea; --on-ink: #14172b; --live: #19a572; --focus: #907aeb;
+  --atmo-base: #0f1120; --atmo-lavender: #2a2548; --atmo-ice: #183040; --atmo-mint: #183329; --atmo-blush: #3a2231;
+  --shadow: 0 32px 72px -20px rgba(0, 0, 0, 0.8), 0 0 0 1px rgba(255, 255, 255, 0.08); } }
+* { box-sizing: border-box; }
+body { margin: 0; min-height: 100vh; display: grid; place-items: center; padding: 16px; color: var(--text);
+  font: 16px/1.5 "Plus Jakarta Sans", ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; -webkit-font-smoothing: antialiased;
+  background: radial-gradient(circle at 12% 12%, var(--atmo-blush) 0%, transparent 52%), radial-gradient(circle at 88% 18%, var(--atmo-ice) 0%, transparent 54%),
+    radial-gradient(circle at 82% 92%, var(--atmo-mint) 0%, transparent 56%), radial-gradient(circle at 14% 92%, var(--atmo-lavender) 0%, transparent 56%), var(--atmo-base); }
+main { width: 100%; max-width: 420px; background: var(--surface); border-radius: 24px; padding: 32px; box-shadow: var(--shadow); display: flex; flex-direction: column; gap: 16px; }
+.logo { display: inline-flex; align-items: center; gap: 8px; color: var(--ink); font-weight: 800; letter-spacing: -0.04em; font-size: 19px; }
+.badge { align-self: flex-start; display: inline-flex; align-items: center; gap: 6px; padding: 4px 10px; border-radius: 9999px; background: var(--sunken); border: 1px solid var(--border); font-size: 13px; color: var(--muted); }
+h1 { font-size: 24px; line-height: 30px; font-weight: 700; letter-spacing: -0.02em; margin: 0; }
+p { margin: 0; color: var(--muted); font-size: 14px; }
+.eyebrow { font-size: 12px; font-weight: 700; letter-spacing: 0.12em; text-transform: uppercase; color: var(--muted); margin-bottom: 8px; }
+ul { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 8px; font-size: 14px; }
+li { display: flex; align-items: center; gap: 8px; }
+li svg { flex-shrink: 0; }
+.can svg { color: var(--live); }
+.cant svg { color: var(--muted); }
+.warn { font-size: 14px; font-weight: 600; }
+.actions { display: flex; gap: 12px; justify-content: flex-end; margin-top: 8px; }
+button { font: inherit; font-size: 16px; font-weight: 600; min-height: 48px; padding: 0 22px; border-radius: 9999px; cursor: pointer; border: none; }
+button.soft { background: var(--sunken); color: var(--text); border: 1px solid var(--border); }
+button.ink { background: var(--ink); color: var(--on-ink); }
+button.ink:hover { background: var(--ink-hover); }
+button:disabled { opacity: 0.5; cursor: default; }
+button:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
+.small { font-size: 12px; }
+`;
+var MARK = "M181 61 C184 74 191 82 206 86 C191 90 184 98 181 111 C178 98 171 90 156 86 C171 82 178 74 181 61 Z M59 92 C60 109 67 128 79 143 C91 158 105 168 124 174 C149 182 164 193 171 207 C177 219 177 239 177 255 C182 255 182 240 184 226 C188 199 201 187 223 179 C247 171 270 158 284 142 C298 127 303 109 303 92 C298 91 292 101 284 108 C265 125 245 130 226 126 C217 124 211 114 205 112 C199 110 199 116 199 121 C198 127 191 130 181 130 C171 130 165 127 163 121 C162 116 165 110 159 111 C151 112 148 122 137 126 C118 131 98 125 78 109 C69 102 65 91 59 92 Z";
+var LOGO = `<span class="logo" role="img" aria-label="Leuria"><svg width="22" height="22" viewBox="53 30 256 256" aria-hidden="true"><path d="${MARK}" fill="currentColor"/></svg>leuria</span>`;
+var icon = (d) => `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="${d}"/></svg>`;
+var CHECK = icon("M5 12.5l4.5 4.5L19 7.5");
+var CROSS = icon("M6 6l12 12M18 6L6 18");
+var GLOBE = icon("M12 21a9 9 0 100-18 9 9 0 000 18zM3.5 9h17M3.5 15h17M12 3c2.5 2.6 3.5 5.6 3.5 9s-1 6.4-3.5 9c-2.5-2.6-3.5-5.6-3.5-9s1-6.4 3.5-9z");
+function page(title, body, script = "") {
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)} \xB7 Leuria</title><style>${STYLE}</style></head>
+<body><main>${LOGO}${body}</main>${script ? `<script>${script}</script>` : ""}</body></html>`;
+}
+function approvePage(request, agentName2) {
+  const host = escapeHtml(new URL(request.origin).host);
+  const name = request.app ? escapeHtml(request.app) : host;
+  const agent = escapeHtml(agentName2);
+  const insecure = request.origin.startsWith("http:") && !/^http:\/\/(localhost|127\.0\.0\.1)(:|$)/.test(request.origin);
+  const body = `
+<span class="badge">${GLOBE}${host}</span>
+<h1>${name} wants to use your AI</h1>
+<p>It will talk to ${agent}, on this computer.</p>
+<div><div class="eyebrow">It can</div><ul class="can"><li>${CHECK}Ask your AI to answer you</li><li>${CHECK}Let your AI use its own page's tools</li></ul></div>
+<div><div class="eyebrow">It can't</div><ul class="cant"><li>${CROSS}See your files or run programs</li><li>${CROSS}See what you do on other websites</li></ul></div>
+${insecure ? `<p class="warn">This site doesn't use a secure connection.</p>` : ""}
+<p class="small">You can disconnect it at any time with <code>leuria sites revoke ${escapeHtml(request.origin)}</code>.</p>
+<div class="actions"><button type="button" class="soft" id="deny">Not now</button><button type="button" class="ink" id="allow">Allow</button></div>`;
+  const script = `
+const main = document.querySelector("main");
+const buttons = document.querySelectorAll("button");
+const done = (title, text) => {
+  main.innerHTML = main.querySelector(".logo").outerHTML + "<h1>" + title + "</h1><p>" + text + "</p>";
+  setTimeout(() => window.close(), 1500);
+};
+async function decide(allow) {
+  buttons.forEach((b) => (b.disabled = true));
+  const res = await fetch(location.pathname + "/decide", {
+    method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ allow }),
+  }).catch(() => null);
+  if (!res || !res.ok) return done("This request has expired", "Go back to the site and try connecting again.");
+  allow ? done("Connected", "You can close this window and go back to the site.") : done("Not connected", "The site can ask again later.");
+}
+document.getElementById("allow").addEventListener("click", () => decide(true));
+document.getElementById("deny").addEventListener("click", () => decide(false));
+// Answered in the Leuria app instead: close this window too.
+setInterval(async () => {
+  const res = await fetch(location.pathname + "/state").catch(() => null);
+  const state = res && res.ok ? await res.json() : null;
+  if (state && state.decision !== "pending") done("Answered in Leuria", "You can close this window.");
+}, 1500);`;
+  return page("Connect your AI", body, script);
+}
+function messagePage(title, text) {
+  return page(title, `<h1>${escapeHtml(title)}</h1><p>${escapeHtml(text)}</p>`);
+}
+
+// src/routes.ts
+var MAX_ATTACHMENTS = 10;
+function parseAttachments(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error("attachments must be an array");
+  if (value.length > MAX_ATTACHMENTS) throw new Error(`At most ${MAX_ATTACHMENTS} attachments`);
+  return value.map((item, i) => {
+    const a = item ?? {};
+    const name = typeof a.name === "string" ? a.name.slice(0, 200) : void 0;
+    if (a.type === "image" && typeof a.mimeType === "string" && /^image\//.test(a.mimeType) && typeof a.data === "string") {
+      return { type: "image", mimeType: a.mimeType, data: a.data, name };
+    }
+    if (a.type === "text" && typeof a.text === "string") {
+      return { type: "text", text: a.text, name, mimeType: typeof a.mimeType === "string" ? a.mimeType : void 0 };
+    }
+    throw new Error(`attachments[${i}] must be { type: "image", mimeType, data } or { type: "text", text }`);
+  });
+}
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var POST_ACTIONS = /* @__PURE__ */ new Set([
+  "approve",
+  "prompt",
+  "cancel-turn",
+  "cancel",
+  "close"
+]);
+async function handleSessionRequest(req, res, pathname, sm, requester) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments[0] !== "session") return false;
+  try {
+    if (req.method === "POST" && segments.length === 2 && segments[1] === "prepare") {
+      await handlePrepare(req, res, sm, requester);
+      return true;
+    }
+    const sessionId = segments[1];
+    const action = segments[2];
+    if (!sessionId) return false;
+    const info = sm.get(sessionId);
+    if (!info || info.origin !== requester) {
+      sendJson(res, 404, { error: "Session not found" });
+      return true;
+    }
+    if (req.method === "GET" && segments.length === 2) {
+      sendJson(res, 200, info);
+      return true;
+    }
+    if (req.method === "GET" && action === "stream") {
+      handleStream(req, res, sm, sessionId);
+      return true;
+    }
+    if (req.method === "POST" && action && POST_ACTIONS.has(action)) {
+      const updated = await runAction(req, sm, sessionId, action);
+      sendJson(res, 200, { sessionId: updated.id, status: updated.status });
+      return true;
+    }
+  } catch (err) {
+    sendJson(res, 400, { error: err instanceof Error ? err.message : String(err) });
+    return true;
+  }
+  return false;
+}
+async function runAction(req, sm, sessionId, action) {
+  switch (action) {
+    case "approve":
+      return sm.approve(sessionId);
+    case "prompt": {
+      const body = await parseBody(req);
+      if (typeof body.prompt !== "string" || !body.prompt.trim()) {
+        throw new Error("Missing required field: prompt");
+      }
+      return sm.promptTurn(sessionId, body.prompt, parseAttachments(body.attachments));
+    }
+    case "cancel-turn":
+      return sm.cancelTurn(sessionId);
+    case "cancel":
+      return sm.cancel(sessionId);
+    default:
+      return sm.close(sessionId);
+  }
+}
+async function handlePrepare(req, res, sm, origin) {
+  const body = await parseBody(req);
+  if (body.prompt !== void 0 && (typeof body.prompt !== "string" || !body.prompt.trim())) {
+    sendJson(res, 400, { error: "prompt must be a non-empty string when given" });
+    return;
+  }
+  const info = sm.prepare({
+    prompt: body.prompt,
+    attachments: parseAttachments(body.attachments),
+    systemPrompt: typeof body.systemPrompt === "string" && body.systemPrompt ? body.systemPrompt : void 0,
+    maxTurns: typeof body.maxTurns === "number" ? body.maxTurns : void 0,
+    origin
+  });
+  sendJson(res, 201, {
+    sessionId: info.id,
+    status: info.status,
+    registrationToken: info.registrationToken,
+    webmcpUrl: info.webmcpUrl
+  });
+}
+function handleStream(req, res, sm, sessionId) {
+  const info = sm.get(sessionId);
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive"
+  });
+  res.flushHeaders();
+  if (info.status === "completed" || info.status === "failed" || info.status === "cancelled") {
+    writeSse(res, info.status, info.status === "failed" ? info.error ?? null : null);
+    res.end();
+    return;
+  }
+  if (info.status !== "pending_approval") {
+    writeSse(res, "webmcp_ready", sm.webmcpReady(sessionId));
+  }
+  if (info.status === "idle") writeSse(res, "ready", null);
+  for (const chunk of sm.turnChunks(sessionId)) writeSse(res, "chunk", chunk);
+  const listener = (event, data) => {
+    writeSse(res, event, data);
+    if (TERMINAL_EVENTS.has(event)) {
+      sm.removeListener(sessionId, listener);
+      res.end();
+    }
+  };
+  sm.addListener(sessionId, listener);
+  req.on("close", () => sm.removeListener(sessionId, listener));
+}
+
+// src/session-manager.ts
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join6 } from "path";
+
+// src/llm/llm-session.ts
+var LlmSession = class {
+  constructor(options) {
+    this.options = options;
+    if (options.systemPrompt) this.messages.push({ role: "system", content: options.systemPrompt });
+  }
+  options;
+  messages = [];
+  turn = null;
+  alive = false;
+  get isAlive() {
+    return this.alive;
+  }
+  /** Nothing to spawn: check that the provider answers. */
+  async start() {
+    const { provider } = this.options;
+    try {
+      const res = await (this.options.fetch ?? fetch)(`${provider.baseUrl}/models`, {
+        headers: authHeaders(provider),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (res.status === 401 || res.status === 403) return { error: `${provider.name} refused the API key.` };
+    } catch {
+      return { error: unreachable(provider) };
+    }
+    this.alive = true;
+    return {};
+  }
+  async prompt(text, attachments = []) {
+    if (!this.alive) return { error: "Session is not alive" };
+    this.messages.push({ role: "user", content: userContent(text, attachments) });
+    const controller = new AbortController();
+    this.turn = controller;
+    const maxSteps = this.options.maxSteps ?? 10;
+    try {
+      for (let step = 0; step < maxSteps; step++) {
+        const { content, toolCalls } = await this.complete(controller.signal, step === maxSteps - 1);
+        this.messages.push({ role: "assistant", content: content || null, ...toolCalls.length ? { tool_calls: toolCalls } : {} });
+        if (toolCalls.length === 0) return {};
+        for (const call of toolCalls) {
+          if (controller.signal.aborted) return {};
+          this.messages.push({ role: "tool", tool_call_id: call.id, content: await this.runTool(call) });
+        }
+      }
+      return {};
+    } catch (error) {
+      if (controller.signal.aborted) return {};
+      return { error: error instanceof Error ? error.message : String(error) };
+    } finally {
+      this.turn = null;
+    }
+  }
+  async cancelTurn() {
+    this.turn?.abort();
+  }
+  close() {
+    this.turn?.abort();
+    this.alive = false;
+  }
+  async runTool(call) {
+    const notify = (status) => this.options.onToolCall?.({ toolCallId: call.id, title: call.function.name, toolName: `mcp__webmcp__${call.function.name}`, kind: "other", status });
+    notify("in_progress");
+    let args = {};
+    try {
+      args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+    } catch {
+      notify("failed");
+      return JSON.stringify({ error: "The arguments were not valid JSON." });
+    }
+    try {
+      const result = await this.options.tools.call(call.function.name, args);
+      notify("completed");
+      return typeof result === "string" ? result : JSON.stringify(result ?? null);
+    } catch (error) {
+      notify("failed");
+      return JSON.stringify({ error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  /** One streamed model call; text and reasoning go out as they arrive. */
+  async complete(signal, lastStep) {
+    const { provider, model } = this.options;
+    const tools = this.options.tools.list();
+    const body = { model, messages: this.messages, stream: true };
+    if (tools.length) {
+      body.tools = tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description ?? "", parameters: t.inputSchema }
+      }));
+      if (lastStep) body.tool_choice = "none";
+    }
+    let res;
+    try {
+      res = await (this.options.fetch ?? fetch)(`${provider.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "text/event-stream", ...authHeaders(provider) },
+        body: JSON.stringify(body),
+        signal
+      });
+    } catch (error) {
+      if (signal.aborted) throw error;
+      throw new Error(unreachable(provider));
+    }
+    if (!res.ok || !res.body) {
+      const raw = await res.text().catch(() => "");
+      let detail = raw.slice(0, 300);
+      try {
+        const parsed = JSON.parse(raw);
+        detail = typeof parsed.error === "string" ? parsed.error : parsed.error?.message ?? detail;
+      } catch {
+      }
+      if (res.status === 404 && /model/i.test(detail)) throw new Error(`${provider.name} does not have the model "${model}".`);
+      if (res.status === 401 || res.status === 403) throw new Error(`${provider.name} refused the API key.`);
+      throw new Error(detail ? `${provider.name}: ${detail}` : `${provider.name} answered with an error (${res.status}).`);
+    }
+    let content = "";
+    const calls = /* @__PURE__ */ new Map();
+    for await (const data of sseData(res.body)) {
+      if (data === "[DONE]") break;
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (chunk.error?.message) throw new Error(`${provider.name}: ${chunk.error.message}`);
+      const delta = chunk.choices?.[0]?.delta;
+      if (!delta) continue;
+      const thought = delta.reasoning_content ?? delta.reasoning;
+      if (thought) this.options.onThought?.(thought);
+      if (delta.content) {
+        content += delta.content;
+        this.options.onChunk?.(delta.content);
+      }
+      for (const part of delta.tool_calls ?? []) {
+        const index = part.index ?? calls.size;
+        const call = calls.get(index) ?? { id: "", type: "function", function: { name: "", arguments: "" } };
+        if (part.id) call.id = part.id;
+        if (part.function?.name) call.function.name += part.function.name;
+        if (part.function?.arguments) call.function.arguments += part.function.arguments;
+        calls.set(index, call);
+      }
+    }
+    const toolCalls = [...calls.values()].map((c, i) => ({ ...c, id: c.id || `call_${i}_${Date.now()}` }));
+    return { content, toolCalls };
+  }
+};
+function userContent(text, attachments) {
+  if (attachments.length === 0) return text;
+  const parts = [{ type: "text", text }];
+  for (const file of attachments) {
+    if (file.type === "image") parts.push({ type: "image_url", image_url: { url: `data:${file.mimeType};base64,${file.data}` } });
+    else parts.push({ type: "text", text: `<file name="${file.name ?? "attachment"}">
+${file.text}
+</file>` });
+  }
+  return parts;
+}
+async function* sseData(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let index;
+      while ((index = buffer.search(/\r?\n\r?\n/)) >= 0) {
+        const block = buffer.slice(0, index);
+        buffer = buffer.slice(index).replace(/^\r?\n\r?\n/, "");
+        const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+        if (data) yield data;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/session-manager.ts
+var MAX_SESSIONS_PER_ORIGIN = 4;
+var MAX_TURNS_LIMIT = 50;
+var FORGET_AFTER_MS = 5 * 6e4;
+var TERMINAL = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var SessionManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  // ── Lifecycle ───────────────────────────────────────────────────────
+  prepare(params) {
+    const live = [...this.sessions.values()].filter(
+      (s) => s.params.origin === params.origin && !TERMINAL.has(s.status)
+    );
+    if (live.length >= MAX_SESSIONS_PER_ORIGIN) {
+      throw new Error(
+        `Too many open sessions for this site (${MAX_SESSIONS_PER_ORIGIN}). Close one first.`
+      );
+    }
+    if (params.maxTurns !== void 0) {
+      params.maxTurns = Math.min(Math.max(1, Math.floor(params.maxTurns)), MAX_TURNS_LIMIT);
+    }
+    const id = randomUUID();
+    const channel = this.options.webMcpServer.createChannel(id);
+    const session = {
+      id,
+      status: "pending_approval",
+      params,
+      cwd: this.allocateSandbox(id),
+      createdAt: /* @__PURE__ */ new Date(),
+      turnChunks: [],
+      listeners: /* @__PURE__ */ new Set(),
+      registrationToken: channel.registrationToken,
+      channelToken: channel.channelToken
+    };
+    this.sessions.set(id, session);
+    this.options.logger.info("session prepared", { sessionId: id, origin: params.origin });
+    return this.toInfo(session);
+  }
+  approve(sessionId) {
+    const session = this.require(sessionId);
+    if (session.status !== "pending_approval") {
+      throw new Error(`Session is ${session.status}, expected pending_approval`);
+    }
+    session.status = "running";
+    this.notify(session, "webmcp_ready", this.webmcpReady(session));
+    void this.execute(session);
+    return this.toInfo(session);
+  }
+  promptTurn(sessionId, prompt, attachments = []) {
+    const session = this.require(sessionId);
+    if (!session.live?.isAlive) {
+      throw new Error("Agent session has ended. Start a new session.");
+    }
+    if (session.status !== "idle") {
+      throw new Error(`Session is ${session.status}, expected idle`);
+    }
+    void this.runTurn(session, prompt, attachments);
+    return this.toInfo(session);
+  }
+  async cancelTurn(sessionId) {
+    const session = this.require(sessionId);
+    if (session.status === "running") await session.live?.cancelTurn();
+    return this.toInfo(session);
+  }
+  cancel(sessionId) {
+    const session = this.require(sessionId);
+    if (!TERMINAL.has(session.status)) {
+      session.status = "cancelled";
+      this.teardown(session);
+      this.notify(session, "cancelled", null);
+    }
+    return this.toInfo(session);
+  }
+  close(sessionId) {
+    const session = this.require(sessionId);
+    if (!TERMINAL.has(session.status)) {
+      session.status = "completed";
+      this.teardown(session);
+      this.notify(session, "completed", null);
+    }
+    return this.toInfo(session);
+  }
+  get(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session ? this.toInfo(session) : null;
+  }
+  /** Current-turn text, for SSE replay. */
+  turnChunks(sessionId) {
+    return this.sessions.get(sessionId)?.turnChunks ?? [];
+  }
+  webmcpReady(session) {
+    const s = typeof session === "string" ? this.require(session) : session;
+    return {
+      registrationToken: s.registrationToken,
+      webmcpUrl: `http://127.0.0.1:${this.options.port}`
+    };
+  }
+  addListener(sessionId, listener) {
+    this.sessions.get(sessionId)?.listeners.add(listener);
+  }
+  removeListener(sessionId, listener) {
+    this.sessions.get(sessionId)?.listeners.delete(listener);
+  }
+  /** End every session of an origin, e.g. when its grant is revoked. */
+  /** End the sessions of the origins that match (their AI or model changed): the next message starts a new one. */
+  closeWhere(match) {
+    for (const session of this.sessions.values()) {
+      if (match(session.params.origin)) this.cancel(session.id);
+    }
+  }
+  closeOrigin(origin) {
+    for (const session of this.sessions.values()) {
+      if (session.params.origin === origin) this.cancel(session.id);
+    }
+  }
+  shutdown() {
+    for (const session of this.sessions.values()) {
+      this.teardown(session);
+      session.listeners.clear();
+    }
+    this.sessions.clear();
+  }
+  // ── Internals ───────────────────────────────────────────────────────
+  async execute(session) {
+    const { logger } = this.options;
+    let launch;
+    try {
+      launch = await this.options.resolveAgent(session.params.origin);
+    } catch (err) {
+      this.fail(session, err instanceof Error ? err.message : String(err));
+      return;
+    }
+    if (TERMINAL.has(session.status)) return;
+    const live = launch.llm ? this.llmSession(session, launch.llm) : this.acpSession(session, launch);
+    session.live = live;
+    const timeoutMs = this.options.startTimeoutMs ?? 6e4;
+    let timer;
+    const started = await Promise.race([
+      live.start(),
+      new Promise((resolve) => {
+        timer = setTimeout(
+          () => resolve({ error: `The AI did not start within ${Math.round(timeoutMs / 1e3)} s` }),
+          timeoutMs
+        );
+      })
+    ]);
+    clearTimeout(timer);
+    if (started.error) {
+      if (launch.id && "authRequired" in started && started.authRequired) this.options.onAgentState?.(launch.id, { ok: false });
+      this.fail(session, started.error);
+      return;
+    }
+    if (launch.id) this.options.onAgentState?.(launch.id, { ok: true, models: live.models });
+    logger.info("agent started", { sessionId: session.id, llm: Boolean(launch.llm) });
+    if (session.params.prompt) {
+      await this.runTurn(session, session.params.prompt, session.params.attachments ?? []);
+    } else if (session.status === "running") {
+      session.status = "idle";
+      this.notify(session, "ready", null);
+    }
+  }
+  /** An LLM provider, driven by the engine with the page's tools. */
+  llmSession(session, llm) {
+    const { webMcpServer } = this.options;
+    return new LlmSession({
+      provider: llm.provider,
+      model: llm.model,
+      systemPrompt: session.params.systemPrompt,
+      maxSteps: session.params.maxTurns,
+      tools: {
+        list: () => webMcpServer.listTools(session.id),
+        call: (name, args) => webMcpServer.callTool(session.id, name, args)
+      },
+      onChunk: (text) => {
+        session.turnChunks.push(text);
+        this.notify(session, "chunk", text);
+      },
+      onThought: (text) => this.notify(session, "thought", text),
+      onToolCall: (event) => this.notify(session, "tool_call", event)
+    });
+  }
+  /** An ACP agent process under its policy. */
+  acpSession(session, launch) {
+    const { logger, port } = this.options;
+    const mcpUrl = `http://127.0.0.1:${port}/webmcp/mcp`;
+    const custom = launch.configure?.({
+      sandbox: session.cwd,
+      mcpUrl,
+      mcpToken: session.channelToken,
+      systemPrompt: session.params.systemPrompt,
+      maxTurns: session.params.maxTurns
+    });
+    const live = new AcpLiveSession({
+      command: launch.command,
+      args: launch.args,
+      cwd: session.cwd,
+      envVars: { ...launch.env, ...custom?.env },
+      model: launch.model,
+      mcpServers: custom?.mcpServers ?? ((caps) => {
+        const stdio = this.options.stdioMcpCommand;
+        if (caps.http === false && stdio) {
+          return [
+            {
+              name: WEBMCP_SERVER_NAME,
+              command: stdio.command,
+              args: [...stdio.args, mcpUrl],
+              env: [{ name: "LEURIA_MCP_TOKEN", value: session.channelToken }]
+            }
+          ];
+        }
+        return [
+          {
+            type: "http",
+            name: WEBMCP_SERVER_NAME,
+            url: mcpUrl,
+            headers: [{ name: "Authorization", value: `Bearer ${session.channelToken}` }]
+          }
+        ];
+      }),
+      sessionConfig: {
+        systemPrompt: session.params.systemPrompt,
+        maxTurns: session.params.maxTurns
+      },
+      sessionMeta: custom?.meta,
+      onChunk: (text) => {
+        session.turnChunks.push(text);
+        this.notify(session, "chunk", text);
+      },
+      onThought: (text) => this.notify(session, "thought", text),
+      onToolCall: (event) => this.notify(session, "tool_call", event),
+      onPermission: (decision) => {
+        const level = decision.allow ? "info" : "warn";
+        logger[level]("permission", {
+          sessionId: session.id,
+          tool: decision.toolName,
+          allow: decision.allow
+        });
+        this.notify(session, "permission", {
+          toolName: decision.toolName,
+          allow: decision.allow
+        });
+      },
+      onStderr: (text) => this.notify(session, "log", text),
+      onSpawnError: (err) => this.fail(session, `Failed to start the agent: ${err.message}`),
+      onExit: (code, signal) => {
+        if (TERMINAL.has(session.status)) return;
+        if (code !== 0 && code !== null) {
+          this.fail(session, `Agent exited with code ${code}${signal ? ` (${signal})` : ""}`);
+        } else {
+          session.status = "completed";
+          this.teardown(session);
+          this.notify(session, "completed", null);
+        }
+      }
+    });
+    return live;
+  }
+  async runTurn(session, prompt, attachments) {
+    session.status = "running";
+    session.turnChunks = [];
+    this.notify(session, "turn_start", null);
+    const startedAt = Date.now();
+    const result = await session.live.prompt(prompt, attachments);
+    if (session.status !== "running") return;
+    if (result.error) {
+      this.fail(session, result.error);
+      return;
+    }
+    session.status = "idle";
+    this.options.logger.info("turn completed", {
+      sessionId: session.id,
+      durationMs: Date.now() - startedAt
+    });
+    this.notify(session, "turn_completed", {
+      text: session.turnChunks.join(""),
+      durationMs: Date.now() - startedAt
+    });
+  }
+  fail(session, detail) {
+    if (TERMINAL.has(session.status)) return;
+    session.status = "failed";
+    session.error = detail;
+    this.options.logger.error("session failed", { sessionId: session.id, detail });
+    this.teardown(session);
+    this.notify(session, "failed", detail);
+  }
+  /**
+   * Fresh empty directory per session, so the agent finds no project
+   * files (CLAUDE.md, repo) to act on.
+   */
+  allocateSandbox(sessionId) {
+    const dir = join6(tmpdir3(), `leuria-${sessionId}`);
+    mkdirSync6(dir, { recursive: true });
+    return dir;
+  }
+  teardown(session) {
+    try {
+      session.live?.close();
+    } catch {
+    }
+    session.live = void 0;
+    this.options.webMcpServer.removeChannel(session.id);
+    setTimeout(() => this.sessions.delete(session.id), FORGET_AFTER_MS).unref();
+    try {
+      rmSync4(session.cwd, { recursive: true, force: true });
+    } catch (err) {
+      this.options.logger.warn("failed to remove sandbox", {
+        cwd: session.cwd,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  notify(session, event, data) {
+    for (const listener of session.listeners) {
+      try {
+        listener(event, data);
+      } catch {
+      }
+    }
+  }
+  require(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    return session;
+  }
+  toInfo(session) {
+    return {
+      id: session.id,
+      status: session.status,
+      origin: session.params.origin,
+      createdAt: session.createdAt.toISOString(),
+      error: session.error,
+      ...this.webmcpReady(session)
+    };
+  }
+};
+
+// src/webmcp-server.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { WebSocket, WebSocketServer } from "ws";
+var REQUEST_TIMEOUT_MS = 10 * 60 * 1e3;
+var HTTP_KEEPALIVE_INTERVAL_MS = 2e4;
+var PING_INTERVAL_MS = 15e3;
+var SERVER_NAME = "leuria-webmcp";
+var SUPPORTED_PROTOCOL_VERSIONS = ["2024-11-05", "2025-03-26", "2025-06-18"];
+var SERVER_VERSION = "1.0.0";
+var WebMcpServer = class {
+  constructor(logger, port) {
+    this.logger = logger;
+    this.port = port;
+    this.registerWss = new WebSocketServer({ noServer: true });
+    this.channelWss = new WebSocketServer({ noServer: true });
+  }
+  logger;
+  port;
+  channels = /* @__PURE__ */ new Map();
+  registrationTokens = /* @__PURE__ */ new Map();
+  sessionChannels = /* @__PURE__ */ new Map();
+  tokenToChannel = /* @__PURE__ */ new Map();
+  registerWss;
+  channelWss;
+  // ── Channel lifecycle ────────────────────────────────────────────────
+  /**
+   * Allocate a channel for an ACP session. Returns:
+   *   - `registrationToken` — base64-encoded `{ server, token }` blob the
+   *     browser presents on the `/webmcp/register` WS to claim the channel.
+   *   - `channelToken` — Bearer credential the agent presents on the
+   *     `/webmcp/mcp` HTTP endpoint.
+   *   - `channelId` — server-side handle (used in the channel WS path).
+   */
+  createChannel(sessionId) {
+    const channelId = randomUUID2();
+    const channelToken = randomUUID2();
+    const regTokenRaw = randomUUID2();
+    const channel = {
+      id: channelId,
+      sessionId,
+      token: channelToken,
+      browserWs: null,
+      tools: /* @__PURE__ */ new Map(),
+      resources: /* @__PURE__ */ new Map(),
+      prompts: /* @__PURE__ */ new Map(),
+      pendingRequests: /* @__PURE__ */ new Map(),
+      pingTimer: null
+    };
+    this.channels.set(channelId, channel);
+    this.sessionChannels.set(sessionId, channelId);
+    this.tokenToChannel.set(channelToken, channelId);
+    this.registrationTokens.set(regTokenRaw, { channelId, sessionId });
+    this.logger.info("WebMCP channel created", { channelId, sessionId });
+    const registrationPayload = {
+      server: `ws://127.0.0.1:${this.port}`,
+      token: regTokenRaw
+    };
+    const registrationToken = Buffer.from(
+      JSON.stringify(registrationPayload)
+    ).toString("base64");
+    return { registrationToken, channelToken, channelId };
+  }
+  getChannelSummaries() {
+    return Array.from(this.channels.values()).map((ch) => ({
+      id: ch.id,
+      sessionId: ch.sessionId,
+      connected: ch.browserWs !== null && ch.browserWs.readyState === WebSocket.OPEN,
+      tools: Array.from(ch.tools.values()).map((t) => ({
+        name: t.name,
+        description: t.description
+      })),
+      resources: Array.from(ch.resources.values()).map((r) => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description
+      })),
+      prompts: Array.from(ch.prompts.values()).map((p) => ({
+        name: p.name,
+        description: p.description
+      }))
+    }));
+  }
+  /**
+   * Tear everything down — close the two WebSocketServers, kill every
+   * ping timer, reject every pending request, force-close every browser
+   * channel WS. Called from `daemon.ts`'s `shutdown` so the process can
+   * exit on Ctrl-C; without it the WS servers keep the event loop alive
+   * indefinitely.
+   */
+  close() {
+    for (const channel of this.channels.values()) {
+      if (channel.pingTimer) {
+        clearInterval(channel.pingTimer);
+        channel.pingTimer = null;
+      }
+      for (const [, pending] of channel.pendingRequests) {
+        clearTimeout(pending.timeout);
+        try {
+          pending.reject(new Error("WebMCP server shutting down"));
+        } catch {
+        }
+      }
+      channel.pendingRequests.clear();
+      if (channel.browserWs) {
+        try {
+          channel.browserWs.terminate();
+        } catch {
+        }
+        channel.browserWs = null;
+      }
+    }
+    this.channels.clear();
+    this.tokenToChannel.clear();
+    this.sessionChannels.clear();
+    this.registrationTokens.clear();
+    try {
+      this.registerWss.close();
+    } catch {
+    }
+    try {
+      this.channelWss.close();
+    } catch {
+    }
+  }
+  removeChannel(sessionId) {
+    const channelId = this.sessionChannels.get(sessionId);
+    if (!channelId) return;
+    const channel = this.channels.get(channelId);
+    if (channel) {
+      if (channel.pingTimer) {
+        clearInterval(channel.pingTimer);
+        channel.pingTimer = null;
+      }
+      for (const [, pending] of channel.pendingRequests) {
+        clearTimeout(pending.timeout);
+        pending.reject(new Error("WebMCP channel removed"));
+      }
+      channel.pendingRequests.clear();
+      if (channel.browserWs && channel.browserWs.readyState === WebSocket.OPEN) {
+        channel.browserWs.close(1e3, "channel removed");
+      }
+      this.tokenToChannel.delete(channel.token);
+      this.channels.delete(channelId);
+    }
+    for (const [token, entry] of this.registrationTokens) {
+      if (entry.channelId === channelId) {
+        this.registrationTokens.delete(token);
+      }
+    }
+    this.sessionChannels.delete(sessionId);
+    this.logger.info("WebMCP channel removed", { sessionId, channelId });
+  }
+  // ── In-process access (the engine's own agent loop for LLM providers) ──
+  /** The page tools a session's browser has declared. */
+  listTools(sessionId) {
+    const channelId = this.sessionChannels.get(sessionId);
+    const channel = channelId ? this.channels.get(channelId) : void 0;
+    return channel ? Array.from(channel.tools.values()) : [];
+  }
+  /** Run a page tool in the browser; resolves with its JSON result. Throws on tool errors. */
+  async callTool(sessionId, name, args) {
+    const channelId = this.sessionChannels.get(sessionId);
+    const channel = channelId ? this.channels.get(channelId) : void 0;
+    if (!channel) throw new Error("The page is not connected");
+    if (!channel.tools.has(name)) throw new Error(`Unknown tool: ${name}`);
+    return this.forwardToBrowser(channel, "callTool", { tool: name, arguments: args });
+  }
+  // ── HTTP / WS dispatch (called from daemon) ──────────────────────────
+  /** Returns true when the request path belongs to WebMCP. */
+  matches(pathname) {
+    return pathname.startsWith("/webmcp/");
+  }
+  handleUpgrade(req, socket, head) {
+    const url = new URL(
+      req.url ?? "/",
+      `http://${req.headers.host ?? "127.0.0.1"}`
+    );
+    if (url.pathname === "/webmcp/register") {
+      this.registerWss.handleUpgrade(
+        req,
+        socket,
+        head,
+        (ws) => this.handleRegistrationConnection(ws)
+      );
+      return;
+    }
+    const channelMatch = url.pathname.match(/^\/webmcp\/channel\/([^/]+)$/);
+    if (channelMatch) {
+      const channelId = channelMatch[1];
+      const token = url.searchParams.get("token");
+      const channel = this.channels.get(channelId);
+      if (!channel || channel.token !== token) {
+        this.logger.warn("WebMCP channel auth failed", { channelId });
+        socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+        socket.destroy();
+        return;
+      }
+      this.channelWss.handleUpgrade(
+        req,
+        socket,
+        head,
+        (ws) => this.handleChannelConnection(channel, ws)
+      );
+      return;
+    }
+    socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+    socket.destroy();
+  }
+  async handleHttp(req, res) {
+    const url = new URL(
+      req.url ?? "/",
+      `http://${req.headers.host ?? "127.0.0.1"}`
+    );
+    if (url.pathname !== "/webmcp/mcp") {
+      this.sendJsonRpcError(res, null, -32601, "Not found", 404);
+      return;
+    }
+    if (req.method !== "POST") {
+      this.sendJsonRpcError(res, null, -32600, "Method not allowed", 405);
+      return;
+    }
+    const authHeader = req.headers.authorization;
+    if (!authHeader?.startsWith("Bearer ")) {
+      this.sendJsonRpcError(res, null, -32e3, "Unauthorized", 401);
+      return;
+    }
+    const channelToken = authHeader.slice(7);
+    const channelId = this.tokenToChannel.get(channelToken);
+    if (!channelId) {
+      this.sendJsonRpcError(res, null, -32e3, "Invalid token", 401);
+      return;
+    }
+    const channel = this.channels.get(channelId);
+    if (!channel) {
+      this.sendJsonRpcError(res, null, -32e3, "Channel not found", 404);
+      return;
+    }
+    let body;
+    try {
+      body = await this.parseBody(req);
+    } catch {
+      this.sendJsonRpcError(res, null, -32700, "Parse error", 400);
+      return;
+    }
+    if (!body.method) {
+      this.sendJsonRpcError(
+        res,
+        body.id ?? null,
+        -32600,
+        "Invalid request",
+        400
+      );
+      return;
+    }
+    this.logger.info("WebMCP MCP request", {
+      channelId,
+      method: body.method,
+      toolName: body.method === "tools/call" ? body.params?.name : void 0,
+      toolCount: body.method === "tools/list" ? channel.tools.size : void 0
+    });
+    if (body.id === void 0 || body.id === null) {
+      await this.dispatch(channel, body).catch(() => void 0);
+      res.writeHead(202);
+      res.end();
+      return;
+    }
+    const blocking = body.method === "tools/call" || body.method === "resources/read" || body.method === "prompts/get";
+    if (blocking) {
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-cache"
+      });
+      res.flushHeaders();
+      const keepAlive = setInterval(() => {
+        if (!res.destroyed) res.write("\n");
+      }, HTTP_KEEPALIVE_INTERVAL_MS);
+      try {
+        const result = await this.dispatch(channel, body);
+        clearInterval(keepAlive);
+        this.logger.info("WebMCP MCP response", {
+          channelId,
+          method: body.method,
+          ok: true
+        });
+        const payload = {
+          jsonrpc: "2.0",
+          id: body.id ?? null,
+          result
+        };
+        res.end(JSON.stringify(payload));
+      } catch (err) {
+        clearInterval(keepAlive);
+        const message = err instanceof Error ? err.message : String(err);
+        const unsupported = message.startsWith("Unsupported method");
+        const code = unsupported ? -32601 : message.includes("not connected") ? -32001 : -32603;
+        this.logger[unsupported ? "info" : "warn"]("WebMCP MCP error", {
+          channelId,
+          method: body.method,
+          message
+        });
+        const payload = {
+          jsonrpc: "2.0",
+          id: body.id ?? null,
+          error: { code, message }
+        };
+        res.end(JSON.stringify(payload));
+      }
+      return;
+    }
+    try {
+      const result = await this.dispatch(channel, body);
+      this.sendJsonRpcResult(res, body.id ?? null, result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const unsupported = message.startsWith("Unsupported method");
+      const code = unsupported ? -32601 : message.includes("not connected") ? -32001 : -32603;
+      this.logger[unsupported ? "info" : "warn"]("WebMCP MCP error", {
+        channelId,
+        method: body.method,
+        message
+      });
+      this.sendJsonRpcError(res, body.id ?? null, code, message, 500);
+    }
+  }
+  // ── Browser registration WS ─────────────────────────────────────────
+  handleRegistrationConnection(ws) {
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        ws.send(
+          JSON.stringify({ type: "error", message: "Invalid JSON" })
+        );
+        return;
+      }
+      if (msg.type !== "register" || typeof msg.token !== "string") {
+        ws.send(
+          JSON.stringify({
+            type: "error",
+            message: "Expected register message"
+          })
+        );
+        return;
+      }
+      let regToken = msg.token;
+      try {
+        const decoded = JSON.parse(
+          Buffer.from(regToken, "base64").toString("utf-8")
+        );
+        if (typeof decoded.token === "string") regToken = decoded.token;
+      } catch {
+      }
+      const entry = this.registrationTokens.get(regToken);
+      if (!entry) {
+        ws.send(
+          JSON.stringify({
+            type: "error",
+            message: "Invalid registration token"
+          })
+        );
+        return;
+      }
+      const channel = this.channels.get(entry.channelId);
+      if (!channel) {
+        ws.send(
+          JSON.stringify({ type: "error", message: "Channel not found" })
+        );
+        return;
+      }
+      this.registrationTokens.delete(regToken);
+      ws.send(
+        JSON.stringify({
+          type: "registerSuccess",
+          channel: `/webmcp/channel/${channel.id}`,
+          token: channel.token
+        })
+      );
+      this.logger.info("WebMCP registration success", {
+        channelId: channel.id
+      });
+    });
+  }
+  // ── Browser channel WS ──────────────────────────────────────────────
+  handleChannelConnection(channel, ws) {
+    if (channel.pingTimer) {
+      clearInterval(channel.pingTimer);
+      channel.pingTimer = null;
+    }
+    channel.browserWs = ws;
+    this.logger.info("WebMCP browser connected", { channelId: channel.id });
+    channel.pingTimer = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(JSON.stringify({ type: "ping" }));
+        } catch {
+        }
+      }
+    }, PING_INTERVAL_MS);
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      this.handleChannelMessage(channel, msg);
+    });
+    ws.on("close", () => {
+      if (channel.pingTimer) {
+        clearInterval(channel.pingTimer);
+        channel.pingTimer = null;
+      }
+      channel.browserWs = null;
+      this.logger.info("WebMCP browser disconnected", {
+        channelId: channel.id
+      });
+    });
+    ws.on("error", (err) => {
+      this.logger.error("WebMCP channel WS error", {
+        channelId: channel.id,
+        err: err.message
+      });
+    });
+  }
+  handleChannelMessage(channel, msg) {
+    const type = msg.type;
+    switch (type) {
+      case "registerTool": {
+        const tool = this.parseTool(msg);
+        if (tool) {
+          channel.tools.set(tool.name, tool);
+          this.logger.info("WebMCP tool registered", {
+            channelId: channel.id,
+            name: tool.name,
+            toolCount: channel.tools.size
+          });
+          this.sendAck(channel, "registerTool", tool.name);
+        }
+        return;
+      }
+      case "registerResource": {
+        const resource = this.parseResource(msg);
+        if (resource) {
+          channel.resources.set(resource.uri, resource);
+          this.sendAck(channel, "registerResource", resource.uri);
+        }
+        return;
+      }
+      case "registerPrompt": {
+        const prompt = this.parsePrompt(msg);
+        if (prompt) {
+          channel.prompts.set(prompt.name, prompt);
+          this.sendAck(channel, "registerPrompt", prompt.name);
+        }
+        return;
+      }
+      case "deregisterTool": {
+        const name = msg.name;
+        if (name) channel.tools.delete(name);
+        return;
+      }
+      case "toolResponse":
+      case "resourceResponse":
+      case "promptResponse": {
+        const id = msg.id;
+        if (id) {
+          this.resolveRequest(
+            channel,
+            id,
+            msg.result,
+            msg.error
+          );
+        }
+        return;
+      }
+      case "ping":
+        if (channel.browserWs?.readyState === WebSocket.OPEN) {
+          try {
+            channel.browserWs.send(JSON.stringify({ type: "pong" }));
+          } catch {
+          }
+        }
+        return;
+      case "pong":
+        return;
+      default:
+        return;
+    }
+  }
+  parseTool(msg) {
+    const nested = msg.tool;
+    const src = nested && typeof nested.name === "string" ? nested : msg;
+    if (typeof src.name !== "string") {
+      this.logger.warn("WebMCP registerTool missing name", {});
+      return null;
+    }
+    return {
+      name: src.name,
+      description: src.description,
+      inputSchema: src.inputSchema ?? {
+        type: "object",
+        properties: {}
+      },
+      annotations: src.annotations
+    };
+  }
+  parseResource(msg) {
+    const nested = msg.resource;
+    const src = nested && typeof nested.uri === "string" ? nested : msg;
+    if (typeof src.uri !== "string") {
+      this.logger.warn("WebMCP registerResource missing uri", {});
+      return null;
+    }
+    return {
+      uri: src.uri,
+      name: src.name ?? src.uri,
+      description: src.description,
+      mimeType: src.mimeType
+    };
+  }
+  parsePrompt(msg) {
+    const nested = msg.prompt;
+    const src = nested && typeof nested.name === "string" ? nested : msg;
+    if (typeof src.name !== "string") {
+      this.logger.warn("WebMCP registerPrompt missing name", {});
+      return null;
+    }
+    return {
+      name: src.name,
+      description: src.description,
+      arguments: src.arguments
+    };
+  }
+  sendAck(channel, registration, name) {
+    if (channel.browserWs?.readyState !== WebSocket.OPEN) return;
+    try {
+      channel.browserWs.send(
+        JSON.stringify({ type: "ack", registration, name })
+      );
+    } catch {
+    }
+  }
+  resolveRequest(channel, id, result, error) {
+    const pending = channel.pendingRequests.get(id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    channel.pendingRequests.delete(id);
+    if (error) {
+      const message = typeof error === "string" ? error : error.message ?? "Browser returned error";
+      pending.reject(new Error(message));
+    } else {
+      pending.resolve(result);
+    }
+  }
+  // ── MCP JSON-RPC dispatch ───────────────────────────────────────────
+  async dispatch(channel, req) {
+    switch (req.method) {
+      case "initialize": {
+        const requested = req.params?.protocolVersion;
+        return {
+          protocolVersion: typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : SUPPORTED_PROTOCOL_VERSIONS[SUPPORTED_PROTOCOL_VERSIONS.length - 1],
+          serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+          capabilities: {
+            tools: { listChanged: false },
+            resources: { subscribe: false, listChanged: false },
+            prompts: { listChanged: false }
+          }
+        };
+      }
+      case "tools/list":
+        return {
+          tools: Array.from(channel.tools.values()).map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+            annotations: t.annotations
+          }))
+        };
+      case "tools/call": {
+        const name = req.params?.name;
+        const args = req.params?.arguments;
+        if (!name) throw new Error("Missing tool name");
+        if (!channel.tools.has(name)) {
+          throw new Error(`Unknown tool: ${name}`);
+        }
+        const raw = await this.forwardToBrowser(channel, "callTool", {
+          tool: name,
+          arguments: args
+        });
+        const text = typeof raw === "string" ? raw : JSON.stringify(raw);
+        return { content: [{ type: "text", text }] };
+      }
+      case "resources/list":
+        return {
+          resources: Array.from(channel.resources.values()).map((r) => ({
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType
+          }))
+        };
+      case "resources/read": {
+        const uri = req.params?.uri;
+        if (!uri) throw new Error("Missing resource URI");
+        if (!channel.resources.has(uri)) {
+          throw new Error(`Unknown resource: ${uri}`);
+        }
+        const raw = await this.forwardToBrowser(channel, "readResource", {
+          uri
+        });
+        const text = typeof raw === "string" ? raw : raw?.content ?? JSON.stringify(raw);
+        const mimeType = typeof raw === "object" && raw && "mimeType" in raw ? raw.mimeType ?? "text/plain" : "text/plain";
+        return { contents: [{ uri, text, mimeType }] };
+      }
+      case "prompts/list":
+        return {
+          prompts: Array.from(channel.prompts.values()).map((p) => ({
+            name: p.name,
+            description: p.description,
+            arguments: p.arguments
+          }))
+        };
+      case "prompts/get": {
+        const name = req.params?.name;
+        const args = req.params?.arguments;
+        if (!name) throw new Error("Missing prompt name");
+        if (!channel.prompts.has(name)) {
+          throw new Error(`Unknown prompt: ${name}`);
+        }
+        return await this.forwardToBrowser(channel, "getPrompt", {
+          name,
+          arguments: args
+        });
+      }
+      case "notifications/initialized":
+        return void 0;
+      default:
+        throw new Error(`Unsupported method: ${req.method}`);
+    }
+  }
+  // ── Forwarding agent → browser ──────────────────────────────────────
+  forwardToBrowser(channel, type, payload) {
+    if (!channel.browserWs || channel.browserWs.readyState !== WebSocket.OPEN) {
+      return Promise.reject(
+        new Error("Browser WebSocket not connected to channel")
+      );
+    }
+    const id = randomUUID2();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        channel.pendingRequests.delete(id);
+        reject(
+          new Error(
+            `WebMCP request timed out after ${REQUEST_TIMEOUT_MS}ms (type=${type})`
+          )
+        );
+      }, REQUEST_TIMEOUT_MS);
+      channel.pendingRequests.set(id, { resolve, reject, timeout });
+      try {
+        channel.browserWs.send(
+          JSON.stringify({ type, id, ...payload })
+        );
+      } catch (err) {
+        clearTimeout(timeout);
+        channel.pendingRequests.delete(id);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  // ── HTTP helpers ────────────────────────────────────────────────────
+  parseBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => {
+        try {
+          const raw = Buffer.concat(chunks).toString("utf-8");
+          resolve(raw ? JSON.parse(raw) : {});
+        } catch {
+          reject(new Error("Invalid JSON body"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+  sendJsonRpcResult(res, id, result) {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ jsonrpc: "2.0", id, result }));
+  }
+  sendJsonRpcError(res, id, code, message, httpStatus = 500) {
+    res.writeHead(httpStatus, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        error: { code, message }
+      })
+    );
+  }
+};
+
+// src/server.ts
+var ADMIN_ORIGINS = /^(tauri:\/\/localhost|https?:\/\/tauri\.localhost|http:\/\/(localhost|127\.0\.0\.1):\d+)$/;
+async function startEngine(options) {
+  const port = options.port ?? DEFAULT_PORT;
+  const { logger, grants } = options;
+  const embeddings = options.embeddings ?? localEmbeddings();
+  const selfOrigins = /* @__PURE__ */ new Set([`http://127.0.0.1:${port}`, `http://localhost:${port}`]);
+  const allowedHosts = /* @__PURE__ */ new Set([`127.0.0.1:${port}`, `localhost:${port}`]);
+  const silent = options.silent ?? Boolean(options.admin);
+  const webMcpServer = new WebMcpServer(logger, port);
+  const sessions = new SessionManager({
+    webMcpServer,
+    port,
+    logger,
+    resolveAgent: options.resolveAgent,
+    startTimeoutMs: options.startTimeoutMs,
+    stdioMcpCommand: options.stdioMcpCommand,
+    onAgentState: options.onAgentState
+  });
+  grants.onRemoved((origin) => sessions.closeOrigin(origin));
+  grants.onChanged((origin) => sessions.closeOrigin(origin));
+  const pairing = new Pairing({
+    grants,
+    logger,
+    selfOrigins,
+    port,
+    linksOnly: silent,
+    agentName: () => agentName2(),
+    onRequest: options.onPairingRequest,
+    onDecided: options.onPairingDecided
+  });
+  const agentName2 = typeof options.agentName === "function" ? options.agentName : () => options.agentName;
+  const handleAdmin = async (req, res) => {
+    const admin = options.admin;
+    const origin = req.headers.origin;
+    if (origin) {
+      if (!ADMIN_ORIGINS.test(origin)) {
+        res.statusCode = 403;
+        res.end();
+        return;
+      }
+      res.setHeader("Access-Control-Allow-Origin", origin);
+      res.setHeader("Vary", "Origin");
+    }
+    if (req.method === "OPTIONS") {
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      res.statusCode = 204;
+      res.end();
+      return;
+    }
+    const auth = req.headers.authorization ?? "";
+    const given = Buffer.from(auth.startsWith("Bearer ") ? auth.slice(7) : "");
+    const expected = Buffer.from(admin.token);
+    if (given.length !== expected.length || !timingSafeEqual3(given, expected)) {
+      sendJson(res, 401, { error: "Unauthorized" });
+      return;
+    }
+    const { pathname } = new URL(req.url ?? "/", "http://127.0.0.1");
+    try {
+      if (!await admin.handle(req, res, pathname, pairing, sessions)) sendJson(res, 404, { error: "Not found" });
+    } catch (err) {
+      logger.error("admin request failed", { url: req.url, err: err instanceof Error ? err.message : String(err) });
+      if (!res.headersSent) sendJson(res, 500, { error: err instanceof Error ? err.message : "Internal error" });
+    }
+  };
+  const identify = (req) => {
+    const origin = req.headers.origin;
+    if (!origin) return { kind: "local" };
+    if (selfOrigins.has(origin)) return { kind: "self" };
+    let normalized;
+    try {
+      normalized = normalizeOrigin(origin);
+    } catch {
+      return null;
+    }
+    const auth = req.headers.authorization;
+    const token = auth?.startsWith("Bearer ") ? auth.slice(7) : void 0;
+    return { kind: "site", origin: normalized, authorized: grants.verify(normalized, token) };
+  };
+  const server = http.createServer(async (req, res) => {
+    if (!allowedHosts.has(req.headers.host ?? "")) {
+      sendJson(res, 403, { error: "host not allowed" });
+      return;
+    }
+    if (options.admin && (req.url ?? "").startsWith("/admin/")) {
+      await handleAdmin(req, res);
+      return;
+    }
+    const caller = identify(req);
+    if (!caller) {
+      sendJson(res, 403, { error: "origin not allowed" });
+      return;
+    }
+    const { pathname } = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (caller.kind === "site") {
+      if (silent && !grants.has(caller.origin) && !pairing.hasRequest(caller.origin)) {
+        res.statusCode = 403;
+        res.end();
+        return;
+      }
+      res.setHeader("Access-Control-Allow-Origin", req.headers.origin);
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
+      res.setHeader("Vary", "Origin");
+    }
+    if (req.method === "OPTIONS") {
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      res.setHeader("Access-Control-Max-Age", "600");
+      res.statusCode = 204;
+      res.end();
+      return;
+    }
+    try {
+      if (pathname === "/health" && req.method === "GET") {
+        sendJson(res, 200, {
+          leuria: VERSION,
+          ok: true,
+          // A connected site hears about its own AI and model.
+          agent: caller.kind === "site" && caller.authorized && options.siteAgentName ? options.siteAgentName(caller.origin) : agentName2(),
+          // "app": the desktop app asks the visitor natively; "page": the engine's approval page.
+          approvals: options.admin ? "app" : "page",
+          ...caller.kind === "site" ? { paired: caller.authorized } : {},
+          // A connected site hears which embedding model it would get.
+          ...caller.kind !== "site" || caller.authorized ? { embed: (await embeddings.find())?.model } : {}
+        });
+        return;
+      }
+      if (await pairing.handle(req, res, pathname)) return;
+      if (caller.kind === "self") {
+        sendJson(res, 403, { error: "Forbidden" });
+        return;
+      }
+      if (caller.kind === "site" && !caller.authorized) {
+        sendJson(res, 401, { error: "This site is not connected to Leuria", code: "not_paired" });
+        return;
+      }
+      if (webMcpServer.matches(pathname)) {
+        if (caller.kind === "site") {
+          sendJson(res, 403, { error: "Forbidden" });
+          return;
+        }
+        await webMcpServer.handleHttp(req, res);
+        return;
+      }
+      if (pathname === "/embed" && req.method === "POST") {
+        let request;
+        try {
+          request = parseEmbedBody(await parseBody(req));
+        } catch (error) {
+          sendJson(res, 400, { error: error instanceof Error ? error.message : String(error) });
+          return;
+        }
+        try {
+          sendJson(res, 200, await embeddings.embed(request.texts, request.kind));
+        } catch (error) {
+          const none = error instanceof NoEmbedderError;
+          sendJson(res, none ? 503 : 502, { error: error instanceof Error ? error.message : String(error), ...none ? { code: "no_embedder" } : {} });
+        }
+        return;
+      }
+      const requester = caller.kind === "site" ? caller.origin : "local";
+      if (await handleSessionRequest(req, res, pathname, sessions, requester)) return;
+      sendJson(res, 404, { error: "Not found" });
+    } catch (err) {
+      logger.error("request failed", {
+        url: req.url,
+        err: err instanceof Error ? err.message : String(err)
+      });
+      if (!res.headersSent) sendJson(res, 500, { error: "Internal error" });
+    }
+  });
+  server.on("upgrade", (req, socket, head) => {
+    const { pathname } = new URL(req.url ?? "/", "http://127.0.0.1");
+    const caller = allowedHosts.has(req.headers.host ?? "") ? identify(req) : null;
+    const allowed = caller !== null && (caller.kind === "local" || caller.kind === "site" && grants.has(caller.origin));
+    if (!allowed || !webMcpServer.matches(pathname)) {
+      logger.warn("upgrade rejected", { origin: req.headers.origin, url: pathname });
+      socket.write(`HTTP/1.1 ${allowed ? "404 Not Found" : "403 Forbidden"}\r
+\r
+`);
+      socket.destroy();
+      return;
+    }
+    webMcpServer.handleUpgrade(req, socket, head);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+  const boundPort = server.address().port;
+  return {
+    port: boundPort,
+    pairing,
+    sessions,
+    revoke: (origin) => grants.revoke(origin),
+    close: async () => {
+      sessions.shutdown();
+      webMcpServer.close();
+      server.closeAllConnections();
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+// src/logger.ts
+function createLogger(verbose = false) {
+  const write = (level) => (msg, meta) => {
+    if (level === "info" && !verbose) return;
+    const suffix = meta ? ` ${JSON.stringify(meta)}` : "";
+    process.stderr.write(
+      `${(/* @__PURE__ */ new Date()).toISOString()} ${level.padEnd(5)} ${msg}${suffix}
+`
+    );
+  };
+  return { info: write("info"), warn: write("warn"), error: write("error") };
+}
+
+export {
+  fetchRegistry,
+  getRegistryEntry,
+  DEFAULT_PORT,
+  leuriaHome,
+  homePath,
+  loadConfig,
+  isKnownReady,
+  saveConfig,
+  isLlmId,
+  llmId,
+  parseLlmId,
+  getProvider,
+  saveProvider,
+  removeProvider,
+  normalizeBaseUrl,
+  listModels,
+  detectLlms,
+  WEBMCP_SERVER_NAME,
+  buildSessionMeta,
+  decidePermission,
+  installedAgent,
+  ensureAgent,
+  resolveAgentCommand,
+  resolveSiteAgent,
+  agentName,
+  resetAgent,
+  isAvailable,
+  listAgents,
+  VERSION,
+  agentModels,
+  seenAgentModels,
+  aiLabel,
+  rememberAgentState,
+  checkSignIn,
+  signIn,
+  parseNeeds,
+  detectInstalledClis,
+  listLocalEmbedders,
+  localEmbeddings,
+  sendJson,
+  parseBody,
+  GrantStore,
+  normalizeOrigin,
+  startEngine,
+  createLogger
+};