pelican-cc 0.0.0-stage → 0.2.2

package/dist/server/index.js

@@ -0,0 +1,4226 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "pelican-cc",
+      version: "0.2.2",
+      description: "Your Claude Code sessions, from any browser: a phone-first web app that runs next to Claude Code.",
+      keywords: [
+        "claude",
+        "claude-code",
+        "agent",
+        "mobile",
+        "web-ui",
+        "ai-coding"
+      ],
+      homepage: "https://github.com/Ki-Seki/pelican#readme",
+      bugs: "https://github.com/Ki-Seki/pelican/issues",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/Ki-Seki/pelican.git"
+      },
+      license: "MIT",
+      author: "Shichao Song",
+      type: "module",
+      bin: {
+        pelican: "dist/server/index.js"
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "CHANGELOG.md"
+      ],
+      engines: {
+        node: ">=22.12"
+      },
+      scripts: {
+        dev: "node scripts/dev.mjs",
+        demo: "node dist/server/index.js --demo",
+        build: "vite build && node scripts/build-server.mjs",
+        start: "node dist/server/index.js",
+        typecheck: "tsc --noEmit -p tsconfig.json",
+        test: "vitest run",
+        screenshots: "node scripts/screenshots.mjs",
+        prepublishOnly: "npm run typecheck && npm test && npm run build"
+      },
+      dependencies: {
+        "@anthropic-ai/claude-agent-sdk": "^0.3.318",
+        "@hono/node-server": "^2.1.6",
+        hono: "^4.13.16",
+        "qrcode-generator": "^1.4.4",
+        "web-push": "^3.6.7",
+        ws: "^8.22.1"
+      },
+      devDependencies: {
+        "@tailwindcss/vite": "^4.3.4",
+        "@tanstack/react-query": "^5.105.3",
+        "@testing-library/react": "^16.3.0",
+        "@types/node": "^24.0.0",
+        "@types/react": "^19.1.0",
+        "@types/react-dom": "^19.1.0",
+        "@types/web-push": "^3.6.4",
+        "@types/ws": "^8.18.1",
+        "@vitejs/plugin-react": "^6.2.1",
+        diff: "^9.0.0",
+        esbuild: "^0.27.0",
+        jsdom: "^27.0.0",
+        "lucide-react": "^1.68.0",
+        "playwright-core": "^1.64.1",
+        react: "^19.3.1",
+        "react-dom": "^19.3.1",
+        "react-markdown": "^10.1.0",
+        "rehype-highlight": "^7.0.2",
+        "remark-breaks": "^4.0.0",
+        "remark-gfm": "^4.0.1",
+        tailwindcss: "^4.3.4",
+        tsx: "^4.23.15",
+        typescript: "^7.0.2",
+        vite: "^8.3.5",
+        vitest: "^5.1.0"
+      }
+    };
+  }
+});
+
+// src/server/config.ts
+var config_exports = {};
+__export(config_exports, {
+  config: () => config,
+  configWarnings: () => configWarnings
+});
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function findWebDir() {
+  for (const candidate of [path.join(here, "../web"), path.join(here, "../../dist/web")]) {
+    if (existsSync(path.join(candidate, "index.html"))) return candidate;
+  }
+  return void 0;
+}
+function origins(name, value, wildcardHost = false) {
+  const kept = [];
+  for (const entry of (value ?? "").split(/[\s,]+/).filter(Boolean)) {
+    const wildcard = wildcardHost && /^https?:\/\/\*\.[^*]+$/i.test(entry);
+    let url;
+    try {
+      url = /^https?:\/\//i.test(entry) ? new URL(wildcard ? entry.replace("*.", "wildcard.") : entry) : void 0;
+    } catch {
+      url = void 0;
+    }
+    const origin = url && (wildcard ? url.origin.replace("://wildcard.", "://*.") : url.origin);
+    if (url && origin && url.pathname === "/" && !url.search && !url.hash && !url.username && !url.password && (wildcard ? /^https?:\/\/\*\.[a-z0-9.-]+(:\d+)?$/ : /^https?:\/\/([a-z0-9.-]+|\[[0-9a-f:.]+\])(:\d+)?$/).test(origin)) {
+      kept.push(origin);
+    } else {
+      configWarnings.push(`${name}: ignored "${entry}"; use an origin like https://pelican.example.com`);
+    }
+  }
+  return kept;
+}
+var here, home, list, configWarnings, config;
+var init_config = __esm({
+  "src/server/config.ts"() {
+    "use strict";
+    here = path.dirname(fileURLToPath(import.meta.url));
+    home = os.homedir();
+    list = (value) => (value ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    configWarnings = [];
+    config = {
+      host: process.env.PELICAN_HOST ?? "127.0.0.1",
+      port: Number(process.env.PELICAN_PORT ?? 7860),
+      /** Name shown in the app, for telling machines apart. */
+      machine: process.env.PELICAN_MACHINE ?? (os.hostname().split(".")[0] || "local"),
+      home,
+      claudeHome: process.env.CLAUDE_CONFIG_DIR ?? path.join(home, ".claude"),
+      /** The password hash lives here. */
+      configDir: process.env.PELICAN_CONFIG_DIR ?? path.join(home, ".config", "pelican"),
+      /** Uploads, push keys and subscriptions. */
+      stateDir: process.env.PELICAN_STATE_DIR ?? path.join(home, ".local", "state", "pelican"),
+      webDir: findWebDir(),
+      /**
+       * auto: sign in with the password when one is set (`pelican password`), else
+       * with the access token in the link Pelican prints. none: no sign-in, for
+       * when something in front already authenticates (a proxy, a gateway).
+       */
+      auth: process.env.PELICAN_AUTH === "none" ? "none" : "auto",
+      /** Origins, besides the page's own, allowed to send requests (for example a proxy's public URL). */
+      allowedOrigins: origins("PELICAN_ALLOWED_ORIGINS", process.env.PELICAN_ALLOWED_ORIGINS),
+      /** Host names the server answers to, besides this machine's own names and addresses (and *.ts.net). */
+      allowedHosts: list(process.env.PELICAN_ALLOWED_HOSTS),
+      /**
+       * A proxy on this machine (Tailscale, Caddy, nginx) sets X-Forwarded-For truthfully: limit sign-in
+       * attempts by the client it names. Off by default, since anyone can write that header.
+       */
+      trustedProxy: process.env.PELICAN_TRUSTED_PROXY === "1",
+      /** Pages, besides Pelican's own origin, that may show Pelican in a frame (space or comma separated). */
+      frameAncestors: origins("PELICAN_FRAME_ANCESTORS", process.env.PELICAN_FRAME_ANCESTORS, true),
+      /** Where a tapped notification opens a session; `{id}` is replaced. Default: the page that subscribed. */
+      sessionUrl: process.env.PELICAN_SESSION_URL || void 0,
+      /** A Claude process with nothing to do is closed after this long; the next message resumes the session. */
+      idleCloseMs: Number(process.env.PELICAN_IDLE_CLOSE_MS ?? 30 * 60 * 1e3),
+      /** A transcript written by someone else this recently counts as live. */
+      liveWindowMs: 45e3,
+      claudeExecutable: process.env.PELICAN_CLAUDE_PATH || void 0,
+      /** Demo mode: made-up sessions, nothing runs. */
+      demo: false
+    };
+  }
+});
+
+// src/server/security.ts
+import os2 from "node:os";
+function isLoopback(host) {
+  const h = hostname(host);
+  return h === "localhost" || h.endsWith(".localhost") || h === "::1" || /^127(\.\d{1,3}){3}$/.test(h);
+}
+function listensLocally(host) {
+  return isLoopback(host);
+}
+function knownHosts() {
+  const names = /* @__PURE__ */ new Set();
+  const machine = os2.hostname().toLowerCase();
+  names.add(machine);
+  names.add(machine.split(".")[0]);
+  for (const address of Object.values(os2.networkInterfaces()).flat()) if (address) names.add(address.address.toLowerCase());
+  if (config.host !== "0.0.0.0" && config.host !== "::") names.add(hostname(config.host));
+  for (const host of config.allowedHosts) {
+    const name = hostname(host);
+    if (name) names.add(name);
+  }
+  for (const origin of config.allowedOrigins) {
+    try {
+      names.add(new URL(origin).hostname.toLowerCase().replace(/^\[(.*)\]$/, "$1"));
+    } catch {
+    }
+  }
+  return names;
+}
+function hostAllowed(host) {
+  if (!host) return false;
+  const name = hostname(host);
+  if (!name) return false;
+  if (isLoopback(host)) return true;
+  if (name.endsWith(".ts.net")) return true;
+  return knownHosts().has(name);
+}
+function originAllowed(origin, ...hosts) {
+  if (!origin) return true;
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (config.allowedOrigins.includes(url.origin)) return true;
+  return hosts.flatMap((h) => h ? h.split(",").map((s) => s.trim()) : []).includes(url.host);
+}
+var hostname;
+var init_security = __esm({
+  "src/server/security.ts"() {
+    "use strict";
+    init_config();
+    hostname = (host) => {
+      const h = host.trim().toLowerCase();
+      if (h.startsWith("[")) return h.slice(1, h.indexOf("]"));
+      const colon = h.lastIndexOf(":");
+      return colon > -1 && h.indexOf(":") === colon ? h.slice(0, colon) : h;
+    };
+  }
+});
+
+// src/server/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  accessToken: () => accessToken,
+  attemptAllowed: () => attemptAllowed,
+  authMode: () => authMode,
+  beginAttempt: () => beginAttempt,
+  checkPassword: () => checkPassword,
+  checkToken: () => checkToken,
+  clearPassword: () => clearPassword,
+  cookieName: () => cookieName,
+  issueCode: () => issueCode,
+  loadAuth: () => loadAuth,
+  newSessionCookie: () => newSessionCookie,
+  noteFailure: () => noteFailure,
+  passwordSet: () => passwordSet,
+  redeemCode: () => redeemCode,
+  resetAttempts: () => resetAttempts,
+  resetToken: () => resetToken,
+  setPassword: () => setPassword,
+  signedIn: () => signedIn
+});
+import { createHash, createHmac, randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+function derive(text2, salt, params) {
+  return new Promise((resolve, reject) => {
+    scrypt(text2.normalize("NFKC"), salt, 32, { ...params, maxmem: 64 * 1024 * 1024 }, (error, key) => error ? reject(error) : resolve(key));
+  });
+}
+async function writePrivate(file2, value) {
+  await mkdir(path2.dirname(file2), { recursive: true, mode: 448 });
+  await writeFile(file2, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+}
+async function loadAuth() {
+  if (loaded) return;
+  password = await readJson(passwordFile());
+  if (config.auth !== "none") {
+    token = await readJson(tokenFile());
+    if (!token?.token || !token.secret) await resetToken();
+  }
+  loaded = true;
+}
+function authMode() {
+  if (config.auth === "none") return "none";
+  return password ? "password" : "token";
+}
+function passwordSet() {
+  return Boolean(password);
+}
+function accessToken() {
+  return authMode() === "token" ? token?.token : void 0;
+}
+async function resetToken() {
+  token = { version: 1, token: randomBytes(24).toString("base64url"), secret: randomBytes(32).toString("base64") };
+  await writePrivate(tokenFile(), token);
+  return token.token;
+}
+async function setPassword(text2) {
+  const salt = randomBytes(16);
+  const hash = await derive(text2, salt, PARAMS);
+  password = { version: 1, salt: salt.toString("base64"), hash: hash.toString("base64"), secret: randomBytes(32).toString("base64"), ...PARAMS };
+  await writePrivate(passwordFile(), password);
+  loaded = true;
+}
+async function clearPassword() {
+  await rm(passwordFile(), { force: true });
+  password = void 0;
+}
+async function checkPassword(text2) {
+  if (!password) return false;
+  const expected = Buffer.from(password.hash, "base64");
+  const actual = await derive(text2, Buffer.from(password.salt, "base64"), password);
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function checkToken(given) {
+  const current = accessToken();
+  return Boolean(current && given && same(given, current));
+}
+function cookieName() {
+  const value = secret();
+  return `pelican_${value ? createHash("sha256").update(value).digest("hex").slice(0, 8) : "none"}`;
+}
+function sign(expires) {
+  return createHmac("sha256", Buffer.from(secret() ?? "", "base64")).update(String(expires)).digest("base64url");
+}
+function newSessionCookie() {
+  const maxAge = SESSION_DAYS * 24 * 3600;
+  const expires = Date.now() + maxAge * 1e3;
+  return { name: cookieName(), value: `${expires}.${sign(expires)}`, maxAge };
+}
+function cookieValue(header, name) {
+  for (const part of (header ?? "").split(";")) {
+    const [key, ...rest] = part.trim().split("=");
+    if (key === name) return rest.join("=");
+  }
+  return void 0;
+}
+function signedIn(cookieHeader2, authorization) {
+  const mode = authMode();
+  if (mode === "none") return true;
+  if (mode === "token" && authorization?.startsWith("Bearer ") && checkToken(authorization.slice(7).trim())) return true;
+  if (!secret()) return false;
+  const value = cookieValue(cookieHeader2, cookieName());
+  if (!value) return false;
+  const [expires, mac] = value.split(".");
+  const when = Number(expires);
+  if (!mac || !Number.isFinite(when) || when < Date.now()) return false;
+  const expected = Buffer.from(sign(when));
+  const given = Buffer.from(mac);
+  return expected.length === given.length && timingSafeEqual(expected, given);
+}
+function attemptAllowed(client, now = Date.now()) {
+  allFailures = recent(allFailures, now);
+  if (allFailures.length >= IN_ALL) return false;
+  return recent(failures.get(client) ?? [], now).length < PER_CLIENT;
+}
+function noteFailure(client, now = Date.now()) {
+  allFailures.push(now);
+  failures.set(client, [...recent(failures.get(client) ?? [], now), now]);
+  if (failures.size > 1e3) {
+    for (const [key, times] of failures) if (recent(times, now).length === 0) failures.delete(key);
+    while (failures.size > 5e3) failures.delete(failures.keys().next().value);
+  }
+}
+function beginAttempt(client, now = Date.now()) {
+  if (!attemptAllowed(client, now)) return void 0;
+  noteFailure(client, now);
+  return () => {
+    const drop = (times) => {
+      const at = times?.lastIndexOf(now) ?? -1;
+      if (times && at >= 0) times.splice(at, 1);
+    };
+    drop(allFailures);
+    drop(failures.get(client));
+  };
+}
+function resetAttempts() {
+  failures.clear();
+  allFailures = [];
+}
+function issueCode(now = Date.now()) {
+  for (const [code2, expires] of codes) if (expires <= now) codes.delete(code2);
+  while (codes.size >= 20) codes.delete(codes.keys().next().value);
+  const code = randomBytes(18).toString("base64url");
+  codes.set(code, now + CODE_MS);
+  return code;
+}
+function redeemCode(given, now = Date.now()) {
+  if (!given || authMode() === "none") return false;
+  for (const [code, expires] of codes) {
+    if (same(code, given)) {
+      codes.delete(code);
+      return expires > now;
+    }
+  }
+  return false;
+}
+var passwordFile, tokenFile, SESSION_DAYS, PARAMS, password, token, loaded, readJson, same, secret, WINDOW_MS, PER_CLIENT, IN_ALL, failures, allFailures, recent, CODE_MS, codes;
+var init_auth = __esm({
+  "src/server/auth.ts"() {
+    "use strict";
+    init_config();
+    passwordFile = () => path2.join(config.configDir, "auth.json");
+    tokenFile = () => path2.join(config.configDir, "token.json");
+    SESSION_DAYS = 30;
+    PARAMS = { N: 16384, r: 8, p: 1 };
+    loaded = false;
+    readJson = async (file2) => {
+      try {
+        return JSON.parse(await readFile(file2, "utf8"));
+      } catch {
+        return void 0;
+      }
+    };
+    same = (a, b) => {
+      const x = createHash("sha256").update(a).digest();
+      const y = createHash("sha256").update(b).digest();
+      return timingSafeEqual(x, y);
+    };
+    secret = () => authMode() === "password" ? password?.secret : authMode() === "token" ? token?.secret : void 0;
+    WINDOW_MS = 10 * 6e4;
+    PER_CLIENT = 10;
+    IN_ALL = 30;
+    failures = /* @__PURE__ */ new Map();
+    allFailures = [];
+    recent = (times, now) => times.filter((t) => now - t < WINDOW_MS);
+    CODE_MS = 2 * 6e4;
+    codes = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/demo-image.ts
+var SETTINGS_SCREENSHOT;
+var init_demo_image = __esm({
+  "src/server/demo-image.ts"() {
+    "use strict";
+    SETTINGS_SCREENSHOT = "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";
+  }
+});
+
+// src/server/demo-visuals.ts
+function signupsChart() {
+  const max = Math.max(...SIGNUPS);
+  const bars = SIGNUPS.map((value, i) => {
+    const h = Math.round(value / max * 128);
+    const x = 26 + i * 52;
+    const y = 196 - h;
+    const tone = value === max ? "c-purple" : "c-teal";
+    return `<g class="${tone}"><rect x="${x}" y="${y}" width="38" height="${h}" rx="6"/></g><text class="ts" x="${x + 19}" y="${y - 8}" text-anchor="middle">${(value / 1e3).toFixed(1)}k</text><text class="ts" x="${x + 19}" y="216" text-anchor="middle">${DAYS[i]}</text>`;
+  }).join("");
+  return `<svg width="100%" viewBox="0 0 400 228" role="img"><title>Signups by day, last week</title><text class="th" x="16" y="24">Signups by day \xB7 last week</text><text class="ts" x="16" y="42">12,480 in total, 18% more than the week before</text><line x1="16" y1="196.5" x2="384" y2="196.5" style="stroke:var(--line)"/>${bars}</svg>`;
+}
+var DAYS, SIGNUPS, SIGNUPS_CSV, REPORT_HTML;
+var init_demo_visuals = __esm({
+  "src/server/demo-visuals.ts"() {
+    "use strict";
+    DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+    SIGNUPS = [1420, 1588, 1710, 2214, 1966, 1702, 1880];
+    SIGNUPS_CSV = `day,signups
+${DAYS.map((d, i) => `${d},${SIGNUPS[i]}`).join("\n")}
+`;
+    REPORT_HTML = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Signups \xB7 week 45</title>
+<style>
+  :root { color-scheme: light dark; --ink: #17181a; --soft: #6b6e75; --line: #e6e6e3; --card: #fff; --bg: #f6f6f3; --a: #0e7490; --b: #7c6cf2; }
+  @media (prefers-color-scheme: dark) { :root { --ink: #ececea; --soft: #a5a8ae; --line: #2a2d31; --card: #16181b; --bg: #0e0f11; --a: #3ba7bd; --b: #9d90f5; } }
+  * { box-sizing: border-box; margin: 0; }
+  body { background: var(--bg); color: var(--ink); font: 15px/1.55 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; padding: 28px 20px 40px; }
+  main { max-width: 640px; margin: 0 auto; }
+  .eyebrow { color: var(--a); font-weight: 600; font-size: 13px; letter-spacing: .02em; }
+  h1 { margin-top: 6px; font-size: 30px; line-height: 1.1; letter-spacing: -.03em; }
+  .kpis { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; margin-top: 22px; }
+  .kpi { background: var(--card); border: 1px solid var(--line); border-radius: 14px; padding: 14px; }
+  .kpi b { display: block; font-size: 24px; letter-spacing: -.02em; font-variant-numeric: tabular-nums; }
+  .kpi span { color: var(--soft); font-size: 12.5px; }
+  .up { color: #16a34a; }
+  .chart { margin-top: 14px; background: var(--card); border: 1px solid var(--line); border-radius: 14px; padding: 16px 14px 10px; }
+  .bars { display: flex; align-items: flex-end; gap: 8px; height: 170px; }
+  .bar { flex: 1; display: flex; flex-direction: column; align-items: center; justify-content: flex-end; gap: 6px; height: 100%; }
+  .bar i { display: block; width: 100%; border-radius: 8px 8px 4px 4px; background: color-mix(in srgb, var(--a) 75%, transparent); height: 0; transition: height .9s cubic-bezier(.2,.8,.2,1); }
+  .bar.top i { background: var(--b); }
+  .bar small { color: var(--soft); font-size: 11.5px; }
+  p.note { margin-top: 16px; color: var(--soft); }
+</style>
+</head>
+<body>
+<main>
+  <div class="eyebrow">Growth \xB7 week 45</div>
+  <h1>Signups grew 18%, and Thursday led the week</h1>
+  <div class="kpis">
+    <div class="kpi"><b data-count="12480">0</b><span>signups</span></div>
+    <div class="kpi"><b class="up">+18%</b><span>on week 44</span></div>
+    <div class="kpi"><b>Thu</b><span>best day, 2,214</span></div>
+  </div>
+  <div class="chart"><div class="bars" id="bars"></div></div>
+  <p class="note">Thursday's newsletter brought the peak; the weekend held above the weekday average.</p>
+</main>
+<script>
+  const days = ${JSON.stringify(DAYS)};
+  const values = ${JSON.stringify(SIGNUPS)};
+  const max = Math.max(...values);
+  const bars = document.getElementById('bars');
+  values.forEach((v, i) => {
+    const bar = document.createElement('div');
+    bar.className = 'bar' + (v === max ? ' top' : '');
+    bar.innerHTML = '<small>' + v.toLocaleString() + '</small><i></i><small>' + days[i] + '</small>';
+    bars.append(bar);
+    requestAnimationFrame(() => requestAnimationFrame(() => { bar.querySelector('i').style.height = (v / max * 120) + 'px'; }));
+  });
+  for (const el of document.querySelectorAll('[data-count]')) {
+    const end = Number(el.dataset.count); const start = performance.now();
+    const step = (t) => { const k = Math.min(1, (t - start) / 900); el.textContent = Math.round(end * (1 - Math.pow(1 - k, 3))).toLocaleString(); if (k < 1) requestAnimationFrame(step); };
+    requestAnimationFrame(step);
+  }
+</script>
+</body>
+</html>
+`;
+  }
+});
+
+// src/server/demo.ts
+var demo_exports = {};
+__export(demo_exports, {
+  DEMO_LIVE_SESSION: () => DEMO_LIVE_SESSION,
+  DEMO_MODELS: () => DEMO_MODELS,
+  DEMO_WAITING_SESSION: () => DEMO_WAITING_SESSION,
+  demoRunState: () => demoRunState,
+  prepareDemo: () => prepareDemo
+});
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+import { promisify } from "node:util";
+function numbered(source) {
+  return source.split("\n").map((line, i) => `${String(i + 1).padStart(6)}	${line}`).join("\n");
+}
+async function demoRepository(dir) {
+  const env = { ...process.env, GIT_AUTHOR_NAME: "Demo", GIT_AUTHOR_EMAIL: "demo@example.com", GIT_COMMITTER_NAME: "Demo", GIT_COMMITTER_EMAIL: "demo@example.com" };
+  const git2 = (args) => run("git", ["-c", "commit.gpgsign=false", "-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false", "-c", "init.templateDir=", ...args], { cwd: dir, env, timeout: 1e4 });
+  try {
+    await git2(["init", "-q", "-b", "feat/dark-theme"]);
+    await rm2(path3.join(dir, "src/settings/ThemeToggle.tsx"), { force: true });
+    await git2(["add", "-A"]);
+    await git2(["commit", "-q", "--no-verify", "-m", "Settings page"]);
+    await writeFile2(path3.join(dir, "src/styles/theme.css"), DARK_CSS);
+    await writeFile2(path3.join(dir, "src/settings/ThemeToggle.tsx"), TOGGLE_TSX);
+  } catch {
+  }
+}
+async function prepareDemo() {
+  const root = path3.join(config.stateDir, "demo");
+  await rm2(root, { recursive: true, force: true });
+  const claudeHome = path3.join(root, ".claude");
+  for (const [project, files] of Object.entries(DEMO_FILES)) {
+    for (const file2 of files) {
+      const full = path3.join(root, "code", project, file2);
+      await mkdir2(path3.dirname(full), { recursive: true });
+      await writeFile2(full, FILE_TEXT[`${project}/${file2}`] ?? "");
+    }
+  }
+  await demoRepository(path3.join(root, "code", "acme-web"));
+  for (const session of SESSIONS) {
+    const cwd = session.scratch ? path3.join(root, "scratch", "2026-11-04-7c2e") : path3.join(root, "code", session.project);
+    await mkdir2(cwd, { recursive: true });
+    const dir = path3.join(claudeHome, "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+    await mkdir2(dir, { recursive: true });
+    let parent = null;
+    const lines = [JSON.stringify({ type: "custom-title", customTitle: session.title, sessionId: session.id })];
+    for (const row of session.rows(cwd)) {
+      const uuid = randomUUID();
+      const message = row.role === "assistant" ? { id: `msg_demo_${uuid.slice(0, 8)}`, type: "message", role: "assistant", model: "claude-opus-5-5", content: row.content } : { role: "user", content: row.content };
+      lines.push(JSON.stringify({
+        parentUuid: parent,
+        isSidechain: false,
+        userType: "external",
+        cwd,
+        sessionId: session.id,
+        version: "2.1.318",
+        gitBranch: session.branch,
+        type: row.role,
+        message,
+        uuid,
+        timestamp: new Date(row.at).toISOString()
+      }));
+      parent = uuid;
+    }
+    await writeFile2(path3.join(dir, `${session.id}.jsonl`), `${lines.join("\n")}
+`);
+  }
+  config.home = root;
+  config.claudeHome = claudeHome;
+  config.configDir = path3.join(root, "config");
+  config.stateDir = path3.join(root, "state");
+  process.env.CLAUDE_CONFIG_DIR = claudeHome;
+  process.env.PELICAN_SCRATCH_DIR = path3.join(root, "scratch");
+}
+function demoRunState(sessionId) {
+  const first = SESSIONS[0];
+  if (sessionId !== first.id) return void 0;
+  const cwd = path3.join(config.home, "code", first.project);
+  return {
+    sessionId,
+    cwd,
+    busy: true,
+    settings: { model: "default", effort: "high", permissionMode: "default" },
+    partial: [],
+    permissions: [{
+      id: "demo-permission",
+      sessionId,
+      toolName: "Edit",
+      input: {
+        file_path: `${cwd}/src/settings/Settings.tsx`,
+        old_string: "      <FontSizePicker />\n    </Section>",
+        new_string: "      <FontSizePicker />\n      <ThemeToggle value={theme} onChange={setTheme} />\n    </Section>"
+      },
+      canRemember: true,
+      createdAt: Date.now() - 2e4
+    }],
+    context: { percent: 31, tokens: 62e3, max: 2e5 }
+  };
+}
+var run, MIN, HOUR, tool, result, text, THEME_CSS, SESSIONS, SETTINGS_TSX, TOGGLE_TSX, DARK_CSS, FILE_TEXT, DEMO_FILES, DEMO_MODELS, DEMO_LIVE_SESSION, DEMO_WAITING_SESSION;
+var init_demo = __esm({
+  "src/server/demo.ts"() {
+    "use strict";
+    init_config();
+    init_demo_image();
+    init_demo_visuals();
+    run = promisify(execFile);
+    MIN = 6e4;
+    HOUR = 60 * MIN;
+    tool = (id, name, input) => ({ type: "tool_use", id, name, input });
+    result = (id, content, isError = false) => ({ type: "tool_result", tool_use_id: id, content, ...isError ? { is_error: true } : {} });
+    text = (value) => ({ type: "text", text: value });
+    THEME_CSS = `:root {
+  --bg: #ffffff;
+  --fg: #111111;
+  --muted: #6b6b6b;
+  --accent: #2563eb;
+}
+
+body {
+  background: var(--bg);
+  color: var(--fg);
+}`;
+    SESSIONS = [
+      {
+        id: "a3f1c2d4-1111-4a1b-8c3d-000000000001",
+        title: "Add a dark theme to the settings page",
+        project: "acme-web",
+        branch: "feat/dark-theme",
+        rows: (cwd) => {
+          const t = Date.now() - 4 * MIN;
+          return [
+            {
+              role: "user",
+              at: t,
+              content: [
+                { type: "image", source: { type: "base64", media_type: "image/png", data: SETTINGS_SCREENSHOT } },
+                text("Add a dark theme to the settings page, with a toggle. Keep the colors in CSS variables.")
+              ]
+            },
+            { role: "assistant", at: t + 4e3, content: [text("I'll look at how the colors are set up first."), tool("t1", "Read", { file_path: `${cwd}/src/styles/theme.css` })] },
+            { role: "user", at: t + 5e3, content: [result("t1", numbered(THEME_CSS))] },
+            {
+              role: "assistant",
+              at: t + 9e3,
+              content: [
+                text("The colors are already variables, so a dark theme is one more set of values plus a toggle that switches them."),
+                tool("t2", "TodoWrite", {
+                  todos: [
+                    { content: "Add dark color values", status: "completed", activeForm: "Adding dark color values" },
+                    { content: "Add the toggle to Settings", status: "in_progress", activeForm: "Adding the toggle to Settings" },
+                    { content: "Remember the choice", status: "pending", activeForm: "Remembering the choice" },
+                    { content: "Run the tests", status: "pending", activeForm: "Running the tests" }
+                  ]
+                })
+              ]
+            },
+            { role: "user", at: t + 9500, content: [result("t2", "Todos have been modified successfully.")] },
+            {
+              role: "assistant",
+              at: t + 14e3,
+              content: [tool("t3", "Edit", {
+                file_path: `${cwd}/src/styles/theme.css`,
+                old_string: "  --accent: #2563eb;\n}",
+                new_string: "  --accent: #2563eb;\n}\n\n:root[data-theme='dark'] {\n  --bg: #0b0b0c;\n  --fg: #ededed;\n  --muted: #a1a1a1;\n  --accent: #60a5fa;\n}"
+              })]
+            },
+            { role: "user", at: t + 15e3, content: [result("t3", `The file ${cwd}/src/styles/theme.css has been updated successfully.`)] },
+            { role: "assistant", at: t + 19e3, content: [text("Now the toggle itself, next to the other display settings:")] }
+          ];
+        }
+      },
+      {
+        id: "b7e2a9c1-2222-4b2c-9d4e-000000000002",
+        title: "Why is the nightly export slow?",
+        project: "data-pipeline",
+        branch: "main",
+        rows: (cwd) => {
+          const t = Date.now() - 26 * MIN;
+          return [
+            { role: "user", at: t, content: "The nightly export went from 4 minutes to 40. Can you find out why?" },
+            { role: "assistant", at: t + 5e3, content: [tool("g1", "Grep", { pattern: "def export_rows", path: `${cwd}/pipeline` })] },
+            { role: "user", at: t + 6e3, content: [result("g1", "pipeline/export.py:41:def export_rows(batch):")] },
+            { role: "assistant", at: t + 9e3, content: [tool("g2", "Read", { file_path: `${cwd}/pipeline/export.py`, offset: 35, limit: 30 })] },
+            { role: "user", at: t + 1e4, content: [result("g2", numbered("def export_rows(batch):\n    for row in batch:\n        owner = db.fetch_owner(row.owner_id)\n        write(row, owner)"))] },
+            { role: "assistant", at: t + 15e3, content: [tool("g3", "Bash", { command: "python -m cProfile -s cumtime -m pipeline.export --sample 5000 | head -8", description: "Profile the export on a 5,000-row sample" })] },
+            {
+              role: "user",
+              at: t + 31e3,
+              content: [result("g3", "   ncalls  tottime  cumtime  filename:lineno(function)\n     5000    0.412   61.902  db.py:88(fetch_owner)\n        1    0.020   62.410  export.py:41(export_rows)\n     5000    0.301    0.488  writer.py:12(write)")]
+            },
+            {
+              role: "assistant",
+              at: t + 4e4,
+              content: [text([
+                "Found it: `export_rows` looks up each row's owner one query at a time. Since the owners table grew past a million rows that lookup is no longer cached, so 5,000 rows cost 5,000 round trips.",
+                "",
+                "| | Before | After batching |",
+                "|---|---|---|",
+                "| Queries per 5,000 rows | 5,000 | 1 |",
+                "| Time on the sample | 62.4 s | 0.9 s |",
+                "",
+                "The fix fetches the owners for the whole batch at once:",
+                "",
+                "```python",
+                "owners = db.fetch_owners({row.owner_id for row in batch})",
+                "for row in batch:",
+                "    write(row, owners[row.owner_id])",
+                "```",
+                "",
+                "Want me to apply it and add a test that counts the queries?"
+              ].join("\n"))]
+            }
+          ];
+        }
+      },
+      {
+        id: "c9d3b8e2-3333-4c3d-ae5f-000000000003",
+        title: "Fix the flaky login test",
+        project: "acme-web",
+        branch: "fix/login-test",
+        rows: (cwd) => {
+          const t = Date.now() - 3 * HOUR;
+          return [
+            { role: "user", at: t, content: "The login test fails about one run in five on CI. Plan a fix first." },
+            {
+              role: "assistant",
+              at: t + 3e4,
+              content: [tool("p1", "ExitPlanMode", {
+                plan: "## Fix the flaky login test\n\nThe test clicks **Sign in** before the form has loaded its CSRF token, so the request is sometimes rejected.\n\n1. Wait for the token field to be filled before submitting.\n2. Replace the fixed 500 ms sleep with that wait.\n3. Run the test 50 times in a row to confirm."
+              })]
+            },
+            { role: "user", at: t + 9e4, content: [result("p1", "User has approved your plan. You can now start coding.")] },
+            {
+              role: "assistant",
+              at: t + 95e3,
+              content: [tool("p2", "Edit", {
+                file_path: `${cwd}/tests/login.spec.ts`,
+                old_string: "  await page.waitForTimeout(500);\n  await page.click('text=Sign in');",
+                new_string: "  await expect(page.locator('input[name=csrf]')).not.toHaveValue('');\n  await page.click('text=Sign in');"
+              })]
+            },
+            { role: "user", at: t + 96e3, content: [result("p2", `The file ${cwd}/tests/login.spec.ts has been updated successfully.`)] },
+            { role: "assistant", at: t + 99e3, content: [tool("p3", "Bash", { command: "npx playwright test tests/login.spec.ts --repeat-each=50", description: "Run the login test 50 times" })] },
+            { role: "user", at: t + 16e4, content: [result("p3", "Running 50 tests using 4 workers\n\n  50 passed (58.2s)")] },
+            { role: "assistant", at: t + 165e3, content: [text("All 50 runs pass now. The test waits for the CSRF token instead of sleeping, so it is also about 400 ms faster.")] }
+          ];
+        }
+      },
+      {
+        id: "d1e4c7f3-4444-4d4e-bf60-000000000004",
+        title: "Release notes for v2.4",
+        project: "docs-site",
+        branch: "main",
+        rows: () => {
+          const t = Date.now() - 26 * HOUR;
+          return [
+            { role: "user", at: t, content: "Write the release notes for v2.4 from the merged pull requests." },
+            {
+              role: "assistant",
+              at: t + 5e4,
+              content: [text("## v2.4\n\n**Highlights**\n\n- A dark theme, which follows your system setting or can be chosen in Settings.\n- Exports are about 60 times faster on large accounts.\n\n**Fixes**\n\n- The login page no longer fails when submitted right after it opens.\n- Long project names no longer push the menu off screen on phones.")]
+            }
+          ];
+        }
+      },
+      {
+        id: "f3a6e9b5-6666-4f60-9182-000000000006",
+        title: "Chart last week's signups",
+        project: "data-pipeline",
+        branch: "main",
+        rows: (cwd) => {
+          const t = Date.now() - 50 * MIN;
+          return [
+            { role: "user", at: t, content: "Chart last week's signups by day, and make me a one-page summary I can share." },
+            { role: "assistant", at: t + 3e3, content: [text("I'll read the numbers first."), tool("v1", "Read", { file_path: `${cwd}/data/signups.csv` })] },
+            { role: "user", at: t + 4e3, content: [result("v1", numbered(SIGNUPS_CSV.trimEnd()))] },
+            { role: "assistant", at: t + 9e3, content: [tool("v2", "mcp__visualize__show_widget", { title: "signups_by_day", loading_messages: ["Stacking the bars"], widget_code: signupsChart() })] },
+            { role: "user", at: t + 1e4, content: [result("v2", "Shown to the user.")] },
+            { role: "assistant", at: t + 16e3, content: [tool("v3", "Write", { file_path: `${cwd}/reports/signups-week-45.html`, content: REPORT_HTML })] },
+            { role: "user", at: t + 17e3, content: [result("v3", `File created successfully at: ${cwd}/reports/signups-week-45.html`)] },
+            {
+              role: "assistant",
+              at: t + 21e3,
+              content: [text("Signups grew **18%** to 12,480. Thursday was the best day (2,214), the day the newsletter went out, and the weekend stayed above the weekday average.\n\nThe one-pager is in `reports/signups-week-45.html`: the three numbers that matter and the chart. Open it from the step above.")]
+            }
+          ];
+        }
+      },
+      {
+        id: "e2f5d8a4-5555-4e5f-8071-000000000005",
+        title: "Turn this CSV into JSON",
+        project: "scratch",
+        branch: "",
+        scratch: true,
+        rows: (cwd) => {
+          const t = Date.now() - 29 * HOUR;
+          return [
+            { role: "user", at: t, content: "Turn contacts.csv into a JSON array, one object per row." },
+            { role: "assistant", at: t + 6e3, content: [tool("s1", "Bash", { command: `python3 -c "import csv, json; print(json.dumps(list(csv.DictReader(open('contacts.csv'))), indent=2))" > contacts.json && wc -l contacts.json`, description: "Convert the CSV to JSON" })] },
+            { role: "user", at: t + 8e3, content: [result("s1", `   1203 ${cwd}/contacts.json`)] },
+            { role: "assistant", at: t + 1e4, content: [text("Done: `contacts.json` has 200 objects, with the CSV header as keys.")] }
+          ];
+        }
+      }
+    ];
+    SETTINGS_TSX = `import { FontSizePicker } from './FontSizePicker';
+import { Section } from './Section';
+
+export function Settings() {
+  return (
+    <Section title="Display">
+      <FontSizePicker />
+    </Section>
+  );
+}
+`;
+    TOGGLE_TSX = `type Theme = 'light' | 'dark';
+
+/** Switches the page between the light and dark color values in theme.css. */
+export function ThemeToggle({ value, onChange }: { value: Theme; onChange: (theme: Theme) => void }) {
+  return (
+    <label className="row">
+      Dark theme
+      <input type="checkbox" checked={value === 'dark'} onChange={(e) => onChange(e.target.checked ? 'dark' : 'light')} />
+    </label>
+  );
+}
+`;
+    DARK_CSS = `${THEME_CSS.replace("  --accent: #2563eb;\n}", "  --accent: #2563eb;\n}\n\n:root[data-theme='dark'] {\n  --bg: #0b0b0c;\n  --fg: #ededed;\n  --muted: #a1a1a1;\n  --accent: #60a5fa;\n}")}
+`;
+    FILE_TEXT = {
+      "acme-web/src/styles/theme.css": `${THEME_CSS}
+`,
+      "acme-web/src/settings/Settings.tsx": SETTINGS_TSX,
+      "acme-web/README.md": "# acme-web\n\nThe Acme web app.\n",
+      "data-pipeline/README.md": "# data-pipeline\n\nNightly exports and the numbers behind them.\n",
+      "data-pipeline/data/signups.csv": SIGNUPS_CSV,
+      "data-pipeline/reports/signups-week-45.html": REPORT_HTML,
+      "docs-site/README.md": "# docs-site\n\nThe public docs.\n"
+    };
+    DEMO_FILES = {
+      "acme-web": ["README.md", "package.json", "src/app.tsx", "src/settings/Settings.tsx", "src/settings/ThemeToggle.tsx", "src/styles/theme.css", "tests/login.spec.ts"],
+      "data-pipeline": ["README.md", "data/signups.csv", "pipeline/export.py", "pipeline/db.py", "pipeline/writer.py", "reports/signups-week-45.html", "tests/test_export.py"],
+      "docs-site": ["README.md", "docs/releases.md"]
+    };
+    DEMO_MODELS = [
+      { value: "default", label: "Default (recommended)", description: "Opus \xB7 best for everyday, complex tasks", efforts: ["low", "medium", "high", "xhigh", "max"], supportsFast: true, resolvedModel: "claude-opus-5-5" },
+      { value: "opus", label: "Opus", description: "For complex work", efforts: ["low", "medium", "high", "xhigh", "max"], supportsFast: true, resolvedModel: "claude-opus-5-5" },
+      { value: "sonnet", label: "Sonnet", description: "Efficient for everyday tasks", efforts: ["low", "medium", "high", "xhigh", "max"], supportsFast: false, resolvedModel: "claude-sonnet-5-5" },
+      { value: "haiku", label: "Haiku", description: "Fastest for quick answers", efforts: [], supportsFast: false, resolvedModel: "claude-haiku-5-5" }
+    ];
+    DEMO_LIVE_SESSION = SESSIONS[1].id;
+    DEMO_WAITING_SESSION = SESSIONS[0].id;
+  }
+});
+
+// src/shared/tasks.ts
+function todosOf(input) {
+  return Array.isArray(input.todos) ? input.todos.filter((t) => t && typeof t.content === "string") : [];
+}
+function currentTasks(messages) {
+  const results = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const block of message.blocks) {
+      if (block.type !== "tool_result") continue;
+      const text2 = typeof block.content === "string" ? block.content : block.content.map((c) => c.type === "text" ? c.text : "").join("");
+      results.set(block.tool_use_id, text2);
+    }
+  }
+  let tasks = [];
+  for (const message of messages) {
+    if (message.role !== "assistant" || message.parentToolUseId) continue;
+    for (const block of message.blocks) {
+      if (block.type !== "tool_use") continue;
+      const input = block.input;
+      if (block.name === "TodoWrite") {
+        tasks = todosOf(input).map((t) => ({ ...t }));
+      } else if (block.name === "TaskCreate") {
+        const id = results.get(block.id)?.match(/Task #(\w+)/)?.[1] ?? String(tasks.length + 1);
+        const activeForm = str(input.activeForm);
+        tasks.push({ id, content: str(input.subject) ?? str(input.description) ?? "Task", status: "pending", ...activeForm ? { activeForm } : {} });
+      } else if (block.name === "TaskUpdate") {
+        const task = tasks.find((t) => t.id !== void 0 && t.id === String(input.taskId));
+        if (!task) continue;
+        const status = str(input.status);
+        if (status === "deleted") {
+          tasks = tasks.filter((t) => t !== task);
+          continue;
+        }
+        if (status && STATUSES.has(status)) task.status = status;
+        if (str(input.subject)) task.content = str(input.subject);
+        if (str(input.activeForm)) task.activeForm = str(input.activeForm);
+      }
+    }
+  }
+  return tasks.map(({ id: _id, ...task }) => task);
+}
+var str, STATUSES;
+var init_tasks = __esm({
+  "src/shared/tasks.ts"() {
+    "use strict";
+    str = (value) => typeof value === "string" && value ? value : void 0;
+    STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
+  }
+});
+
+// src/server/archive.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir3, readFile as readFile2, rename, writeFile as writeFile3 } from "node:fs/promises";
+import path4 from "node:path";
+async function load() {
+  let text2;
+  try {
+    text2 = await readFile2(file(), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return /* @__PURE__ */ new Set();
+    throw error;
+  }
+  try {
+    const ids = JSON.parse(text2).ids;
+    return new Set(Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : []);
+  } catch {
+    await rename(file(), `${file()}.bad-${Date.now()}`).catch(() => void 0);
+    console.warn("[pelican] archived.json could not be read; it was set aside and the archive starts empty");
+    return /* @__PURE__ */ new Set();
+  }
+}
+function archived() {
+  loaded2 ??= load().catch((error) => {
+    loaded2 = void 0;
+    throw error;
+  });
+  return loaded2;
+}
+async function archivedIds() {
+  return archived().catch(() => /* @__PURE__ */ new Set());
+}
+async function setArchived(sessionId, on) {
+  const ids = await archived();
+  const before2 = ids.has(sessionId);
+  if (on) ids.add(sessionId);
+  else ids.delete(sessionId);
+  const write = writing.then(async () => {
+    await mkdir3(path4.dirname(file()), { recursive: true, mode: 448 });
+    const temp = `${file()}.${randomUUID2()}.tmp`;
+    await writeFile3(temp, `${JSON.stringify({ ids: [...ids] }, null, 2)}
+`, { mode: 384 });
+    await rename(temp, file());
+  });
+  writing = write.catch(() => void 0);
+  try {
+    await write;
+  } catch (error) {
+    if (before2) ids.add(sessionId);
+    else ids.delete(sessionId);
+    throw error;
+  }
+}
+var file, loaded2, writing;
+var init_archive = __esm({
+  "src/server/archive.ts"() {
+    "use strict";
+    init_config();
+    file = () => path4.join(config.stateDir, "archived.json");
+    writing = Promise.resolve();
+  }
+});
+
+// src/server/folders.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { mkdir as mkdir4, stat } from "node:fs/promises";
+import os3 from "node:os";
+import path5 from "node:path";
+function folderKind(dir) {
+  if (config.demo && under(dir, [config.home.replace(/\/+$/, "")])) return under(dir, scratchRoots) ? "scratch" : "project";
+  if (under(dir, tempRoots)) return "temp";
+  if (under(dir, scratchRoots)) return "scratch";
+  return "project";
+}
+async function isDirectory(dir) {
+  return stat(dir).then((s) => s.isDirectory(), () => false);
+}
+async function createScratchFolder() {
+  const now = /* @__PURE__ */ new Date();
+  const day = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  const dir = path5.join(scratchRoot, `${day}-${randomBytes2(2).toString("hex")}`);
+  await mkdir4(dir, { recursive: true });
+  return dir;
+}
+var realpath, scratchRoot, tempRoots, scratchRoots, under;
+var init_folders = __esm({
+  "src/server/folders.ts"() {
+    "use strict";
+    init_config();
+    realpath = (p) => {
+      try {
+        return realpathSync(p);
+      } catch {
+        return p;
+      }
+    };
+    scratchRoot = process.env.PELICAN_SCRATCH_DIR ?? path5.join(config.home, "scratch");
+    tempRoots = [.../* @__PURE__ */ new Set(["/tmp", "/private/tmp", "/var/folders", "/private/var/folders", os3.tmpdir(), realpath(os3.tmpdir())])].map((p) => p.replace(/\/+$/, ""));
+    scratchRoots = [path5.join(config.home, "Library/Application Support/Claude/scratch-workspaces"), scratchRoot].map((p) => p.replace(/\/+$/, ""));
+    under = (dir, roots) => {
+      const p = dir.replace(/\/+$/, "");
+      return roots.some((root) => p === root || p.startsWith(`${root}/`));
+    };
+  }
+});
+
+// src/server/live.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readdir, readFile as readFile3 } from "node:fs/promises";
+import path6 from "node:path";
+import { promisify as promisify2 } from "node:util";
+async function processes() {
+  try {
+    const { stdout } = await run2("ps", ["-A", "-o", "pid=,ppid=,comm="], { timeout: 3e3, maxBuffer: 8 * 1024 * 1024 });
+    const map = /* @__PURE__ */ new Map();
+    for (const line of stdout.split("\n")) {
+      const match = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+      if (match) map.set(Number(match[1]), { ppid: Number(match[2]), comm: match[3].trim() });
+    }
+    return map;
+  } catch {
+    return void 0;
+  }
+}
+function descends(pid, procs) {
+  for (let p = procs.get(pid)?.ppid, hops = 0; p && hops < 8; p = procs.get(p)?.ppid, hops += 1) {
+    if (p === process.pid) return true;
+  }
+  return false;
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function liveProcesses() {
+  if (config.demo) return /* @__PURE__ */ new Map([[DEMO_LIVE_SESSION, { app: "Claude Desktop", busy: true }]]);
+  if (cache && Date.now() - cache.at < 1500) return cache.byId;
+  const dir = path6.join(config.claudeHome, "sessions");
+  const byId = /* @__PURE__ */ new Map();
+  let names = [];
+  try {
+    names = (await readdir(dir)).filter((n) => /^\d+\.json$/.test(n));
+  } catch {
+  }
+  const entries = (await Promise.all(names.map(async (name) => {
+    try {
+      const entry = JSON.parse(await readFile3(path6.join(dir, name), "utf8"));
+      return entry.sessionId && typeof entry.pid === "number" && entry.pid !== process.pid && alive(entry.pid) ? entry : void 0;
+    } catch {
+      return void 0;
+    }
+  }))).filter((e) => Boolean(e));
+  const procs = await processes();
+  for (const entry of entries) {
+    const proc = procs?.get(entry.pid);
+    if (procs && (!proc || !/claude|node|bun|disclaimer/i.test(proc.comm))) continue;
+    const ours = procs ? descends(entry.pid, procs) : entry.entrypoint === "sdk-ts";
+    if (ours) continue;
+    const busy = entry.status !== void 0 && entry.status !== "idle";
+    const app2 = CLAUDE_CLIENTS[entry.entrypoint ?? ""];
+    const known = byId.get(entry.sessionId);
+    const worked = typeof entry.statusUpdatedAt === "number" ? entry.statusUpdatedAt : entry.updatedAt;
+    const updatedAt = Math.max(known?.updatedAt ?? 0, typeof worked === "number" ? worked : 0) || void 0;
+    const pick = !known || busy && !known.busy ? { ...app2 ? { app: app2 } : {}, busy } : known;
+    byId.set(entry.sessionId, { ...pick, ...updatedAt ? { updatedAt } : {} });
+  }
+  cache = { at: Date.now(), byId };
+  return byId;
+}
+var run2, CLAUDE_CLIENTS, cache;
+var init_live = __esm({
+  "src/server/live.ts"() {
+    "use strict";
+    init_config();
+    init_demo();
+    run2 = promisify2(execFile2);
+    CLAUDE_CLIENTS = {
+      "claude-desktop": "Claude Desktop",
+      cli: "the terminal",
+      "claude-vscode": "VS Code"
+    };
+  }
+});
+
+// src/server/normalize.ts
+function clip(text2, max) {
+  return text2.length > max ? { type: "text", text: `${text2.slice(0, max)}
+\u2026`, truncated: true } : { type: "text", text: text2 };
+}
+function image(raw) {
+  const source = raw.source;
+  if (!isRecord(source)) return void 0;
+  if (source.type === "base64" && typeof source.data === "string") {
+    const mediaType = typeof source.media_type === "string" ? source.media_type : "image/png";
+    return source.data.length > MAX_IMAGE_BASE64 ? { type: "image", source: { type: "base64", media_type: mediaType, data: "" }, omitted: true } : { type: "image", source: { type: "base64", media_type: mediaType, data: source.data } };
+  }
+  if (source.type === "url" && typeof source.url === "string") return { type: "image", source: { type: "url", url: source.url } };
+  return void 0;
+}
+function resultContent(content) {
+  if (typeof content === "string") {
+    const clipped = clip(content, MAX_RESULT_TEXT);
+    return { content: clipped.text, truncated: Boolean(clipped.truncated) };
+  }
+  if (!Array.isArray(content)) return { content: "", truncated: false };
+  let truncated = false;
+  const parts = [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    if (part.type === "text" && typeof part.text === "string") {
+      const clipped = clip(part.text, MAX_RESULT_TEXT);
+      truncated ||= Boolean(clipped.truncated);
+      parts.push(clipped);
+    } else if (part.type === "image") {
+      const img = image(part);
+      if (img) parts.push(img);
+    }
+  }
+  return { content: parts, truncated };
+}
+function blocks(content) {
+  if (typeof content === "string") return content ? [clip(content, MAX_TEXT)] : [];
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const raw of content) {
+    if (!isRecord(raw)) continue;
+    switch (raw.type) {
+      case "text":
+        if (typeof raw.text === "string" && raw.text) out.push(clip(raw.text, MAX_TEXT));
+        break;
+      case "thinking":
+        if (typeof raw.thinking === "string" && raw.thinking.trim()) out.push({ type: "thinking", thinking: raw.thinking });
+        break;
+      case "tool_use":
+      case "server_tool_use":
+        if (typeof raw.id === "string" && typeof raw.name === "string") {
+          out.push({ type: "tool_use", id: raw.id, name: raw.name, input: isRecord(raw.input) ? raw.input : {} });
+        }
+        break;
+      case "tool_result": {
+        if (typeof raw.tool_use_id !== "string") break;
+        const { content: resultBody, truncated } = resultContent(raw.content);
+        out.push({
+          type: "tool_result",
+          tool_use_id: raw.tool_use_id,
+          content: resultBody,
+          ...raw.is_error === true ? { is_error: true } : {},
+          ...truncated ? { truncated: true } : {}
+        });
+        break;
+      }
+      case "web_search_tool_result":
+        if (typeof raw.tool_use_id === "string") {
+          const results = Array.isArray(raw.content) ? raw.content.filter(isRecord) : [];
+          const text2 = results.map((r) => `${String(r.title ?? "")} ${String(r.url ?? "")}`.trim()).join("\n");
+          out.push({ type: "tool_result", tool_use_id: raw.tool_use_id, content: text2 });
+        }
+        break;
+      case "image": {
+        const img = image(raw);
+        if (img) out.push(img);
+        break;
+      }
+      case "document":
+        out.push({ type: "text", text: "[document]" });
+        break;
+      default:
+        break;
+    }
+  }
+  return out;
+}
+function toChatMessage(raw) {
+  const type = raw.type;
+  if (type !== "user" && type !== "assistant") return void 0;
+  if (typeof raw.uuid !== "string") return void 0;
+  const message = isRecord(raw.message) ? raw.message : {};
+  const out = {
+    uuid: raw.uuid,
+    role: type,
+    blocks: blocks(message.content)
+  };
+  if (out.blocks.length === 0) return void 0;
+  const timestamp = typeof raw.timestamp === "string" ? Date.parse(raw.timestamp) : NaN;
+  if (!Number.isNaN(timestamp)) out.timestamp = timestamp;
+  const parent = raw.parent_tool_use_id;
+  if (typeof parent === "string") out.parentToolUseId = parent;
+  if (type === "assistant") {
+    if (typeof message.model === "string") out.model = message.model;
+    if (typeof message.id === "string") out.messageId = message.id;
+  }
+  if (raw.is_meta === true || raw.isMeta === true || raw.isSynthetic === true) out.meta = true;
+  if (raw.isCompactSummary === true) out.compactSummary = true;
+  return out;
+}
+var MAX_TEXT, MAX_RESULT_TEXT, MAX_IMAGE_BASE64, isRecord;
+var init_normalize = __esm({
+  "src/server/normalize.ts"() {
+    "use strict";
+    MAX_TEXT = 6e4;
+    MAX_RESULT_TEXT = 24e3;
+    MAX_IMAGE_BASE64 = 25e5;
+    isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+});
+
+// src/server/history.ts
+import { open, stat as stat2 } from "node:fs/promises";
+function empty(ino) {
+  return {
+    recorded: {},
+    ino,
+    offset: 0,
+    carry: Buffer.alloc(0),
+    nodes: /* @__PURE__ */ new Map(),
+    order: [],
+    leaf: void 0,
+    chain: [],
+    chainIndex: /* @__PURE__ */ new Map(),
+    chainLeaf: void 0,
+    messages: []
+  };
+}
+function note(recorded, row) {
+  if (row.type === "assistant") {
+    const model = str2(row.requestedModel) ?? str2(row.message?.model);
+    if (model && !model.startsWith("<")) recorded.model = model;
+    if (str2(row.effort)) recorded.effort = str2(row.effort);
+    const speed = str2(row.message?.usage?.speed);
+    if (speed) recorded.fast = speed === "fast";
+    recorded.ultracode ??= false;
+  } else if (row.type === "user" && str2(row.permissionMode) && MODES.has(str2(row.permissionMode))) {
+    recorded.permissionMode = str2(row.permissionMode);
+  } else if (row.type === "attachment") {
+    const kind = str2(row.attachment?.type) ?? "";
+    if (kind === "ultra_effort_enter") recorded.ultracode = true;
+    else if (/^ultra_effort_(exit|leave|off)/.test(kind)) recorded.ultracode = false;
+  }
+}
+function steeredMessage(row, uuid) {
+  const attachment = row.attachment;
+  if (row.type !== "attachment" || attachment?.type !== "queued_command") return void 0;
+  if (attachment.commandMode !== void 0 && attachment.commandMode !== "prompt") return void 0;
+  const message = toChatMessage({ type: "user", uuid, timestamp: row.timestamp, message: { role: "user", content: attachment.prompt } });
+  if (!message) return void 0;
+  const source = str2(attachment.source_uuid);
+  return { ...message, steered: true, ...source ? { sourceUuid: source } : {} };
+}
+function addLine(t, line) {
+  if (line.length < 2 || line.charCodeAt(0) !== 123 || !line.includes('"uuid"')) return;
+  let row;
+  try {
+    row = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const uuid = str2(row.uuid);
+  if (!uuid || row.isSidechain === true) return;
+  note(t.recorded, row);
+  const turn = row.type === "user" || row.type === "assistant";
+  const message = turn ? toChatMessage(row) : steeredMessage(row, uuid);
+  const existing = t.nodes.get(uuid);
+  if (existing) {
+    existing.message = message;
+    return;
+  }
+  const metadata = row.compactMetadata;
+  const node = {
+    uuid,
+    parent: str2(row.parentUuid),
+    logicalParent: str2(row.logicalParentUuid),
+    preservedTail: str2(metadata?.preservedSegment?.tailUuid),
+    index: t.order.length,
+    message
+  };
+  t.nodes.set(uuid, node);
+  t.order.push(node);
+  if (turn) t.leaf = node;
+}
+async function readNew(file2, t, size) {
+  const handle = await open(file2, "r");
+  try {
+    let position = t.offset;
+    while (position < size) {
+      const buffer = Buffer.allocUnsafe(Math.min(CHUNK, size - position));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (bytesRead <= 0) break;
+      position += bytesRead;
+      const data = t.carry.length > 0 ? Buffer.concat([t.carry, buffer.subarray(0, bytesRead)]) : buffer.subarray(0, bytesRead);
+      const lastBreak = data.lastIndexOf(10);
+      if (lastBreak < 0) {
+        t.carry = Buffer.from(data);
+        continue;
+      }
+      t.carry = Buffer.from(data.subarray(lastBreak + 1));
+      for (const line of data.subarray(0, lastBreak).toString("utf8").split("\n")) addLine(t, line);
+    }
+    t.offset = position;
+    if (t.carry.length > 0) addLine(t, t.carry.toString("utf8"));
+  } finally {
+    await handle.close();
+  }
+}
+function before(t, boundary) {
+  return t.nodes.get(boundary.logicalParent) ?? (boundary.preservedTail ? t.nodes.get(boundary.preservedTail) : void 0) ?? (boundary.index > 0 ? t.order[boundary.index - 1] : void 0);
+}
+function walk(t, from, known) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  let node = from;
+  while (node && !seen.has(node.uuid)) {
+    const at = known?.get(node.uuid);
+    if (at !== void 0) return { nodes: out.reverse(), joinedAt: at };
+    seen.add(node.uuid);
+    out.push(node);
+    if (node.parent) node = t.nodes.get(node.parent);
+    else if (node.logicalParent) node = before(t, node);
+    else node = void 0;
+  }
+  return { nodes: out.reverse(), joinedAt: -1 };
+}
+function conversation(t) {
+  const leaf = t.leaf;
+  if (!leaf) return [];
+  if (t.chainLeaf === leaf.uuid) return t.messages;
+  const { nodes, joinedAt } = walk(t, leaf, t.chainIndex);
+  t.chain = joinedAt >= 0 ? t.chain.slice(0, joinedAt + 1).concat(nodes) : nodes;
+  t.chainIndex = new Map(t.chain.map((n, i) => [n.uuid, i]));
+  t.chainLeaf = leaf.uuid;
+  t.messages = t.chain.flatMap((n) => n.message ? [n.message] : []);
+  return t.messages;
+}
+async function read(file2) {
+  let info;
+  try {
+    info = await stat2(file2);
+  } catch {
+    transcripts.delete(file2);
+    return [];
+  }
+  let t = transcripts.get(file2);
+  if (!t || t.ino !== info.ino || info.size < t.offset) t = empty(info.ino);
+  transcripts.delete(file2);
+  transcripts.set(file2, t);
+  while (transcripts.size > MAX_FILES) transcripts.delete(transcripts.keys().next().value);
+  if (info.size > t.offset) await readNew(file2, t, info.size);
+  return conversation(t);
+}
+async function readRecordedSettings(file2) {
+  await readHistory(file2);
+  return { ...transcripts.get(file2)?.recorded ?? {} };
+}
+function readHistory(file2) {
+  const previous = locks.get(file2) ?? Promise.resolve();
+  const next = previous.catch(() => void 0).then(() => read(file2));
+  locks.set(file2, next);
+  void next.finally(() => {
+    if (locks.get(file2) === next) locks.delete(file2);
+  }).catch(() => void 0);
+  return next;
+}
+var CHUNK, MAX_FILES, transcripts, locks, str2, MODES;
+var init_history = __esm({
+  "src/server/history.ts"() {
+    "use strict";
+    init_normalize();
+    CHUNK = 8 * 1024 * 1024;
+    MAX_FILES = 16;
+    transcripts = /* @__PURE__ */ new Map();
+    locks = /* @__PURE__ */ new Map();
+    str2 = (value) => typeof value === "string" && value ? value : void 0;
+    MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "auto", "bypassPermissions"]);
+  }
+});
+
+// src/server/transcripts.ts
+import { createReadStream } from "node:fs";
+import { open as open2, readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import readline from "node:readline";
+import path7 from "node:path";
+async function rebuildIndex() {
+  const next = /* @__PURE__ */ new Map();
+  let dirs = [];
+  try {
+    dirs = await readdir2(projectsDir());
+  } catch {
+  }
+  await Promise.all(dirs.map(async (dir) => {
+    try {
+      for (const name of await readdir2(path7.join(projectsDir(), dir))) {
+        if (name.endsWith(".jsonl")) next.set(name.slice(0, -".jsonl".length), path7.join(projectsDir(), dir, name));
+      }
+    } catch {
+    }
+  }));
+  index = next;
+  indexBuiltAt = Date.now();
+}
+async function transcriptPath(sessionId) {
+  if (!index.has(sessionId) && Date.now() - indexBuiltAt > 1e3) await rebuildIndex();
+  return index.get(sessionId);
+}
+async function refreshTranscriptIndex() {
+  await rebuildIndex();
+}
+function replyText(row) {
+  const content = row.message?.content;
+  if (!Array.isArray(content)) return void 0;
+  const text2 = content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join(" ").replace(/[`*_#>|]+/g, "").replace(/\s+/g, " ").trim();
+  return text2 ? text2.slice(0, 160) : void 0;
+}
+async function readLastTurn(file2) {
+  let handle;
+  let found;
+  let foundAt = 0;
+  try {
+    handle = await open2(file2, "r");
+    const { size } = await handle.stat();
+    let end = size;
+    let carry = Buffer.alloc(0);
+    while (end > 0 && size - end < MAX_SCAN && !(found && foundAt - end > PREVIEW_SCAN)) {
+      const start = Math.max(0, end - CHUNK2);
+      const chunk = Buffer.alloc(end - start);
+      await handle.read(chunk, 0, chunk.length, start);
+      let data = Buffer.concat([chunk, carry]);
+      end = start;
+      if (start > 0) {
+        const firstBreak = data.indexOf(10);
+        if (firstBreak < 0) {
+          carry = data;
+          continue;
+        }
+        carry = data.subarray(0, firstBreak);
+        data = data.subarray(firstBreak + 1);
+      }
+      const lines = data.toString("utf8").split("\n");
+      for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i];
+        if (!line.includes('"timestamp"') || !(line.includes('"type":"user"') || line.includes('"type":"assistant"'))) continue;
+        if (found && !line.includes('"type":"text"') && !line.includes('"content":"')) continue;
+        try {
+          const row = JSON.parse(line);
+          if (row.type !== "user" && row.type !== "assistant" || row.isSidechain || typeof row.timestamp !== "string") continue;
+          if (!found) {
+            const time = Date.parse(row.timestamp);
+            if (Number.isNaN(time)) continue;
+            found = {
+              time,
+              ...typeof row.cwd === "string" ? { cwd: row.cwd } : {},
+              ...typeof row.gitBranch === "string" ? { gitBranch: row.gitBranch } : {},
+              ...row.forkedFrom ? { copied: true } : {}
+            };
+            foundAt = end;
+          }
+          if (row.type === "assistant") {
+            const preview = replyText(row);
+            if (preview) return { ...found, preview };
+          } else if (found && row.type === "user" && typeof row.message?.content === "string") {
+            return found;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  } finally {
+    await handle?.close();
+  }
+  return found;
+}
+async function lastTurnTime(file2) {
+  let info;
+  try {
+    info = await stat3(file2);
+  } catch {
+    return void 0;
+  }
+  const cached = lastTurnCache.get(file2);
+  if (cached && cached.size === info.size && cached.mtimeMs === info.mtimeMs) {
+    return { lastTurn: cached.value, mtimeMs: info.mtimeMs, size: info.size };
+  }
+  const value = await readLastTurn(file2);
+  lastTurnCache.set(file2, { size: info.size, mtimeMs: info.mtimeMs, value });
+  return { lastTurn: value, mtimeMs: info.mtimeMs, size: info.size };
+}
+async function firstTurnSession(file2) {
+  const cached = headCache.get(file2);
+  if (cached !== void 0) return cached ?? void 0;
+  let found;
+  let read2 = 0;
+  try {
+    const input = createReadStream(file2);
+    const lines = readline.createInterface({ input, crlfDelay: Infinity });
+    try {
+      for await (const line of lines) {
+        read2 += line.length + 1;
+        if (read2 > HEAD_SCAN) break;
+        if (!line.includes('"sessionId"') || !(line.includes('"type":"user"') || line.includes('"type":"assistant"'))) continue;
+        try {
+          const row = JSON.parse(line);
+          if ((row.type === "user" || row.type === "assistant") && !row.isSidechain && typeof row.sessionId === "string") {
+            found = row.sessionId;
+            break;
+          }
+        } catch {
+        }
+      }
+    } finally {
+      lines.close();
+      input.destroy();
+    }
+  } catch {
+    return void 0;
+  }
+  if (found) {
+    if (headCache.size > 1e4) headCache.clear();
+    headCache.set(file2, found);
+  }
+  return found;
+}
+async function rawEntry(file2, uuid) {
+  const needle = `"uuid":"${uuid}"`;
+  const input = createReadStream(file2);
+  const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      if (!line.includes(needle)) continue;
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (row.uuid !== uuid) continue;
+      const content = row.type === "attachment" && row.attachment?.type === "queued_command" ? row.attachment.prompt : row.message?.content;
+      return { parentUuid: typeof row.parentUuid === "string" ? row.parentUuid : null, content };
+    }
+  } catch {
+    return void 0;
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+  return void 0;
+}
+async function rawImages(file2, uuid) {
+  const content = (await rawEntry(file2, uuid))?.content;
+  if (!Array.isArray(content)) return [];
+  const images = [];
+  for (const block of content) {
+    if (block?.type !== "image" || !block.source) continue;
+    if (block.source.type === "base64" && typeof block.source.data === "string") {
+      images.push({ type: "base64", mediaType: typeof block.source.media_type === "string" ? block.source.media_type : "image/png", data: block.source.data });
+    } else if (block.source.type === "url" && typeof block.source.url === "string") {
+      images.push({ type: "url" });
+    }
+  }
+  return images;
+}
+var projectsDir, index, indexBuiltAt, CHUNK2, MAX_SCAN, PREVIEW_SCAN, lastTurnCache, HEAD_SCAN, headCache;
+var init_transcripts = __esm({
+  "src/server/transcripts.ts"() {
+    "use strict";
+    init_config();
+    projectsDir = () => path7.join(config.claudeHome, "projects");
+    index = /* @__PURE__ */ new Map();
+    indexBuiltAt = 0;
+    CHUNK2 = 256 * 1024;
+    MAX_SCAN = 16 * 1024 * 1024;
+    PREVIEW_SCAN = 4 * 1024 * 1024;
+    lastTurnCache = /* @__PURE__ */ new Map();
+    HEAD_SCAN = 64 * 1024 * 1024;
+    headCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/sessions.ts
+import path8 from "node:path";
+import { getSessionInfo, getSubagentMessages, listSessions, renameSession } from "@anthropic-ai/claude-agent-sdk";
+function titleOf(info) {
+  const title = info.customTitle || info.summary || info.firstPrompt || "";
+  return title.replace(/\s+/g, " ").trim() || "Untitled session";
+}
+async function summarize(info, status, live, archived2) {
+  const file2 = await transcriptPath(info.sessionId);
+  const times = file2 ? await lastTurnTime(file2) : void 0;
+  const lastTurn = times?.lastTurn;
+  const lastActivity = lastTurn?.time ?? info.lastModified;
+  const own = status(info.sessionId);
+  let state = own ?? "idle";
+  const other = live.get(info.sessionId);
+  const elsewhere = own ? void 0 : other;
+  const recent2 = lastTurn && !lastTurn.copied && Date.now() - lastTurn.time < config.liveWindowMs;
+  if (!own && (elsewhere?.busy || recent2)) state = "live";
+  else if (own === "idle" && other?.busy) state = "live";
+  const cwd = info.cwd || lastTurn?.cwd || "";
+  if (!info.cwd && cwd) infoCache.set(info.sessionId, { ...info, cwd });
+  const gitBranch = lastTurn?.gitBranch ?? info.gitBranch;
+  const title = titleOf(info);
+  const copiedFrom = file2 && title === "Side chat" ? await firstTurnSession(file2) : void 0;
+  const sideChatOf = copiedFrom && copiedFrom !== info.sessionId ? copiedFrom : void 0;
+  return {
+    id: info.sessionId,
+    title,
+    cwd,
+    project: cwd ? path8.basename(cwd) : "",
+    ...gitBranch && gitBranch !== "HEAD" ? { gitBranch } : {},
+    lastActivity,
+    ...info.createdAt ? { createdAt: info.createdAt } : {},
+    status: state,
+    ...info.fileSize ? { sizeBytes: info.fileSize } : {},
+    ...cwd && folderKind(cwd) === "scratch" ? { scratch: true } : {},
+    ...cwd && folderKind(cwd) === "temp" ? { temp: true } : {},
+    ...state === "live" && other?.busy && other.app ? { runningIn: other.app } : {},
+    ...lastTurn?.preview ? { preview: lastTurn.preview } : {},
+    ...sideChatOf ? { sideChatOf } : {},
+    ...archived2.has(info.sessionId) ? { archived: true } : {},
+    // Open, idle, in another app too: its Claude does not see what is sent here until it reopens.
+    ...other && !other.busy ? { openIn: other.app ?? "another app" } : {}
+  };
+}
+async function listSummaries(status) {
+  const infos = await listSessions({ includeProgrammatic: true });
+  for (const info of infos) infoCache.set(info.sessionId, info);
+  const [live, archived2] = await Promise.all([liveProcesses(), archivedIds()]);
+  const summaries = await Promise.all(infos.map((info) => summarize(info, status, live, archived2)));
+  return summaries.sort((a, b) => b.lastActivity - a.lastActivity);
+}
+async function sessionInfo(sessionId) {
+  if (!infoCache.has(sessionId)) {
+    for (const info2 of await listSessions({ includeProgrammatic: true }).catch(() => [])) infoCache.set(info2.sessionId, info2);
+  }
+  const cached = infoCache.get(sessionId);
+  const info = await getSessionInfo(sessionId, cached?.cwd ? { dir: cached.cwd } : {}).catch(() => void 0);
+  if (!info) return cached;
+  let cwd = info.cwd || cached?.cwd;
+  if (!cwd) {
+    const file2 = await transcriptPath(sessionId);
+    cwd = file2 ? (await lastTurnTime(file2))?.lastTurn?.cwd : void 0;
+  }
+  const merged = { ...cached, ...info, ...cwd ? { cwd } : {} };
+  infoCache.set(sessionId, merged);
+  return merged;
+}
+async function sessionSummary(sessionId, status) {
+  const info = await sessionInfo(sessionId);
+  return info ? summarize(info, status, await liveProcesses(), await archivedIds()) : void 0;
+}
+async function renameSessionTitle(sessionId, title) {
+  const dir = infoCache.get(sessionId)?.cwd;
+  await renameSession(sessionId, title, dir ? { dir } : {});
+  infoCache.delete(sessionId);
+}
+async function recordedSettings(sessionId) {
+  const file2 = await transcriptPath(sessionId);
+  return file2 ? readRecordedSettings(file2) : {};
+}
+async function loadMessages(sessionId) {
+  const file2 = await transcriptPath(sessionId);
+  return file2 ? readHistory(file2) : [];
+}
+async function sentFiles(sessionId) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const message of await loadMessages(sessionId)) {
+    if (message.role !== "assistant") continue;
+    for (const block of message.blocks) {
+      if (block.type !== "tool_use") continue;
+      if (block.name === "SendUserFile" && Array.isArray(block.input.files)) {
+        for (const file2 of block.input.files) if (typeof file2 === "string") paths.add(file2);
+      } else if (block.name === "Artifact" && typeof block.input.file_path === "string") {
+        paths.add(block.input.file_path);
+      }
+    }
+  }
+  return paths;
+}
+async function loadSubagent(sessionId, agentId) {
+  if (!/^[\w-]{1,80}$/.test(agentId)) return [];
+  const dir = infoCache.get(sessionId)?.cwd;
+  const raw = await getSubagentMessages(sessionId, agentId, dir ? { dir } : {}).catch(() => []);
+  return raw.map((message) => toChatMessage(message)).filter((message) => Boolean(message));
+}
+async function loadPage(sessionId, before2, limit) {
+  const all = await loadMessages(sessionId);
+  const end = Math.min(before2 ?? all.length, all.length);
+  const offset = Math.max(0, end - limit);
+  return { messages: all.slice(offset, end), total: all.length, offset };
+}
+var infoCache;
+var init_sessions = __esm({
+  "src/server/sessions.ts"() {
+    "use strict";
+    init_archive();
+    init_config();
+    init_folders();
+    init_live();
+    init_history();
+    init_normalize();
+    init_transcripts();
+    infoCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/actions.ts
+import { deleteSession, forkSession } from "@anthropic-ai/claude-agent-sdk";
+async function fork(sessionId, upTo, title) {
+  if (config.demo) throw new Error("This is the demo: nothing changes.");
+  const info = await sessionInfo(sessionId);
+  const result2 = await forkSession(sessionId, {
+    ...info?.cwd ? { dir: info.cwd } : {},
+    ...upTo ? { upToMessageId: upTo } : {},
+    ...title ? { title } : {}
+  });
+  await refreshTranscriptIndex();
+  return result2.sessionId;
+}
+async function messageBefore(sessionId, uuid) {
+  const messages = await loadMessages(sessionId);
+  const at = messages.findIndex((m) => m.uuid === uuid);
+  if (at < 0) return void 0;
+  return at === 0 ? null : messages[at - 1].uuid;
+}
+async function remove(sessionId) {
+  if (config.demo) throw new Error("This is the demo: nothing changes.");
+  const info = await sessionInfo(sessionId);
+  await deleteSession(sessionId, info?.cwd ? { dir: info.cwd } : {});
+  await refreshTranscriptIndex();
+}
+async function exportMarkdown(sessionId) {
+  const info = await sessionInfo(sessionId);
+  const title = info?.customTitle || info?.summary || "Claude Code session";
+  const messages = await loadMessages(sessionId);
+  const out = [`# ${title}`, ""];
+  if (info?.cwd) out.push(`Folder: \`${info.cwd}\``, "");
+  let speaker;
+  for (const message of messages) {
+    if (message.meta || message.parentToolUseId) continue;
+    const parts = [];
+    const tools = [];
+    for (const block of message.blocks) {
+      if (block.type === "text" && block.text.trim()) parts.push(block.text.trim());
+      else if (block.type === "tool_use") tools.push(toolLine(block.name, block.input));
+    }
+    if (parts.length === 0 && tools.length === 0) continue;
+    const who = message.role === "user" ? "You" : "Claude";
+    if (who !== speaker) {
+      out.push(`## ${who}`, "");
+      speaker = who;
+    }
+    if (tools.length > 0) out.push(...tools, "");
+    if (parts.length > 0) out.push(parts.join("\n\n"), "");
+  }
+  return { title, markdown: `${out.join("\n").trim()}
+` };
+}
+var toolLine;
+var init_actions = __esm({
+  "src/server/actions.ts"() {
+    "use strict";
+    init_config();
+    init_sessions();
+    init_transcripts();
+    toolLine = (name, input) => {
+      const target = ["file_path", "command", "pattern", "url", "query", "description"].map((k) => input[k]).find((v) => typeof v === "string");
+      return `- ${name}${target ? `: \`${String(target).split("\n")[0]}\`` : ""}`;
+    };
+  }
+});
+
+// src/server/feed.ts
+import { stat as stat4 } from "node:fs/promises";
+function feedFor(sessionId) {
+  let feed = feeds.get(sessionId);
+  if (!feed) {
+    feed = new Feed(sessionId);
+    feeds.set(sessionId, feed);
+  }
+  return feed;
+}
+function sessionsChanged() {
+  if (changedTimer) return;
+  changedTimer = setTimeout(() => {
+    changedTimer = void 0;
+    for (const listener of everyone) {
+      try {
+        listener({ type: "sessions_changed" });
+      } catch {
+      }
+    }
+  }, 2e3);
+}
+function broadcastAll(event) {
+  for (const listener of everyone) {
+    try {
+      listener(event);
+    } catch {
+    }
+  }
+}
+function connect(listener) {
+  everyone.add(listener);
+  return () => everyone.delete(listener);
+}
+function subscribe(sessionId, listener) {
+  const feed = feedFor(sessionId);
+  feed.listeners.add(listener);
+  feed.replayRecent(listener);
+  feed.watch();
+  return () => {
+    feed.listeners.delete(listener);
+    if (feed.listeners.size > 0) return;
+    feed.unwatch();
+    if (!feed.hasRecent && feed.publishing === 0 && feeds.get(sessionId) === feed) feeds.delete(sessionId);
+  };
+}
+var POLL_MS, Feed, feeds, everyone, changedTimer;
+var init_feed = __esm({
+  "src/server/feed.ts"() {
+    "use strict";
+    init_sessions();
+    init_transcripts();
+    POLL_MS = 1e3;
+    Feed = class {
+      constructor(sessionId) {
+        this.sessionId = sessionId;
+      }
+      sessionId;
+      listeners = /* @__PURE__ */ new Set();
+      delivered = /* @__PURE__ */ new Set();
+      /** Recently published messages, replayed to a client that subscribes late (a new session's first prompt). */
+      recent = [];
+      /** Ids last read from the file; one that disappears means the conversation was rewound. */
+      fromFile = /* @__PURE__ */ new Set();
+      primed;
+      size = -1;
+      mtimeMs = -1;
+      timer;
+      checking = false;
+      async prime() {
+        this.primed ??= (async () => {
+          const file2 = await transcriptPath(this.sessionId);
+          if (file2) {
+            const info = await stat4(file2).catch(() => void 0);
+            if (info) {
+              this.size = info.size;
+              this.mtimeMs = info.mtimeMs;
+            }
+          }
+          for (const message of await loadMessages(this.sessionId)) {
+            this.delivered.add(message.uuid);
+            this.fromFile.add(message.uuid);
+          }
+        })();
+        return this.primed;
+      }
+      broadcast(event) {
+        for (const listener of this.listeners) {
+          try {
+            listener(event);
+          } catch {
+          }
+        }
+      }
+      /** Publishes still on their way (priming reads the transcript first). */
+      publishing = 0;
+      async publish(message) {
+        this.publishing += 1;
+        try {
+          await this.prime();
+          if (this.delivered.has(message.uuid)) return;
+          this.delivered.add(message.uuid);
+          this.recent.push(message);
+          if (this.recent.length > 40) this.recent.shift();
+          this.broadcast({ type: "message", sessionId: this.sessionId, message });
+        } finally {
+          this.publishing -= 1;
+        }
+      }
+      get hasRecent() {
+        return this.recent.length > 0;
+      }
+      replayRecent(listener) {
+        for (const message of this.recent) listener({ type: "message", sessionId: this.sessionId, message });
+      }
+      watch() {
+        if (this.timer) return;
+        void this.prime();
+        this.timer = setInterval(() => {
+          void this.check().then((changed) => {
+            if (changed) sessionsChanged();
+          });
+        }, POLL_MS);
+      }
+      unwatch() {
+        clearInterval(this.timer);
+        this.timer = void 0;
+      }
+      get watching() {
+        return Boolean(this.timer);
+      }
+      async check() {
+        if (this.checking) return false;
+        this.checking = true;
+        try {
+          await this.prime();
+          const file2 = await transcriptPath(this.sessionId);
+          if (!file2) return false;
+          const info = await stat4(file2).catch(() => void 0);
+          if (!info || info.size === this.size && info.mtimeMs === this.mtimeMs) return false;
+          this.size = info.size;
+          this.mtimeMs = info.mtimeMs;
+          const messages = await loadMessages(this.sessionId);
+          const present = new Set(messages.map((m) => m.uuid));
+          for (const uuid of this.fromFile) {
+            if (!present.has(uuid)) {
+              this.fromFile = present;
+              this.delivered = new Set(present);
+              this.broadcast({ type: "reload", sessionId: this.sessionId });
+              return true;
+            }
+          }
+          this.fromFile = present;
+          for (const message of messages) {
+            if (this.delivered.has(message.uuid)) continue;
+            this.delivered.add(message.uuid);
+            this.broadcast({ type: "message", sessionId: this.sessionId, message });
+          }
+          return true;
+        } finally {
+          this.checking = false;
+        }
+      }
+    };
+    feeds = /* @__PURE__ */ new Map();
+    everyone = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/server/files.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir5, readdir as readdir3, readFile as readFile4, rm as rm3, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
+import path9 from "node:path";
+async function saveUpload(file2) {
+  if (file2.size > MAX_UPLOAD_BYTES) throw new Error(`File is larger than ${MAX_UPLOAD_BYTES / 1024 / 1024} MB`);
+  const id = randomUUID3();
+  const dir = path9.join(uploadsDir(), id);
+  await mkdir5(dir, { recursive: true, mode: 448 });
+  const name = safeName(file2.name);
+  const filePath = path9.join(dir, name);
+  await writeFile4(filePath, Buffer.from(await file2.arrayBuffer()), { mode: 384 });
+  return { id, name, mime: file2.type || "application/octet-stream", size: file2.size, path: filePath };
+}
+async function findUpload(id) {
+  if (!/^[0-9a-f-]{36}$/.test(id)) return void 0;
+  const dir = path9.join(uploadsDir(), id);
+  try {
+    const [name] = await readdir3(dir);
+    if (!name) return void 0;
+    const filePath = path9.join(dir, name);
+    const info = await stat5(filePath);
+    return { id, name, mime: mimeOf(name), size: info.size, path: filePath };
+  } catch {
+    return void 0;
+  }
+}
+async function readUpload(id) {
+  const attachment = await findUpload(id);
+  if (!attachment) return void 0;
+  return { attachment, data: await readFile4(attachment.path) };
+}
+async function listDirs(dir, showHidden) {
+  const target = path9.resolve(dir || config.home);
+  const entries = await readdir3(target, { withFileTypes: true });
+  const dirs = entries.filter((e) => (e.isDirectory() || e.isSymbolicLink()) && (showHidden || !e.name.startsWith("."))).map((e) => ({ name: e.name, path: path9.join(target, e.name) })).sort((a, b) => a.name.localeCompare(b.name));
+  const parent = path9.dirname(target);
+  return { path: target, ...parent !== target ? { parent } : {}, dirs };
+}
+async function removeUpload(id) {
+  if (!/^[0-9a-f-]{36}$/.test(id)) return;
+  await rm3(path9.join(uploadsDir(), id), { recursive: true, force: true });
+}
+var uploadsDir, MAX_UPLOAD_BYTES, safeName, MIME, mimeOf;
+var init_files = __esm({
+  "src/server/files.ts"() {
+    "use strict";
+    init_config();
+    uploadsDir = () => path9.join(config.stateDir, "uploads");
+    MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+    safeName = (name) => name.replace(/[/\\\0]/g, "_").replace(/^\.+/, "_").slice(0, 120) || "file";
+    MIME = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      pdf: "application/pdf",
+      txt: "text/plain",
+      md: "text/markdown",
+      json: "application/json",
+      csv: "text/csv"
+    };
+    mimeOf = (name) => MIME[name.split(".").pop()?.toLowerCase() ?? ""] ?? "application/octet-stream";
+  }
+});
+
+// src/server/trust.ts
+import { realpath as realpath2 } from "node:fs/promises";
+import os4 from "node:os";
+import { listSessions as listSessions2 } from "@anthropic-ai/claude-agent-sdk";
+async function claudeRanIn(folder) {
+  const dir = await realpath2(folder).catch(() => folder);
+  if (dir === os4.homedir()) return true;
+  const cached = cache2.get(dir);
+  if (cached && Date.now() - cached.at < (cached.value ? YES_MS : NO_MS)) return cached.value;
+  let value = false;
+  const sessions = await listSessions2({ dir, limit: 50, includeWorktrees: false }).catch(() => []);
+  for (const session of sessions) {
+    const file2 = await transcriptPath(session.sessionId);
+    const recorded = file2 ? (await lastTurnTime(file2))?.lastTurn?.cwd : void 0;
+    if (!recorded) continue;
+    if (recorded === dir || await realpath2(recorded).catch(() => "") === dir) {
+      value = true;
+      break;
+    }
+  }
+  if (cache2.size > 2e3) cache2.clear();
+  cache2.set(dir, { at: Date.now(), value });
+  return value;
+}
+var YES_MS, NO_MS, cache2;
+var init_trust = __esm({
+  "src/server/trust.ts"() {
+    "use strict";
+    init_transcripts();
+    YES_MS = 3e4;
+    NO_MS = 3e3;
+    cache2 = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/models.ts
+import { realpath as realpath3 } from "node:fs/promises";
+import os5 from "node:os";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+async function slot(work) {
+  if (running >= MAX_PROBES) await new Promise((resolve) => waiting.push(resolve));
+  running += 1;
+  try {
+    return await work();
+  } finally {
+    running -= 1;
+    waiting.shift()?.();
+  }
+}
+async function probe(key, cwd, ask) {
+  const dir = await realpath3(cwd);
+  const id = `${key}:${dir}`;
+  const pending = inflight.get(id);
+  if (pending) return pending;
+  const work = slot(async () => {
+    const q = query({
+      prompt: idlePrompt,
+      options: {
+        cwd: dir,
+        persistSession: false,
+        settingSources: await claudeRanIn(dir) ? ["user", "project", "local"] : ["user"],
+        ...config.claudeExecutable ? { pathToClaudeCodeExecutable: config.claudeExecutable } : {}
+      }
+    });
+    let timer;
+    try {
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Claude Code did not answer in time.")), PROBE_TIMEOUT_MS);
+      });
+      return await Promise.race([ask(q), timeout]);
+    } finally {
+      clearTimeout(timer);
+      q.close();
+    }
+  }).finally(() => inflight.delete(id));
+  inflight.set(id, work);
+  return work;
+}
+function toOption(info) {
+  return {
+    value: info.value,
+    label: info.displayName || info.value,
+    description: info.description ?? "",
+    efforts: info.supportedEffortLevels ?? [],
+    supportsFast: Boolean(info.supportsFastMode),
+    ...info.supportsAutoMode !== void 0 ? { supportsAuto: info.supportsAutoMode } : {},
+    ...info.resolvedModel ? { resolvedModel: info.resolvedModel } : {}
+  };
+}
+async function listModels() {
+  if (config.demo) return { models: DEMO_MODELS, signedIn: true, account: { email: "you@example.com", plan: "max" } };
+  if (cache3 && Date.now() - cache3.at < TTL_MS) return cache3.value;
+  const asking = probe("models", os5.homedir(), async (q) => {
+    const models = (await q.supportedModels()).map(toOption);
+    const account = await q.accountInfo().catch(() => void 0);
+    const signedIn2 = account ? Boolean(account.email || account.tokenSource || account.apiKeySource || account.apiProvider) : null;
+    const who = account?.email || account?.organization || account?.subscriptionType ? {
+      ...account.email ? { email: account.email } : {},
+      ...account.organization ? { organization: account.organization } : {},
+      ...account.subscriptionType ? { plan: account.subscriptionType } : {}
+    } : void 0;
+    return { models, signedIn: signedIn2, ...who ? { account: who } : {} };
+  }).then((value) => {
+    cache3 = { at: Date.now(), value };
+    return value;
+  });
+  try {
+    return await asking;
+  } catch (error) {
+    if (cache3) return cache3.value;
+    throw error;
+  }
+}
+async function listCompletions(cwd) {
+  if (config.demo) return { commands: DEMO_COMMANDS, agents: DEMO_AGENTS };
+  const dir = await realpath3(cwd);
+  const cached = completionCache.get(dir);
+  if (cached && Date.now() - cached.at < TTL_MS) return cached.value;
+  const value = await probe("completions", dir, async (q) => {
+    const [commands, agents] = await Promise.all([q.supportedCommands(), q.supportedAgents().catch(() => [])]);
+    return {
+      commands: commands.map((c) => ({ name: c.name, description: c.description ?? "", argumentHint: c.argumentHint ?? "" })),
+      agents: agents.map((a) => ({ name: a.name, description: a.description ?? "" }))
+    };
+  });
+  completionCache.set(dir, { at: Date.now(), value });
+  return value;
+}
+function toMcpServers(list2) {
+  return list2.map((server) => ({
+    name: server.name,
+    status: server.status,
+    ...server.error ? { error: server.error } : {},
+    tools: server.tools?.length ?? 0,
+    ...server.scope ? { scope: server.scope } : {}
+  }));
+}
+async function probeMcpServers(cwd) {
+  if (config.demo) return [{ name: "github", status: "connected", tools: 26, scope: "user" }, { name: "linear", status: "needs-auth", tools: 0, scope: "project" }];
+  const dir = await realpath3(cwd);
+  const cached = mcpCache.get(dir);
+  if (cached && Date.now() - cached.at < 6e4) return cached.servers;
+  const servers = toMcpServers(await probe("mcp", dir, (q) => q.mcpServerStatus()));
+  mcpCache.set(dir, { at: Date.now(), servers });
+  return servers;
+}
+async function planUsage() {
+  if (config.demo) return DEMO_PLAN;
+  if (planCache && Date.now() - planCache.at < 6e4) return planCache.value;
+  const value = await probe("usage", os5.homedir(), async (q) => {
+    const ask = q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET;
+    if (typeof ask !== "function") return null;
+    const answer = await ask.call(q, { skipBehaviors: true });
+    const limits3 = answer?.rate_limits;
+    if (!answer?.rate_limits_available || !limits3) return null;
+    const windows = [];
+    const add = (type, window, label) => {
+      if (!window || typeof window.utilization !== "number") return;
+      const resetsAt = window.resets_at ? Date.parse(window.resets_at) : NaN;
+      windows.push({ type, ...label ? { label } : {}, utilization: window.utilization / 100, ...Number.isFinite(resetsAt) ? { resetsAt } : {} });
+    };
+    add("five_hour", limits3.five_hour);
+    add("seven_day", limits3.seven_day);
+    add("seven_day_opus", limits3.seven_day_opus);
+    add("seven_day_sonnet", limits3.seven_day_sonnet);
+    for (const scoped of limits3.model_scoped ?? []) add(`model:${scoped.display_name}`, scoped, `Weekly ${scoped.display_name} limit`);
+    const extra = limits3.extra_usage;
+    return {
+      windows,
+      ...extra ? {
+        extra: {
+          enabled: Boolean(extra.is_enabled),
+          ...typeof extra.used_credits === "number" ? { usedCents: extra.used_credits } : {},
+          ...typeof extra.monthly_limit === "number" ? { limitCents: extra.monthly_limit } : {},
+          ...typeof extra.utilization === "number" ? { utilization: extra.utilization / 100 } : {},
+          ...extra.currency ? { currency: extra.currency } : {}
+        }
+      } : {}
+    };
+  }).catch(() => null);
+  planCache = { at: Date.now(), value };
+  return value;
+}
+var TTL_MS, PROBE_TIMEOUT_MS, MAX_PROBES, idlePrompt, running, waiting, inflight, cache3, DEMO_COMMANDS, DEMO_AGENTS, completionCache, mcpCache, DEMO_PLAN, planCache;
+var init_models = __esm({
+  "src/server/models.ts"() {
+    "use strict";
+    init_config();
+    init_demo();
+    init_trust();
+    TTL_MS = 10 * 60 * 1e3;
+    PROBE_TIMEOUT_MS = 3e4;
+    MAX_PROBES = 2;
+    idlePrompt = {
+      [Symbol.asyncIterator]: () => ({ next: () => new Promise(() => {
+      }) })
+    };
+    running = 0;
+    waiting = [];
+    inflight = /* @__PURE__ */ new Map();
+    DEMO_COMMANDS = [
+      { name: "compact", description: "Summarize the conversation so far to free up context", argumentHint: "" },
+      { name: "review", description: "Review the changes on this branch", argumentHint: "" },
+      { name: "init", description: "Write a CLAUDE.md for this project", argumentHint: "" }
+    ];
+    DEMO_AGENTS = [{ name: "code-reviewer", description: "Reviews a change for bugs and style" }];
+    completionCache = /* @__PURE__ */ new Map();
+    mcpCache = /* @__PURE__ */ new Map();
+    DEMO_PLAN = {
+      windows: [
+        { type: "five_hour", utilization: 0.42, resetsAt: Date.now() + 2.4 * 36e5 },
+        { type: "seven_day", utilization: 0.18, resetsAt: Date.now() + 3.5 * 864e5 }
+      ]
+    };
+  }
+});
+
+// src/server/git.ts
+import { execFile as execFile3 } from "node:child_process";
+import { realpathSync as realpathSync2 } from "node:fs";
+import path10 from "node:path";
+import { promisify as promisify3 } from "node:util";
+function environment() {
+  const env = { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0", GIT_LITERAL_PATHSPECS: "1" };
+  for (const name of Object.keys(env)) {
+    if (/^GIT_(DIR|WORK_TREE|INDEX_FILE|COMMON_DIR|OBJECT_DIRECTORY|ALTERNATE_OBJECT_DIRECTORIES|NAMESPACE|CONFIG_PARAMETERS|CONFIG_COUNT|CONFIG_KEY_\d+|CONFIG_VALUE_\d+|CEILING_DIRECTORIES)$/.test(name)) delete env[name];
+  }
+  if (config.demo) {
+    try {
+      env.GIT_CEILING_DIRECTORIES = path10.dirname(realpathSync2(config.home));
+    } catch {
+      env.GIT_CEILING_DIRECTORIES = path10.dirname(config.home);
+    }
+  }
+  return env;
+}
+async function git(cwd, args, timeout = 15e3) {
+  const command = args[0];
+  const extra = command === "diff" ? ["--no-ext-diff", "--no-textconv", "--ignore-submodules=dirty"] : command === "status" ? ["--ignore-submodules=dirty"] : [];
+  const { stdout } = await run3("git", [...SAFE, command, ...extra, ...args.slice(1)], { cwd, env: environment(), maxBuffer: 32 * 1024 * 1024, timeout });
+  return stdout;
+}
+var run3, SAFE;
+var init_git = __esm({
+  "src/server/git.ts"() {
+    "use strict";
+    init_config();
+    run3 = promisify3(execFile3);
+    SAFE = ["-c", "core.fsmonitor=false", "-c", "core.hooksPath=/dev/null", "-c", "safe.bareRepository=explicit", "-c", "core.quotepath=off"];
+  }
+});
+
+// src/server/project-files.ts
+import { readdir as readdir4 } from "node:fs/promises";
+import path11 from "node:path";
+async function projectFiles(cwd) {
+  const cached = cache4.get(cwd);
+  if (cached && Date.now() - cached.at < TTL_MS2) return cached.files;
+  let files;
+  try {
+    if (!config.demo && !await claudeRanIn(cwd)) throw new Error("not trusted");
+    const stdout = await git(cwd, ["ls-files", "--cached", "--others", "--exclude-standard"], 5e3);
+    files = stdout.split("\n").filter(Boolean).slice(0, MAX_FILES2);
+  } catch {
+    files = [];
+    const walk2 = async (dir, depth) => {
+      if (depth > 8 || files.length >= MAX_FILES2) return;
+      let entries;
+      try {
+        entries = await readdir4(path11.join(cwd, dir), { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (files.length >= MAX_FILES2) return;
+        if (entry.name.startsWith(".") || SKIP.has(entry.name)) continue;
+        const rel = dir ? `${dir}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) await walk2(rel, depth + 1);
+        else files.push(rel);
+      }
+    };
+    await walk2("", 0);
+  }
+  cache4.set(cwd, { at: Date.now(), files });
+  return files;
+}
+function score(file2, query3) {
+  const f = file2.toLowerCase();
+  const q = query3.toLowerCase();
+  const base = f.slice(f.lastIndexOf("/") + 1);
+  if (base === q) return 1e3;
+  if (base.startsWith(q)) return 800 - base.length;
+  if (base.includes(q)) return 600 - base.length;
+  if (f.includes(q)) return 400 - f.length / 10;
+  let at = 0;
+  for (const char of q) {
+    at = f.indexOf(char, at);
+    if (at === -1) return -1;
+    at += 1;
+  }
+  return 100 - f.length / 10;
+}
+async function searchFiles(cwd, query3, limit = 30) {
+  const files = await projectFiles(cwd);
+  const dirs = /* @__PURE__ */ new Set();
+  for (const file2 of files) {
+    let cut = file2.lastIndexOf("/");
+    while (cut > 0) {
+      dirs.add(`${file2.slice(0, cut)}/`);
+      cut = file2.lastIndexOf("/", cut - 1);
+    }
+  }
+  const candidates = [...files, ...dirs];
+  if (!query3) return files.slice().sort((a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b)).slice(0, limit);
+  return candidates.map((file2) => ({ file: file2, score: score(file2, query3) })).filter((m) => m.score >= 0).sort((a, b) => b.score - a.score || a.file.localeCompare(b.file)).slice(0, limit).map((m) => m.file);
+}
+var cache4, TTL_MS2, SKIP, MAX_FILES2;
+var init_project_files = __esm({
+  "src/server/project-files.ts"() {
+    "use strict";
+    init_config();
+    init_git();
+    init_trust();
+    cache4 = /* @__PURE__ */ new Map();
+    TTL_MS2 = 3e4;
+    SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".venv", "venv", "__pycache__", "target", ".cache"]);
+    MAX_FILES2 = 2e4;
+  }
+});
+
+// src/server/push.ts
+import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import path12 from "node:path";
+import webpush from "web-push";
+async function save(file2, value) {
+  await mkdir6(path12.dirname(file2), { recursive: true, mode: 448 });
+  await writeFile5(file2, JSON.stringify(value, null, 2), { mode: 384 });
+}
+async function initPush() {
+  try {
+    keys = JSON.parse(await readFile5(keysFile(), "utf8"));
+  } catch {
+    keys = webpush.generateVAPIDKeys();
+    await save(keysFile(), keys);
+  }
+  webpush.setVapidDetails("https://github.com/Ki-Seki/pelican", keys.publicKey, keys.privateKey);
+  try {
+    subscriptions = JSON.parse(await readFile5(subsFile(), "utf8"));
+  } catch {
+    subscriptions = [];
+  }
+}
+function pushKey() {
+  return keys?.publicKey;
+}
+async function addSubscription(subscription) {
+  subscriptions = subscriptions.filter((s) => s.endpoint !== subscription.endpoint);
+  subscriptions.push(subscription);
+  await save(subsFile(), subscriptions);
+}
+async function removeSubscription(endpoint) {
+  subscriptions = subscriptions.filter((s) => s.endpoint !== endpoint);
+  await save(subsFile(), subscriptions);
+}
+async function notify(payload) {
+  if (!keys || subscriptions.length === 0) return;
+  const gone = [];
+  await Promise.all(subscriptions.map(async (subscription) => {
+    const id = encodeURIComponent(payload.sessionId);
+    const url = config.sessionUrl ? config.sessionUrl.replaceAll("{id}", id) : subscription.openUrl ? `${subscription.openUrl}${id}` : void 0;
+    const body = JSON.stringify({ ...payload, url });
+    try {
+      await webpush.sendNotification(subscription, body, { TTL: 3600, urgency: "high" });
+    } catch (error) {
+      const status = error.statusCode;
+      if (status === 404 || status === 410) gone.push(subscription.endpoint);
+      else console.warn("[pelican] push failed", status ?? error.message);
+    }
+  }));
+  if (gone.length > 0) {
+    subscriptions = subscriptions.filter((s) => !gone.includes(s.endpoint));
+    await save(subsFile(), subscriptions);
+  }
+}
+var keysFile, subsFile, keys, subscriptions;
+var init_push = __esm({
+  "src/server/push.ts"() {
+    "use strict";
+    init_config();
+    keysFile = () => path12.join(config.stateDir, "vapid.json");
+    subsFile = () => path12.join(config.stateDir, "push-subscriptions.json");
+    subscriptions = [];
+  }
+});
+
+// src/server/shell.ts
+import { spawn } from "node:child_process";
+function runCommand(cwd, command) {
+  const shell = process.env.SHELL || "/bin/bash";
+  const started = Date.now();
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let truncated = false;
+    const child = spawn(shell, ["-lc", command], { cwd, env: { ...process.env, PAGER: "cat", GIT_PAGER: "cat", TERM: "dumb" }, stdio: ["ignore", "pipe", "pipe"] });
+    const take = (current, chunk) => {
+      if (current.length >= MAX_OUTPUT) {
+        truncated = true;
+        return current;
+      }
+      const next = current + chunk.toString("utf8");
+      if (next.length > MAX_OUTPUT) truncated = true;
+      return next.slice(0, MAX_OUTPUT);
+    };
+    child.stdout.on("data", (chunk) => {
+      stdout = take(stdout, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = take(stderr, chunk);
+    });
+    const timer = setTimeout(() => child.kill("SIGKILL"), TIMEOUT_MS);
+    const finish = (code, error) => {
+      clearTimeout(timer);
+      resolve({
+        command,
+        stdout,
+        stderr: error ? `${stderr}${error.message}` : stderr,
+        code,
+        durationMs: Date.now() - started,
+        ...truncated ? { truncated: true } : {}
+      });
+    };
+    child.on("error", (error) => finish(null, error));
+    child.on("close", (code, signal) => finish(signal ? null : code));
+  });
+}
+function bashModeText(result2) {
+  const note2 = result2.code === null ? "\n(stopped after two minutes)" : result2.code !== 0 ? `
+(exit code ${result2.code})` : "";
+  return `<bash-input>${escape(result2.command)}</bash-input><bash-stdout>${escape(result2.stdout)}</bash-stdout><bash-stderr>${escape(result2.stderr + note2)}</bash-stderr>`;
+}
+var MAX_OUTPUT, TIMEOUT_MS, escape;
+var init_shell = __esm({
+  "src/server/shell.ts"() {
+    "use strict";
+    MAX_OUTPUT = 2e5;
+    TIMEOUT_MS = 2 * 6e4;
+    escape = (text2) => text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+});
+
+// src/server/usage.ts
+function recordLimit(info) {
+  const type = info.rateLimitType ?? "unknown";
+  limits.set(type, {
+    type,
+    status: info.status,
+    ...typeof info.utilization === "number" ? { utilization: info.utilization } : {},
+    ...typeof info.resetsAt === "number" ? { resetsAt: info.resetsAt < 1e12 ? info.resetsAt * 1e3 : info.resetsAt } : {},
+    at: Date.now()
+  });
+}
+function usageLimits() {
+  const now = Date.now();
+  return [...limits.values()].filter((limit) => !limit.resetsAt || limit.resetsAt > now);
+}
+var limits;
+var init_usage = __esm({
+  "src/server/usage.ts"() {
+    "use strict";
+    limits = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/runner.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { readFile as readFile6, stat as stat6 } from "node:fs/promises";
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+function readableError(text2) {
+  if (text2.includes("Resume rejected by --resume-drops-turn")) {
+    return "The conversation changed after that prompt (another app added to it), so the prompt was not replaced. Reload, then edit it again or send a new message.";
+  }
+  return text2;
+}
+function getRun(sessionId) {
+  const run4 = runs.get(sessionId);
+  return run4 && !run4.closed ? run4 : void 0;
+}
+function runStatus(sessionId) {
+  if (config.demo) return sessionId === DEMO_WAITING_SESSION ? "waiting" : void 0;
+  return getRun(sessionId)?.status();
+}
+function runState(sessionId) {
+  if (config.demo) return demoRunState(sessionId);
+  return getRun(sessionId)?.state();
+}
+async function isDirectory2(dir) {
+  return stat6(dir).then((s) => s.isDirectory(), () => false);
+}
+async function staleRun(run4) {
+  if (run4.busy || run4.hasBackgroundTasks) return false;
+  const other = (await liveProcesses()).get(run4.sessionId);
+  if (other?.updatedAt && other.updatedAt > run4.lastActive) return true;
+  const file2 = await transcriptPath(run4.sessionId);
+  const last = file2 ? (await lastTurnTime(file2))?.lastTurn : void 0;
+  return Boolean(last && !last.copied && last.time > run4.lastActive + 2e3);
+}
+async function currentRun(sessionId) {
+  const run4 = getRun(sessionId);
+  if (run4 && await staleRun(run4)) {
+    run4.close();
+    if (runs.get(sessionId) === run4) runs.delete(sessionId);
+    return getRun(sessionId);
+  }
+  return run4;
+}
+async function sendMessage(target, input) {
+  if (config.demo) throw new Error("This is the demo: nothing runs. Start Pelican without --demo to talk to Claude.");
+  if (target.sessionId) {
+    const existing = await currentRun(target.sessionId);
+    if (existing) {
+      await existing.send(input);
+      return existing.sessionId;
+    }
+    const info = await sessionInfo(target.sessionId);
+    const cwd2 = info?.cwd ?? target.cwd;
+    if (!cwd2 || !await isDirectory2(cwd2)) throw new Error(`The session's folder is missing: ${cwd2 ?? "(unknown)"}`);
+    const started = getRun(target.sessionId);
+    if (started) {
+      await started.send(input);
+      return started.sessionId;
+    }
+    const run5 = new SessionRun(target.sessionId, cwd2, input.settings, true);
+    runs.set(run5.sessionId, run5);
+    run5.start();
+    await run5.send(input);
+    return run5.sessionId;
+  }
+  const cwd = target.cwd;
+  if (!cwd || !await isDirectory2(cwd)) throw new Error(`Not a folder: ${cwd ?? "(none)"}`);
+  const run4 = new SessionRun(randomUUID4(), cwd, input.settings, false);
+  runs.set(run4.sessionId, run4);
+  run4.start();
+  await run4.send(input);
+  return run4.sessionId;
+}
+async function replaceLastTurn(sessionId, cwd, entry, prompt, input) {
+  if (config.demo) throw new Error("This is the demo: nothing runs.");
+  const existing = getRun(sessionId);
+  if (existing?.busy) throw new Error("Stop Claude before editing a prompt.");
+  if (existing) {
+    existing.close();
+    runs.delete(sessionId);
+  }
+  const run4 = new SessionRun(sessionId, cwd, input.settings, true, { entry, dropsTurn: prompt });
+  runs.set(sessionId, run4);
+  run4.start();
+  await run4.send(input);
+  return sessionId;
+}
+async function ensureRun(sessionId, settings = {}) {
+  if (config.demo) throw new Error("This is the demo: nothing runs.");
+  const existing = await currentRun(sessionId);
+  if (existing) return existing;
+  const info = await sessionInfo(sessionId);
+  const cwd = info?.cwd;
+  if (!cwd || !await isDirectory2(cwd)) throw new Error(`The session's folder is missing: ${cwd ?? "(unknown)"}`);
+  const started = getRun(sessionId);
+  if (started) return started;
+  const run4 = new SessionRun(sessionId, cwd, settings, true);
+  runs.set(sessionId, run4);
+  run4.start();
+  return run4;
+}
+function closeAll() {
+  for (const run4 of runs.values()) run4.close();
+}
+var InputQueue, sdkModel, SessionRun, runs;
+var init_runner = __esm({
+  "src/server/runner.ts"() {
+    "use strict";
+    init_config();
+    init_demo();
+    init_models();
+    init_feed();
+    init_live();
+    init_normalize();
+    init_push();
+    init_sessions();
+    init_shell();
+    init_transcripts();
+    init_usage();
+    InputQueue = class {
+      items = [];
+      waiters = [];
+      done = false;
+      push(item) {
+        const waiter = this.waiters.shift();
+        if (waiter) waiter({ value: item, done: false });
+        else this.items.push(item);
+      }
+      close() {
+        this.done = true;
+        for (const waiter of this.waiters.splice(0)) waiter({ value: void 0, done: true });
+      }
+      [Symbol.asyncIterator]() {
+        return {
+          next: () => {
+            const item = this.items.shift();
+            if (item) return Promise.resolve({ value: item, done: false });
+            if (this.done) return Promise.resolve({ value: void 0, done: true });
+            return new Promise((resolve) => this.waiters.push(resolve));
+          }
+        };
+      }
+    };
+    sdkModel = (model) => model && model !== "default" ? model : void 0;
+    SessionRun = class {
+      constructor(sessionId, cwd, settings, resume, resumeAt) {
+        this.sessionId = sessionId;
+        this.cwd = cwd;
+        this.settings = settings;
+        this.resume = resume;
+        this.resumeAt = resumeAt;
+      }
+      sessionId;
+      cwd;
+      settings;
+      resume;
+      resumeAt;
+      busy = false;
+      closed = false;
+      error;
+      lastActive = Date.now();
+      partial = [];
+      completedBlocks = 0;
+      permissions = /* @__PURE__ */ new Map();
+      input = new InputQueue();
+      q;
+      emitTimer;
+      title = "";
+      /** Set by Stop: the turn then ends with an error result that is not a failure. */
+      interrupted = false;
+      lastTurn;
+      context;
+      activity;
+      tasks = [];
+      get hasBackgroundTasks() {
+        return this.tasks.length > 0;
+      }
+      /** Messages waiting for the turn to end, published when it does. */
+      queued = [];
+      started;
+      /** Settles once Claude has started (its first message), or fails when it ends before that. */
+      ready = new Promise((resolve, reject) => {
+        this.started = { resolve, reject };
+      });
+      // Most callers never wait for it: a failure here must not count as unhandled.
+      readyHandled = this.ready.catch(() => void 0);
+      suggestion;
+      start() {
+        const settings = this.settings;
+        const options = {
+          cwd: this.cwd,
+          ...this.resume ? { resume: this.sessionId } : { sessionId: this.sessionId },
+          // Claude Code checks that everything past the entry belongs to the dropped turn, so a
+          // message another app added meanwhile is never thrown away unseen.
+          ...this.resume && this.resumeAt ? { resumeSessionAt: this.resumeAt.entry, resumeDropsTurn: this.resumeAt.dropsTurn } : {},
+          ...sdkModel(settings.model) ? { model: sdkModel(settings.model) } : {},
+          ...settings.effort ? { effort: settings.effort } : {},
+          permissionMode: settings.permissionMode ?? "default",
+          allowDangerouslySkipPermissions: true,
+          ...settings.fast || settings.ultracode ? {
+            settings: {
+              ...settings.fast ? { fastMode: true } : {},
+              // Ultracode needs workflows; both are session settings, like the CLI's --settings.
+              ...settings.ultracode ? { ultracode: true, enableWorkflows: true } : {}
+            }
+          } : {},
+          includePartialMessages: true,
+          // Lets "Rewind code" put files back the way they were before a prompt.
+          enableFileCheckpointing: true,
+          promptSuggestions: true,
+          settingSources: ["user", "project", "local"],
+          systemPrompt: { type: "preset", preset: "claude_code" },
+          tools: { type: "preset", preset: "claude_code" },
+          canUseTool: this.canUseTool,
+          ...config.claudeExecutable ? { pathToClaudeCodeExecutable: config.claudeExecutable } : {},
+          stderr: (data) => {
+            if (process.env.PELICAN_DEBUG) process.stderr.write(`[claude ${this.sessionId.slice(0, 8)}] ${data}`);
+          }
+        };
+        this.q = query2({ prompt: this.input, options });
+        void this.pump();
+        void sessionInfo(this.sessionId).then((info) => {
+          if (info) this.title = info.customTitle || info.summary || "";
+        });
+      }
+      state() {
+        return {
+          sessionId: this.sessionId,
+          cwd: this.cwd,
+          busy: this.busy,
+          settings: this.settings,
+          permissions: [...this.permissions.values()].map((p) => p.request),
+          partial: this.partial.slice(this.completedBlocks).filter(Boolean),
+          ...this.error ? { error: this.error } : {},
+          ...this.lastTurn ? { lastTurn: this.lastTurn } : {},
+          ...this.context ? { context: this.context } : {},
+          ...this.activity ? { activity: this.activity } : {},
+          ...this.tasks.length > 0 ? { tasks: this.tasks } : {},
+          ...this.queued.length > 0 ? { queued: this.queued.map((m) => m.uuid) } : {},
+          ...this.suggestion && !this.busy ? { suggestion: this.suggestion } : {}
+        };
+      }
+      status() {
+        if (this.permissions.size > 0) return "waiting";
+        return this.busy ? "running" : "idle";
+      }
+      /** Sends the run state now, or within 80 ms when called for streamed text. */
+      emit(soon = false) {
+        if (soon) {
+          if (this.emitTimer) return;
+          this.emitTimer = setTimeout(() => {
+            this.emitTimer = void 0;
+            this.emitNow();
+          }, 80);
+          return;
+        }
+        clearTimeout(this.emitTimer);
+        this.emitTimer = void 0;
+        this.emitNow();
+      }
+      lastStatus;
+      emitNow() {
+        const state = this.state();
+        feedFor(this.sessionId).broadcast({ type: "run", state });
+        const status = this.status();
+        if (status !== this.lastStatus) {
+          this.lastStatus = status;
+          broadcastAll({ type: "status", sessionId: this.sessionId, status });
+        }
+      }
+      setBusy(busy) {
+        if (this.busy === busy) return;
+        this.busy = busy;
+        this.lastActive = Date.now();
+        if (!busy) {
+          this.partial = [];
+          this.completedBlocks = 0;
+        }
+        this.emit();
+        sessionsChanged();
+      }
+      async send(input) {
+        await this.applySettings(input.settings);
+        const uuid = input.uuid ?? randomUUID4();
+        const content = [];
+        const fileLines = [];
+        for (const attachment of input.attachments) {
+          if (attachment.mime.startsWith("image/") && attachment.size <= 5 * 1024 * 1024) {
+            const data = await readFile6(attachment.path).catch(() => void 0);
+            if (data) {
+              content.push({ type: "image", source: { type: "base64", media_type: attachment.mime, data: data.toString("base64") } });
+              continue;
+            }
+          }
+          fileLines.push(`- ${attachment.path} (${attachment.name})`);
+        }
+        let text2 = input.text;
+        if (fileLines.length > 0) text2 = `${text2}${text2 ? "\n\n" : ""}Attached files:
+${fileLines.join("\n")}`;
+        if (text2) content.push({ type: "text", text: text2 });
+        const queue = this.busy && input.mode === "queue";
+        const message = {
+          type: "user",
+          uuid,
+          session_id: this.sessionId,
+          parent_tool_use_id: null,
+          origin: { kind: "human" },
+          ...this.busy ? { priority: queue ? "later" : "next" } : {},
+          message: { role: "user", content }
+        };
+        this.error = void 0;
+        this.suggestion = void 0;
+        const chat = toChatMessage({ type: "user", uuid, message: { role: "user", content } });
+        if (queue) {
+          if (chat) this.queued.push({ ...chat, timestamp: Date.now() });
+          this.emit();
+        } else {
+          this.setBusy(true);
+          if (chat) await feedFor(this.sessionId).publish({ ...chat, timestamp: Date.now() });
+        }
+        this.input.push(message);
+      }
+      /**
+       * Adds a `!` command and its output to the conversation without starting a
+       * turn, the way Claude Code's bash mode does: Claude reads it with the next message.
+       */
+      async appendShell(result2) {
+        const uuid = randomUUID4();
+        const text2 = bashModeText(result2);
+        const message = {
+          type: "user",
+          uuid,
+          session_id: this.sessionId,
+          parent_tool_use_id: null,
+          origin: { kind: "human" },
+          shouldQuery: false,
+          message: { role: "user", content: text2 }
+        };
+        const chat = toChatMessage({ type: "user", uuid, message: { role: "user", content: text2 } });
+        if (chat) await feedFor(this.sessionId).publish({ ...chat, timestamp: Date.now() });
+        this.input.push(message);
+      }
+      /** Puts files back the way they were before the prompt `uuid`; `dryRun` only says what would change. */
+      async rewind(uuid, dryRun) {
+        if (!this.q) throw new Error("Claude is not running in this session");
+        const result2 = await this.q.rewindFiles(uuid, { dryRun });
+        return {
+          canRewind: result2.canRewind,
+          ...result2.error ? { error: result2.error } : {},
+          ...result2.filesChanged ? { files: result2.filesChanged } : {},
+          ...typeof result2.insertions === "number" ? { insertions: result2.insertions } : {},
+          ...typeof result2.deletions === "number" ? { deletions: result2.deletions } : {}
+        };
+      }
+      async mcpServers() {
+        if (!this.q) return [];
+        return toMcpServers(await this.q.mcpServerStatus());
+      }
+      async setMcpServer(name, change) {
+        if (!this.q) throw new Error("Claude is not running in this session");
+        if (change.reconnect) await this.q.reconnectMcpServer(name);
+        if (change.enabled !== void 0) await this.q.toggleMcpServer(name, change.enabled);
+      }
+      async stopTask(taskId) {
+        await this.q?.stopTask(taskId);
+      }
+      async applySettings(next) {
+        const q = this.q;
+        if (!q) return;
+        const prev = this.settings;
+        try {
+          if ((next.model ?? "default") !== (prev.model ?? "default")) await q.setModel(sdkModel(next.model));
+          if ((next.effort ?? "") !== (prev.effort ?? "") || Boolean(next.ultracode) !== Boolean(prev.ultracode)) {
+            await q.applyFlagSettings({
+              effortLevel: next.effort ?? null,
+              ultracode: Boolean(next.ultracode),
+              ...next.ultracode ? { enableWorkflows: true } : {}
+            });
+          }
+          if (Boolean(next.fast) !== Boolean(prev.fast)) await q.applyFlagSettings({ fastMode: Boolean(next.fast) });
+          if (next.permissionMode && next.permissionMode !== (prev.permissionMode ?? "default")) await q.setPermissionMode(next.permissionMode);
+        } catch (error) {
+          console.warn("[pelican] could not apply settings", error.message);
+        }
+        this.settings = { ...prev, ...next };
+      }
+      async setPermissionMode(mode) {
+        await this.applySettings({ ...this.settings, permissionMode: mode });
+        this.emit();
+      }
+      /** Settings changed in the composer, applied to Claude now: from its next step, also mid-turn. */
+      async updateSettings(next) {
+        await this.applySettings({ ...this.settings, ...next });
+        this.emit();
+      }
+      canUseTool = (toolName, input, { signal, suggestions, blockedPath, decisionReason }) => {
+        const id = randomUUID4();
+        const request = {
+          id,
+          sessionId: this.sessionId,
+          toolName,
+          input,
+          canRemember: Boolean(suggestions && suggestions.length > 0),
+          ...decisionReason ? { reason: decisionReason } : {},
+          ...blockedPath ? { blockedPath } : {},
+          createdAt: Date.now()
+        };
+        return new Promise((resolve) => {
+          this.permissions.set(id, { request, input, ...suggestions ? { suggestions } : {}, resolve });
+          signal.addEventListener("abort", () => {
+            if (this.permissions.delete(id)) {
+              resolve({ behavior: "deny", message: "Cancelled." });
+              this.emit();
+              sessionsChanged();
+            }
+          });
+          this.emit();
+          sessionsChanged();
+          const what = toolName === "AskUserQuestion" ? "has a question for you" : toolName === "ExitPlanMode" ? "has a plan for you to review" : `wants to use ${toolName}`;
+          void notify({ title: this.title || "Claude Code", body: `Claude ${what}`, sessionId: this.sessionId, tag: `${this.sessionId}:ask` });
+        });
+      };
+      decide(id, decision) {
+        const pending = this.permissions.get(id);
+        if (!pending) return false;
+        this.permissions.delete(id);
+        if (decision.behavior === "allow") {
+          pending.resolve({
+            behavior: "allow",
+            updatedInput: decision.updatedInput ?? pending.input,
+            ...decision.remember && pending.suggestions ? { updatedPermissions: pending.suggestions } : {}
+          });
+          if (decision.permissionMode) void this.setPermissionMode(decision.permissionMode);
+        } else {
+          pending.resolve({ behavior: "deny", message: decision.message?.trim() || "The user declined this." });
+        }
+        this.emit();
+        sessionsChanged();
+        return true;
+      }
+      async interrupt() {
+        this.interrupted = true;
+        for (const [id] of this.permissions) this.decide(id, { behavior: "deny", message: "Interrupted by the user." });
+        try {
+          await this.q?.interrupt();
+        } catch (error) {
+          console.warn("[pelican] interrupt failed", error.message);
+        }
+      }
+      close() {
+        if (this.closed) return;
+        this.closed = true;
+        for (const [id] of this.permissions) this.decide(id, { behavior: "deny", message: "Session closed." });
+        this.input.close();
+        try {
+          this.q?.close();
+        } catch {
+        }
+      }
+      /** How full the context window is now; shown in the session header. */
+      async readContext() {
+        try {
+          const usage = await this.q?.getContextUsage();
+          if (!usage) return;
+          this.context = { percent: Math.round(usage.percentage), tokens: usage.totalTokens, max: usage.maxTokens };
+          this.emit();
+        } catch {
+        }
+      }
+      onStream(event) {
+        const index2 = typeof event.index === "number" ? event.index : -1;
+        switch (event.type) {
+          case "message_start":
+            this.partial = [];
+            this.completedBlocks = 0;
+            break;
+          case "content_block_start": {
+            const block = event.content_block ?? {};
+            if (block.type === "text") this.partial[index2] = { type: "text", text: "" };
+            else if (block.type === "thinking") this.partial[index2] = { type: "thinking", thinking: "" };
+            else if (block.type === "tool_use" || block.type === "server_tool_use") {
+              this.partial[index2] = { type: "tool_use", name: String(block.name ?? ""), inputJson: "" };
+            }
+            break;
+          }
+          case "content_block_delta": {
+            const delta = event.delta ?? {};
+            const block = this.partial[index2];
+            if (!block) break;
+            if (block.type === "text" && delta.type === "text_delta") block.text += String(delta.text ?? "");
+            else if (block.type === "thinking" && delta.type === "thinking_delta") block.thinking += String(delta.thinking ?? "");
+            else if (block.type === "tool_use" && delta.type === "input_json_delta") block.inputJson += String(delta.partial_json ?? "");
+            break;
+          }
+          default:
+            return;
+        }
+        this.setBusy(true);
+        this.emit(true);
+      }
+      async pump() {
+        const q = this.q;
+        try {
+          for await (const message of q) {
+            this.lastActive = Date.now();
+            this.started.resolve();
+            const raw = message;
+            switch (message.type) {
+              case "stream_event":
+                if (!message.parent_tool_use_id) this.onStream(message.event);
+                break;
+              case "assistant":
+              case "user": {
+                if (raw.parent_tool_use_id) break;
+                if (message.type === "assistant") this.completedBlocks += 1;
+                if (this.activity?.kind === "retrying") this.activity = void 0;
+                const chat = toChatMessage(raw);
+                if (chat) await feedFor(this.sessionId).publish({ ...chat, timestamp: chat.timestamp ?? Date.now() });
+                this.emit(true);
+                break;
+              }
+              case "system":
+                if (message.subtype === "session_state_changed") {
+                  const state = raw.state;
+                  if (state === "running" || state === "requires_action") this.setBusy(true);
+                  else if (state === "idle") this.setBusy(false);
+                } else if (message.subtype === "init") {
+                  void refreshTranscriptIndex().then(sessionsChanged);
+                } else if (message.subtype === "status") {
+                  this.activity = message.status === "compacting" ? { kind: "compacting" } : void 0;
+                  this.emit();
+                } else if (message.subtype === "api_retry") {
+                  this.activity = { kind: "retrying", attempt: message.attempt, max: message.max_retries, delayMs: message.retry_delay_ms };
+                  this.emit();
+                } else if (message.subtype === "background_tasks_changed") {
+                  this.tasks = message.tasks.filter((t) => !t.ambient).map((t) => ({ id: t.task_id, description: t.description, type: t.subagent_type ?? t.task_type }));
+                  this.emit();
+                }
+                break;
+              case "rate_limit_event":
+                recordLimit(message.rate_limit_info);
+                break;
+              case "prompt_suggestion":
+                this.suggestion = message.suggestion;
+                this.emit();
+                break;
+              case "result": {
+                const stopped = this.interrupted;
+                this.interrupted = false;
+                const failed = !stopped && (message.subtype !== "success" || message.is_error);
+                this.error = failed ? readableError("errors" in message && message.errors.length > 0 ? message.errors.join("\n") : "result" in message ? String(message.result) : message.subtype) : void 0;
+                this.lastTurn = {
+                  durationMs: message.duration_ms,
+                  ...typeof message.total_cost_usd === "number" ? { costUsd: message.total_cost_usd } : {},
+                  ...typeof message.usage?.output_tokens === "number" ? { outputTokens: message.usage.output_tokens } : {}
+                };
+                this.activity = void 0;
+                for (const waiting2 of this.queued.splice(0)) await feedFor(this.sessionId).publish(waiting2);
+                this.setBusy(false);
+                this.emit();
+                void this.readContext();
+                if (!stopped) {
+                  void notify({
+                    title: this.title || "Claude Code",
+                    body: failed ? `Stopped: ${this.error ?? "error"}`.slice(0, 180) : "Finished",
+                    sessionId: this.sessionId,
+                    tag: `${this.sessionId}:done`
+                  });
+                }
+                break;
+              }
+              default:
+                break;
+            }
+          }
+        } catch (error) {
+          this.error = readableError(error.message);
+          console.warn(`[pelican] session ${this.sessionId.slice(0, 8)} ended with an error:`, this.error);
+        } finally {
+          this.closed = true;
+          this.started.reject(new Error(this.error ?? "Claude Code stopped before it started"));
+          for (const [, pending] of this.permissions) pending.resolve({ behavior: "deny", message: "Session closed." });
+          this.permissions.clear();
+          this.setBusy(false);
+          this.emit();
+          if (runs.get(this.sessionId) === this) runs.delete(this.sessionId);
+          sessionsChanged();
+        }
+      }
+    };
+    runs = /* @__PURE__ */ new Map();
+    setInterval(() => {
+      for (const run4 of runs.values()) {
+        if (!run4.busy && run4.status() === "idle" && Date.now() - run4.lastActive > config.idleCloseMs) run4.close();
+      }
+    }, 6e4).unref();
+  }
+});
+
+// src/server/workspace.ts
+import { open as open3, readdir as readdir5, realpath as realpath4, stat as stat7 } from "node:fs/promises";
+import path13 from "node:path";
+function inside(cwd, relative) {
+  if ((relative ?? "").split(/[\\/]/).includes("..")) throw new Error(OUTSIDE);
+  const root = path13.resolve(cwd);
+  const full = path13.resolve(root, relative || ".");
+  if (!within(root, full)) throw new Error(OUTSIDE);
+  return full;
+}
+async function insideReal(cwd, relative) {
+  const full = inside(cwd, relative);
+  const [root, real] = await Promise.all([realpath4(cwd), realpath4(full)]);
+  if (!within(root, real)) throw new Error(OUTSIDE);
+  return real;
+}
+async function repositoryOf(cwd) {
+  try {
+    const top = (await git(cwd, ["rev-parse", "--show-toplevel"], 5e3)).trim();
+    if (!top) return void 0;
+    const [root, folder] = await Promise.all([realpath4(top), realpath4(cwd)]);
+    return within(root, folder) ? root : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function gitStatus(cwd) {
+  if (!await repositoryOf(cwd)) return { repo: false };
+  let raw;
+  let prefix = "";
+  try {
+    prefix = (await git(cwd, ["rev-parse", "--show-prefix"], 5e3)).trim();
+    raw = await git(cwd, ["status", "--porcelain=v2", "--branch", "-z", "--untracked-files=all", "--", "."]);
+  } catch {
+    return { repo: false };
+  }
+  const local = (file2) => file2 && prefix && file2.startsWith(prefix) ? file2.slice(prefix.length) : file2;
+  const out = { repo: true, files: [] };
+  const entries = raw.split("\0");
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i];
+    if (entry.startsWith("# branch.head ")) {
+      const head = entry.slice(14);
+      if (head !== "(detached)") out.branch = head;
+    } else if (entry.startsWith("# branch.ab ")) {
+      const [ahead, behind] = entry.slice(12).split(" ");
+      out.ahead = Number(ahead?.slice(1)) || 0;
+      out.behind = Number(behind?.slice(1)) || 0;
+    } else if (entry.startsWith("1 ") || entry.startsWith("2 ") || entry.startsWith("u ")) {
+      const parts = entry.split(" ");
+      const xy = parts[1] ?? "..";
+      const code = xy[0] !== "." ? xy[0] : xy[1];
+      const file2 = entry.startsWith("1 ") ? parts.slice(8).join(" ") : entry.startsWith("2 ") ? parts.slice(9).join(" ") : parts.slice(10).join(" ");
+      const status = entry.startsWith("u ") ? "conflicted" : KIND[code] ?? "modified";
+      const item = { path: local(file2), status };
+      if (entry.startsWith("2 ")) {
+        const from = local(entries[i + 1]);
+        if (from) item.from = from;
+        i += 1;
+      }
+      out.files.push(item);
+    } else if (entry.startsWith("? ")) {
+      out.files.push({ path: local(entry.slice(2)), status: "untracked" });
+    }
+  }
+  try {
+    const base = await git(cwd, ["rev-parse", "--verify", "-q", "HEAD"]).then(() => "HEAD", () => "4b825dc642cb6eb9a060e54bf8d69288fbee4904");
+    const numstat = await git(cwd, ["diff", "--numstat", "--relative", "-z", base]);
+    const counts = /* @__PURE__ */ new Map();
+    const fields = numstat.split("\0");
+    for (let i = 0; i < fields.length; i += 1) {
+      const field = fields[i];
+      if (!field) continue;
+      const [added, removed, name] = field.split("	");
+      const file2 = name === "" ? fields[i += 2] : name;
+      if (!file2) continue;
+      counts.set(file2, { ...added !== "-" ? { added: Number(added) } : {}, ...removed !== "-" ? { removed: Number(removed) } : {} });
+    }
+    for (const file2 of out.files) Object.assign(file2, counts.get(file2.path) ?? {});
+  } catch {
+  }
+  await Promise.all(out.files.filter((f) => f.status === "untracked").slice(0, 200).map(async (file2) => {
+    try {
+      const content = await readProjectFile(cwd, file2.path);
+      if (content.text !== void 0) file2.added = content.text.split("\n").length - (content.text.endsWith("\n") ? 1 : 0);
+    } catch {
+    }
+  }));
+  return out;
+}
+async function gitDiff(cwd, file2) {
+  if (!await repositoryOf(cwd)) return "";
+  const full = inside(cwd, file2);
+  const [root, parent] = await Promise.all([realpath4(cwd), realpath4(path13.dirname(full)).catch(() => void 0)]);
+  if (parent && !within(root, parent)) throw new Error(OUTSIDE);
+  let diff = "";
+  try {
+    diff = await git(cwd, ["diff", "HEAD", "--", file2]);
+  } catch {
+    diff = "";
+  }
+  if (!diff) {
+    diff = await git(cwd, ["diff", "--no-index", "--", "/dev/null", `./${file2}`]).catch((error) => error.stdout ?? "");
+  }
+  return diff.length > MAX_DIFF ? `${diff.slice(0, MAX_DIFF)}
+\u2026 (diff cut short)` : diff;
+}
+async function listTree(cwd, relative) {
+  const dir = await insideReal(cwd, relative);
+  const names = await readdir5(dir, { withFileTypes: true });
+  const entries = [];
+  for (const entry of names) {
+    if (HIDDEN.has(entry.name)) continue;
+    const rel = path13.join(relative, entry.name);
+    if (entry.isDirectory()) entries.push({ name: entry.name, path: rel, dir: true });
+    else if (entry.isFile() || entry.isSymbolicLink()) {
+      const size = await stat7(path13.join(dir, entry.name)).then((s) => s.isDirectory() ? -1 : s.size, () => void 0);
+      if (size === -1) entries.push({ name: entry.name, path: rel, dir: true });
+      else entries.push({ name: entry.name, path: rel, dir: false, ...size !== void 0 ? { size } : {} });
+    }
+  }
+  return entries.sort((a, b) => Number(b.dir) - Number(a.dir) || a.name.localeCompare(b.name, void 0, { numeric: true }));
+}
+async function readProjectFile(cwd, relative) {
+  const full = await insideReal(cwd, relative);
+  const info = await stat7(full);
+  const ext = path13.extname(full).slice(1).toLowerCase();
+  const handle = await open3(full, "r");
+  try {
+    if (IMAGE[ext] && info.size <= 4 * 1024 * 1024) {
+      const data2 = Buffer.alloc(info.size);
+      await handle.read(data2, 0, info.size, 0);
+      return { path: relative, size: info.size, image: `data:${IMAGE[ext]};base64,${data2.toString("base64")}` };
+    }
+    const length = Math.min(info.size, MAX_FILE);
+    const data = Buffer.alloc(length);
+    await handle.read(data, 0, length, 0);
+    if (data.subarray(0, 8e3).includes(0)) return { path: relative, size: info.size, binary: true };
+    return { path: relative, size: info.size, text: data.toString("utf8"), ...info.size > MAX_FILE ? { truncated: true } : {} };
+  } finally {
+    await handle.close();
+  }
+}
+var MAX_FILE, MAX_DIFF, OUTSIDE, within, KIND, HIDDEN, IMAGE;
+var init_workspace = __esm({
+  "src/server/workspace.ts"() {
+    "use strict";
+    init_git();
+    MAX_FILE = 512 * 1024;
+    MAX_DIFF = 4e5;
+    OUTSIDE = "That path is outside the session\u2019s folder";
+    within = (root, full) => full === root || full.startsWith(`${root}${path13.sep}`);
+    KIND = { M: "modified", T: "modified", A: "added", D: "deleted", R: "renamed", C: "added", U: "conflicted" };
+    HIDDEN = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store"]);
+    IMAGE = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", svg: "image/svg+xml" };
+  }
+});
+
+// src/server/app.ts
+import { readFile as readFile7, realpath as realpath5, stat as stat8 } from "node:fs/promises";
+import { isIP } from "node:net";
+import path14 from "node:path";
+import { getConnInfo } from "@hono/node-server/conninfo";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+function clientAddress(c) {
+  let remote = "unknown";
+  try {
+    remote = getConnInfo(c).remote.address ?? "unknown";
+  } catch {
+  }
+  const address = remote.replace(/^::ffff:/, "");
+  if (config.trustedProxy && isLoopback(address)) {
+    const forwarded = c.req.header("x-forwarded-for")?.split(",").at(-1)?.trim();
+    if (forwarded && isIP(forwarded)) return forwarded;
+  }
+  return address;
+}
+function originOf(header) {
+  if (!header || header === "null") return void 0;
+  try {
+    return new URL(header).origin;
+  } catch {
+    return void 0;
+  }
+}
+function cleanSettings(raw) {
+  const value = raw && typeof raw === "object" ? raw : {};
+  const text2 = (v, max) => typeof v === "string" && v.length > 0 && v.length <= max ? v : void 0;
+  const out = {};
+  const model = text2(value.model, 200);
+  const effort = text2(value.effort, 20);
+  const mode = permissionMode(value.permissionMode);
+  if (model) out.model = model;
+  if (effort) out.effort = effort;
+  if (typeof value.fast === "boolean") out.fast = value.fast;
+  if (typeof value.ultracode === "boolean") out.ultracode = value.ultracode;
+  if (mode) out.permissionMode = mode;
+  return out;
+}
+function sendBody(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return "Not a message";
+  const body = raw;
+  if (body.text !== void 0 && typeof body.text !== "string") return "The text must be a string";
+  if (body.attachments !== void 0 && (!Array.isArray(body.attachments) || body.attachments.length > 50 || !body.attachments.every((a) => typeof a === "string"))) return "Attachments must be upload ids";
+  if (body.settings !== void 0 && (typeof body.settings !== "object" || body.settings === null)) return "Settings must be an object";
+  if (body.cwd !== void 0 && typeof body.cwd !== "string") return "The folder must be a path";
+  if (body.scratch !== void 0 && typeof body.scratch !== "boolean") return "scratch must be true or false";
+  return body;
+}
+async function attachmentsFrom(ids) {
+  const found = await Promise.all((ids ?? []).map((id) => findUpload(id)));
+  return found.filter((a) => Boolean(a));
+}
+async function imagesOf(sessionId, uuid, keep) {
+  const file2 = await transcriptPath(sessionId);
+  if (!file2) return [];
+  const images = await rawImages(file2, uuid);
+  const wanted = Array.isArray(keep) ? new Set(keep.filter((i) => Number.isInteger(i))) : new Set(images.map((_, i) => i));
+  const kept = [];
+  for (const [i, image2] of images.entries()) {
+    if (!wanted.has(i) || image2.type !== "base64" || !image2.data) continue;
+    const ext = image2.mediaType.split("/")[1]?.replace("jpeg", "jpg") ?? "png";
+    kept.push(await saveUpload(new File([Buffer.from(image2.data, "base64")], `image-${i + 1}.${ext}`, { type: image2.mediaType })));
+  }
+  return kept;
+}
+async function claudeStarted(sessionId) {
+  const run4 = getRun(sessionId);
+  if (!run4) return;
+  let timer;
+  try {
+    await Promise.race([run4.ready, new Promise((resolve) => {
+      timer = setTimeout(resolve, 45e3);
+    })]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function makeEdit(id, before2, body, key) {
+  const info = await sessionInfo(id);
+  if (!info?.cwd || !await isDirectory(info.cwd)) return { error: "The session\u2019s folder is missing", status: 404 };
+  if (getRun(id)?.busy) return { error: "Stop Claude before editing an earlier prompt.", status: 409 };
+  const messages = await loadMessages(id);
+  const at = messages.findIndex((m) => m.uuid === before2);
+  if (at < 0) return { error: "That message is not in this session", status: 404 };
+  const previous = at === 0 ? null : messages[at - 1].uuid;
+  const last = !messages.slice(at + 1).some(isPrompt);
+  const file2 = await transcriptPath(id);
+  const entry = last && previous !== null && file2 && !getRun(id)?.hasBackgroundTasks ? (await rawEntry(file2, before2))?.parentUuid : void 0;
+  const settings = cleanSettings(body.settings);
+  if (!entry && settings.permissionMode === "bypassPermissions") settings.permissionMode = "default";
+  const attachments = await imagesOf(id, before2, body.keepImages);
+  const message = { text: body.text, attachments, settings, uuid: key };
+  let branch;
+  let started;
+  try {
+    if (entry) {
+      started = await replaceLastTurn(id, info.cwd, entry, before2, message);
+      await claudeStarted(started);
+      return { sessionId: started, inPlace: true };
+    }
+    if (previous !== null) branch = await fork(id, previous);
+    started = await sendMessage(branch ? { sessionId: branch } : { cwd: info.cwd }, message);
+    await claudeStarted(started);
+    return { sessionId: started, inPlace: false };
+  } catch (error) {
+    if (branch) await remove(branch).catch(() => void 0);
+    else if (started && !entry) await remove(started).catch(() => void 0);
+    await Promise.all(attachments.map((a) => removeUpload(a.id)));
+    throw error;
+  }
+}
+async function inDemo(dir) {
+  try {
+    const [real, root] = await Promise.all([realpath5(dir), realpath5(config.home)]);
+    return real === root || real.startsWith(`${root}${path14.sep}`);
+  } catch {
+    return false;
+  }
+}
+async function checkedFolder(cwd) {
+  if (!cwd || !path14.isAbsolute(cwd) || !await isDirectory(cwd)) return void 0;
+  if (config.demo && !await inDemo(cwd)) return void 0;
+  return cwd;
+}
+async function insideRepository(cwd) {
+  for (let dir = path14.resolve(cwd); ; dir = path14.dirname(dir)) {
+    if (await stat8(path14.join(dir, ".git")).then(() => true, () => false)) return true;
+    if (path14.dirname(dir) === dir) return false;
+  }
+}
+function validSubscription(value) {
+  const { endpoint, keys: keys2 } = value ?? {};
+  const bytes = (text2) => typeof text2 === "string" && /^[\w-]+=*$/.test(text2) ? Buffer.from(text2, "base64url").length : -1;
+  return typeof endpoint === "string" && endpoint.length <= 2048 && endpoint.startsWith("https://") && bytes(keys2?.p256dh) === 65 && bytes(keys2?.auth) === 16;
+}
+var app, secure, cookieHeader, unmarked, tooLarge, limits2, PERMISSION_MODES, permissionMode, sendMode, uuidOf, edits, editing, isPrompt, folderOf, gitAllowed, pageUrl, TYPES, POLICY;
+var init_app = __esm({
+  "src/server/app.ts"() {
+    "use strict";
+    init_package();
+    init_tasks();
+    init_actions();
+    init_archive();
+    init_auth();
+    init_config();
+    init_feed();
+    init_files();
+    init_folders();
+    init_models();
+    init_project_files();
+    init_push();
+    init_runner();
+    init_shell();
+    init_usage();
+    init_workspace();
+    init_security();
+    init_sessions();
+    init_transcripts();
+    init_trust();
+    app = new Hono();
+    secure = (c) => c.req.header("x-forwarded-proto") === "https" || c.req.url.startsWith("https:");
+    cookieHeader = (c, name, value, maxAge) => `${name}=${value}; Path=/; Max-Age=${maxAge}; HttpOnly; SameSite=Strict${secure(c) ? "; Secure" : ""}`;
+    app.use("*", async (c, next) => {
+      if (!hostAllowed(c.req.header("host"))) {
+        return c.text("This host name is not allowed. Add it to PELICAN_ALLOWED_HOSTS.", 403);
+      }
+      await next();
+    });
+    unmarked = (c) => c.req.method === "GET" && (/^\/api\/uploads\/[^/]+$/.test(c.req.path) || /^\/api\/sessions\/[^/]+\/export$/.test(c.req.path));
+    app.use("/api/*", async (c, next) => {
+      const origin = c.req.header("origin");
+      const parsed = originOf(origin);
+      const allowedOrigin = Boolean(parsed && config.allowedOrigins.includes(parsed));
+      const site = c.req.header("sec-fetch-site");
+      if (site && site !== "same-origin" && site !== "none" && !allowedOrigin) {
+        return c.json({ error: "Request from another site" }, 403);
+      }
+      if (!unmarked(c) && c.req.header("x-pelican") !== "1") {
+        return c.json({ error: "Requests must come from Pelican (send the header X-Pelican: 1)" }, 403);
+      }
+      if (c.req.method !== "GET" && c.req.method !== "HEAD" && !originAllowed(origin, c.req.header("host"), c.req.header("x-forwarded-host"))) {
+        return c.json({ error: "Request from another site" }, 403);
+      }
+      if (!c.req.path.startsWith("/api/auth") && !signedIn(c.req.header("cookie"), c.req.header("authorization"))) {
+        return c.json({ error: "Sign in to continue", signIn: true }, 401);
+      }
+      if (config.demo && c.req.method !== "GET" && c.req.method !== "HEAD") {
+        return c.json({ error: "This is the demo: nothing runs and nothing changes. Start Pelican without --demo to talk to Claude." }, 403);
+      }
+      await next();
+    });
+    tooLarge = (c) => c.json({ error: "Request too large" }, 413);
+    limits2 = {
+      auth: bodyLimit({ maxSize: 4 * 1024, onError: tooLarge }),
+      upload: bodyLimit({ maxSize: MAX_UPLOAD_BYTES + 64 * 1024, onError: tooLarge }),
+      json: bodyLimit({ maxSize: 1024 * 1024, onError: tooLarge })
+    };
+    app.use("/api/*", (c, next) => (c.req.path.startsWith("/api/auth") ? limits2.auth : c.req.path === "/api/uploads" ? limits2.upload : limits2.json)(c, next));
+    app.onError((error, c) => {
+      console.warn("[pelican]", c.req.method, c.req.path, error.message);
+      return c.json({ error: error.message }, 500);
+    });
+    app.get("/api/auth", (c) => c.json({
+      required: authMode() !== "none",
+      mode: authMode(),
+      signedIn: signedIn(c.req.header("cookie"), c.req.header("authorization"))
+    }));
+    app.post("/api/auth/login", async (c) => {
+      const succeeded = beginAttempt(clientAddress(c));
+      if (!succeeded) return c.json({ error: "Too many attempts. Try again in a few minutes." }, 429);
+      const body = await c.req.json().catch(() => ({}));
+      const mode = authMode();
+      const ok = mode === "password" ? typeof body.password === "string" && await checkPassword(body.password) : mode === "token" ? typeof body.token === "string" && checkToken(body.token.trim()) : false;
+      if (!ok) return c.json({ error: mode === "token" ? "That is not the access token" : "Wrong password", mode }, 401);
+      succeeded();
+      const cookie = newSessionCookie();
+      c.header("Set-Cookie", cookieHeader(c, cookie.name, cookie.value, cookie.maxAge));
+      return c.json({ ok: true });
+    });
+    app.post("/api/auth/logout", (c) => {
+      c.header("Set-Cookie", cookieHeader(c, cookieName(), "", 0));
+      return c.json({ ok: true });
+    });
+    app.post("/api/access/code", (c) => {
+      if (authMode() === "none") return c.json({ code: null });
+      return c.json({ code: issueCode() });
+    });
+    app.get("/api/info", (c) => {
+      const info = { machine: config.machine, home: config.home, version: package_default.version, auth: authMode() !== "none", demo: config.demo };
+      const key = pushKey();
+      if (key) info.pushKey = key;
+      return c.json(info);
+    });
+    app.get("/api/sessions", async (c) => c.json({ sessions: await listSummaries(runStatus) }));
+    app.get("/api/sessions/:id", async (c) => {
+      const id = c.req.param("id");
+      const session = await sessionSummary(id, runStatus);
+      const run4 = runState(id);
+      if (!session && !run4) return c.json({ error: "No such session" }, 404);
+      const tasks = currentTasks(await loadMessages(id));
+      return c.json({ session: session ?? null, run: run4 ?? null, tasks, settings: await recordedSettings(id) });
+    });
+    app.get("/api/sessions/:id/messages", async (c) => {
+      const before2 = c.req.query("before");
+      const limit = Math.min(Number(c.req.query("limit") ?? 120) || 120, 500);
+      return c.json(await loadPage(c.req.param("id"), before2 === void 0 ? void 0 : Number(before2), limit));
+    });
+    PERMISSION_MODES = ["default", "acceptEdits", "plan", "auto", "bypassPermissions"];
+    permissionMode = (value) => PERMISSION_MODES.includes(value) ? value : void 0;
+    sendMode = (value) => value === "steer" || value === "queue" ? value : void 0;
+    uuidOf = (value) => typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value) ? value : void 0;
+    app.post("/api/sessions", async (c) => {
+      const body = sendBody(await c.req.json().catch(() => void 0));
+      if (typeof body === "string") return c.json({ error: body }, 400);
+      const cwd = body.scratch ? await createScratchFolder() : await checkedFolder(body.cwd);
+      if (!cwd) return c.json({ error: "No such folder" }, 400);
+      const uuid = uuidOf(body.uuid);
+      const sessionId = await sendMessage({ cwd }, {
+        text: typeof body.text === "string" ? body.text : "",
+        attachments: await attachmentsFrom(body.attachments),
+        settings: cleanSettings(body.settings),
+        ...uuid ? { uuid } : {}
+      });
+      return c.json({ sessionId });
+    });
+    app.post("/api/sessions/:id/messages", async (c) => {
+      const body = sendBody(await c.req.json().catch(() => void 0));
+      if (typeof body === "string") return c.json({ error: body }, 400);
+      const uuid = uuidOf(body.uuid);
+      const mode = sendMode(body.mode);
+      const sessionId = await sendMessage({ sessionId: c.req.param("id") }, {
+        text: typeof body.text === "string" ? body.text : "",
+        attachments: await attachmentsFrom(body.attachments),
+        settings: cleanSettings(body.settings),
+        ...uuid ? { uuid } : {},
+        ...mode ? { mode } : {}
+      });
+      return c.json({ sessionId });
+    });
+    edits = /* @__PURE__ */ new Map();
+    editing = /* @__PURE__ */ new Map();
+    isPrompt = (m) => m.role === "user" && !m.meta && m.blocks.some((b) => b.type === "text" || b.type === "image");
+    app.post("/api/sessions/:id/edit", async (c) => {
+      const id = c.req.param("id");
+      const body = await c.req.json().catch(() => ({}));
+      const key = uuidOf(body.uuid);
+      const before2 = uuidOf(body.before);
+      if (!key || !before2 || typeof body.text !== "string" || !body.text.trim()) return c.json({ error: "Nothing to send" }, 400);
+      for (const [k, v] of edits) if (Date.now() - v.at > 10 * 6e4) edits.delete(k);
+      const done = edits.get(key);
+      if (done) return c.json({ sessionId: done.sessionId, inPlace: done.inPlace });
+      let work = editing.get(key);
+      if (!work) {
+        const made = makeEdit(id, before2, { text: body.text, settings: body.settings, keepImages: body.keepImages }, key);
+        work = made;
+        editing.set(key, made);
+        void made.then((result3) => {
+          if (!("error" in result3)) edits.set(key, { at: Date.now(), ...result3 });
+        }, () => void 0).finally(() => editing.delete(key));
+      }
+      const result2 = await work;
+      if ("error" in result2) return c.json({ error: result2.error }, result2.status);
+      return c.json(result2);
+    });
+    app.post("/api/sessions/:id/interrupt", async (c) => {
+      await getRun(c.req.param("id"))?.interrupt();
+      return c.json({ ok: true });
+    });
+    app.post("/api/sessions/:id/permissions/:requestId", async (c) => {
+      const decision = await c.req.json().catch(() => void 0);
+      const raw = decision ?? {};
+      const valid = (raw.behavior === "allow" || raw.behavior === "deny") && (raw.message === void 0 || typeof raw.message === "string") && (raw.remember === void 0 || typeof raw.remember === "boolean") && (raw.updatedInput === void 0 || typeof raw.updatedInput === "object" && raw.updatedInput !== null && !Array.isArray(raw.updatedInput)) && (raw.permissionMode === void 0 || Boolean(permissionMode(raw.permissionMode)));
+      if (!decision || !valid) return c.json({ error: "Not a decision" }, 400);
+      const ok = getRun(c.req.param("id"))?.decide(c.req.param("requestId"), decision) ?? false;
+      return ok ? c.json({ ok }) : c.json({ error: "That request is no longer pending" }, 409);
+    });
+    app.post("/api/sessions/:id/settings", async (c) => {
+      const body = await c.req.json().catch(() => ({}));
+      if (!body.settings || typeof body.settings !== "object") return c.json({ error: "No settings" }, 400);
+      await getRun(c.req.param("id"))?.updateSettings(cleanSettings(body.settings));
+      return c.json({ ok: true });
+    });
+    app.post("/api/sessions/:id/mode", async (c) => {
+      const body = await c.req.json();
+      const mode = permissionMode(body.permissionMode);
+      if (!mode) return c.json({ error: "No such mode" }, 400);
+      await getRun(c.req.param("id"))?.setPermissionMode(mode);
+      return c.json({ ok: true });
+    });
+    app.patch("/api/sessions/:id", async (c) => {
+      const { title } = await c.req.json();
+      if (!title?.trim()) return c.json({ error: "Title is empty" }, 400);
+      await renameSessionTitle(c.req.param("id"), title.trim());
+      return c.json({ ok: true });
+    });
+    app.post("/api/sessions/:id/fork", async (c) => {
+      const id = c.req.param("id");
+      const body = await c.req.json().catch(() => ({}));
+      let upTo = body.upTo;
+      if (body.before) {
+        const previous = await messageBefore(id, body.before);
+        if (previous === void 0) return c.json({ error: "That message is not in this session" }, 404);
+        if (previous === null) return c.json({ sessionId: null });
+        upTo = previous;
+      }
+      return c.json({ sessionId: await fork(id, upTo, body.title) });
+    });
+    app.post("/api/sessions/:id/archive", async (c) => {
+      const id = uuidOf(c.req.param("id"));
+      const body = await c.req.json().catch(() => ({}));
+      if (!id || typeof body.archived !== "boolean") return c.json({ error: "Say archived: true or false" }, 400);
+      await setArchived(id, body.archived);
+      sessionsChanged();
+      return c.json({ ok: true });
+    });
+    app.delete("/api/sessions/:id", async (c) => {
+      const id = c.req.param("id");
+      if (getRun(id)?.busy) return c.json({ error: "Stop Claude in this session before deleting it." }, 409);
+      getRun(id)?.close();
+      await remove(id);
+      return c.json({ ok: true });
+    });
+    app.get("/api/sessions/:id/export", async (c) => {
+      const { title, markdown } = await exportMarkdown(c.req.param("id"));
+      const name = `${title.replace(/[^\p{L}\p{N} _-]+/gu, "").trim().slice(0, 60) || "session"}.md`;
+      return c.body(markdown, 200, {
+        "Content-Type": "text/markdown; charset=utf-8",
+        "Content-Disposition": `attachment; filename*=UTF-8''${encodeURIComponent(name)}`,
+        "X-Content-Type-Options": "nosniff"
+      });
+    });
+    app.get("/api/models", async (c) => c.json(await listModels()));
+    app.get("/api/commands", async (c) => {
+      const cwd = await folderOf(c);
+      if (!cwd) return c.json({ commands: [], agents: [] });
+      return c.json(await listCompletions(cwd));
+    });
+    app.get("/api/usage/plan", async (c) => c.json({ plan: await planUsage() }));
+    app.get("/api/usage", (c) => c.json({
+      limits: config.demo ? [
+        { type: "five_hour", status: "allowed", utilization: 0.42, resetsAt: Date.now() + 2.4 * 36e5, at: Date.now() },
+        { type: "seven_day", status: "allowed", utilization: 0.18, resetsAt: Date.now() + 3.5 * 864e5, at: Date.now() }
+      ] : usageLimits()
+    }));
+    folderOf = (c) => checkedFolder(c.req.query("cwd"));
+    gitAllowed = (cwd) => config.demo ? Promise.resolve(true) : claudeRanIn(cwd);
+    app.get("/api/git", async (c) => {
+      const cwd = await folderOf(c);
+      if (!cwd) return c.json({ error: "No such folder" }, 404);
+      if (!await gitAllowed(cwd)) return c.json(await insideRepository(cwd) ? { repo: false, untrusted: true } : { repo: false });
+      return c.json(await gitStatus(cwd));
+    });
+    app.get("/api/git/diff", async (c) => {
+      const cwd = await folderOf(c);
+      const file2 = c.req.query("path");
+      if (!cwd || !file2) return c.json({ error: "No such file" }, 404);
+      if (!await gitAllowed(cwd)) return c.json({ diff: "" });
+      return c.json({ diff: await gitDiff(cwd, file2) });
+    });
+    app.get("/api/tree", async (c) => {
+      const cwd = await folderOf(c);
+      if (!cwd) return c.json({ error: "No such folder" }, 404);
+      return c.json({ entries: await listTree(cwd, c.req.query("path") ?? "") });
+    });
+    app.get("/api/file", async (c) => {
+      const cwd = await folderOf(c);
+      const file2 = c.req.query("path");
+      if (!cwd || !file2) return c.json({ error: "No such file" }, 404);
+      return c.json(await readProjectFile(cwd, file2));
+    });
+    app.post("/api/sessions/:id/shell", async (c) => {
+      const id = c.req.param("id");
+      const { command } = await c.req.json().catch(() => ({ command: void 0 }));
+      if (!command?.trim()) return c.json({ error: "No command" }, 400);
+      const info = await sessionInfo(id);
+      if (!info?.cwd || !await isDirectory(info.cwd)) return c.json({ error: "The session\u2019s folder is missing" }, 404);
+      const result2 = await runCommand(info.cwd, command.trim());
+      await (await ensureRun(id)).appendShell(result2);
+      return c.json(result2);
+    });
+    app.post("/api/sessions/:id/rewind", async (c) => {
+      const { uuid, dryRun } = await c.req.json().catch(() => ({ uuid: void 0, dryRun: void 0 }));
+      if (!uuid) return c.json({ error: "Which prompt?" }, 400);
+      const run4 = await ensureRun(c.req.param("id"));
+      if (run4.busy) return c.json({ error: "Stop Claude before rewinding files." }, 409);
+      return c.json(await run4.rewind(uuid, dryRun !== false));
+    });
+    app.get("/api/sessions/:id/mcp", async (c) => {
+      const id = c.req.param("id");
+      const run4 = getRun(id);
+      if (run4) return c.json({ servers: await run4.mcpServers(), live: true });
+      const info = await sessionInfo(id);
+      if (!info?.cwd || !await isDirectory(info.cwd)) return c.json({ servers: [], live: false });
+      return c.json({ servers: await probeMcpServers(info.cwd), live: false });
+    });
+    app.post("/api/sessions/:id/mcp/:name", async (c) => {
+      const run4 = getRun(c.req.param("id"));
+      if (!run4) return c.json({ error: "Claude is not running in this session" }, 409);
+      const change = await c.req.json().catch(() => ({}));
+      await run4.setMcpServer(c.req.param("name"), change);
+      return c.json({ servers: await run4.mcpServers() });
+    });
+    app.post("/api/sessions/:id/tasks/:task/stop", async (c) => {
+      await getRun(c.req.param("id"))?.stopTask(c.req.param("task"));
+      return c.json({ ok: true });
+    });
+    app.get("/api/sessions/:id/sent", async (c) => {
+      const file2 = c.req.query("path") ?? "";
+      if (!file2 || !(await sentFiles(c.req.param("id"))).has(file2)) return c.json({ error: "Not a file Claude sent in this session" }, 404);
+      try {
+        return c.json(await readProjectFile(path14.dirname(file2), path14.basename(file2)));
+      } catch {
+        return c.json({ error: "The file is gone" }, 404);
+      }
+    });
+    app.get("/api/sessions/:id/agents/:agent", async (c) => {
+      return c.json({ messages: await loadSubagent(c.req.param("id"), c.req.param("agent")) });
+    });
+    app.get("/api/files", async (c) => {
+      const cwd = await folderOf(c);
+      if (!cwd) return c.json({ files: [] });
+      return c.json({ files: await searchFiles(cwd, c.req.query("q") ?? "") });
+    });
+    app.get("/api/projects", async (c) => {
+      const seen = /* @__PURE__ */ new Map();
+      for (const s of await listSummaries(runStatus)) {
+        if (!s.cwd || s.scratch || s.temp) continue;
+        const entry = seen.get(s.cwd);
+        if (entry) entry.sessions += 1;
+        else seen.set(s.cwd, { path: s.cwd, name: s.project, lastActivity: s.lastActivity, sessions: 1 });
+      }
+      const existing = (await Promise.all([...seen.values()].map(async (p) => await isDirectory(p.path) ? p : void 0))).filter((p) => Boolean(p));
+      const counts = /* @__PURE__ */ new Map();
+      for (const p of existing) counts.set(p.name, (counts.get(p.name) ?? 0) + 1);
+      for (const p of existing) {
+        if ((counts.get(p.name) ?? 0) > 1) p.name = `${path14.basename(path14.dirname(p.path))}/${p.name}`;
+      }
+      return c.json({ projects: existing });
+    });
+    app.get("/api/dirs", async (c) => {
+      const asked = c.req.query("path");
+      if (config.demo && asked && !await inDemo(asked)) return c.json({ error: "Not part of the demo" }, 404);
+      try {
+        return c.json(await listDirs(asked, c.req.query("hidden") === "1"));
+      } catch (error) {
+        return c.json({ error: error.message }, 400);
+      }
+    });
+    app.post("/api/uploads", async (c) => {
+      const body = await c.req.parseBody();
+      const file2 = body.file;
+      if (!(file2 instanceof File)) return c.json({ error: "No file" }, 400);
+      return c.json({ attachment: await saveUpload(file2) });
+    });
+    app.get("/api/uploads/:id", async (c) => {
+      const found = await readUpload(c.req.param("id"));
+      if (!found) return c.notFound();
+      const image2 = found.attachment.mime.startsWith("image/") && found.attachment.mime !== "image/svg+xml";
+      return c.body(new Uint8Array(found.data), 200, {
+        "Content-Type": found.attachment.mime,
+        "Cache-Control": "private, max-age=86400",
+        "X-Content-Type-Options": "nosniff",
+        "Content-Security-Policy": "sandbox; default-src 'none'; img-src 'self' data:; frame-ancestors 'self'",
+        "X-Frame-Options": "SAMEORIGIN",
+        ...image2 ? {} : { "Content-Disposition": `attachment; filename*=UTF-8''${encodeURIComponent(found.attachment.name)}` }
+      });
+    });
+    app.get("/api/push/key", (c) => c.json({ key: pushKey() ?? null }));
+    pageUrl = (value) => typeof value === "string" && value.length <= 2048 && /^https?:\/\//.test(value);
+    app.post("/api/push/subscribe", async (c) => {
+      const body = await c.req.json().catch(() => ({}));
+      if (!validSubscription(body.subscription)) return c.json({ error: "Not a push subscription" }, 400);
+      const { endpoint, keys: keys2 } = body.subscription;
+      await addSubscription({ endpoint, keys: { p256dh: keys2.p256dh, auth: keys2.auth }, ...pageUrl(body.openUrl) ? { openUrl: body.openUrl } : {} });
+      return c.json({ ok: true });
+    });
+    app.post("/api/push/unsubscribe", async (c) => {
+      const { endpoint } = await c.req.json().catch(() => ({ endpoint: void 0 }));
+      if (typeof endpoint !== "string") return c.json({ error: "No endpoint" }, 400);
+      await removeSubscription(endpoint);
+      return c.json({ ok: true });
+    });
+    app.all("/api/*", (c) => c.json({ error: "Not found" }, 404));
+    TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "text/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".ico": "image/x-icon",
+      ".webmanifest": "application/manifest+json",
+      ".json": "application/json",
+      ".woff2": "font/woff2",
+      ".txt": "text/plain; charset=utf-8"
+    };
+    POLICY = {
+      "Content-Security-Policy": [
+        `frame-ancestors 'self'${config.frameAncestors.map((o) => ` ${o}`).join("")}`,
+        "frame-src 'self' blob: data:",
+        "img-src 'self' data: blob:",
+        "media-src 'self' data: blob:",
+        "object-src 'none'",
+        "base-uri 'self'"
+      ].join("; "),
+      ...config.frameAncestors.length === 0 ? { "X-Frame-Options": "SAMEORIGIN" } : {}
+    };
+    app.get("/*", async (c) => {
+      if (!config.webDir) return c.text("The web app is not built. Run `npm run build`, or use `npm run dev`.", 503);
+      const root = config.webDir;
+      let pathname;
+      try {
+        pathname = decodeURIComponent(new URL(c.req.url).pathname);
+      } catch {
+        return c.text("Bad path", 400);
+      }
+      const token2 = c.req.query("token");
+      const code = c.req.query("code");
+      if (token2 !== void 0 || code !== void 0) {
+        const url = new URL(c.req.url);
+        url.searchParams.delete("token");
+        url.searchParams.delete("code");
+        const location = `./${url.pathname.split("/").pop() ?? ""}${url.search}`;
+        const ok = token2 !== void 0 ? checkToken(token2) : redeemCode(code);
+        if (!ok) return c.body(null, 302, { Location: location, "Cache-Control": "no-store" });
+        const cookie = newSessionCookie();
+        return c.body(null, 302, { Location: location, "Set-Cookie": cookieHeader(c, cookie.name, cookie.value, cookie.maxAge), "Cache-Control": "no-store" });
+      }
+      const requested = path14.normalize(pathname).replace(/^(\.\.[/\\])+/, "");
+      let file2 = path14.join(root, requested);
+      if (!file2.startsWith(root) || requested === "/" || !path14.extname(file2)) file2 = path14.join(root, "index.html");
+      try {
+        const data = await readFile7(file2);
+        const ext = path14.extname(file2);
+        const hashed = file2.includes(`${path14.sep}assets${path14.sep}`);
+        return c.body(new Uint8Array(data), 200, {
+          "Content-Type": TYPES[ext] ?? "application/octet-stream",
+          "Cache-Control": hashed ? "public, max-age=31536000, immutable" : "no-cache",
+          "X-Content-Type-Options": "nosniff",
+          "Referrer-Policy": "same-origin",
+          ...POLICY
+        });
+      } catch {
+        return c.notFound();
+      }
+    });
+  }
+});
+
+// src/server/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+import { serve } from "@hono/node-server";
+import { WebSocketServer } from "ws";
+function clientEvent(text2) {
+  let value;
+  try {
+    value = JSON.parse(text2);
+  } catch {
+    return void 0;
+  }
+  if (!value || typeof value !== "object") return void 0;
+  const { type, sessionId } = value;
+  if (type !== "subscribe" && type !== "unsubscribe" || typeof sessionId !== "string" || !SESSION_ID.test(sessionId)) return void 0;
+  return { type, sessionId };
+}
+async function startServer() {
+  await loadAuth();
+  await initPush();
+  const url = await new Promise((resolve, reject) => {
+    const server = serve({ fetch: app.fetch, hostname: config.host, port: config.port }, (info) => {
+      const host = info.family === "IPv6" ? `[${info.address}]` : info.address;
+      resolve(`http://${host}:${info.port}/`);
+    });
+    server.on("error", reject);
+    const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
+    server.on("upgrade", (req, socket, head) => {
+      const pathname = new URL(req.url ?? "/", "http://x").pathname;
+      const forwarded = req.headers["x-forwarded-host"];
+      const ok = pathname.endsWith("/api/ws") && hostAllowed(req.headers.host) && originAllowed(req.headers.origin, req.headers.host, Array.isArray(forwarded) ? forwarded[0] : forwarded) && signedIn(req.headers.cookie, req.headers.authorization);
+      if (!ok) {
+        socket.destroy();
+        return;
+      }
+      wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+    });
+    wss.on("connection", (ws) => {
+      const send = (event) => {
+        if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(event));
+      };
+      const disconnect = connect(send);
+      const subscriptions2 = /* @__PURE__ */ new Map();
+      const ping = setInterval(() => ws.ping(), 25e3);
+      ws.on("error", () => ws.terminate());
+      ws.on("message", (data) => {
+        const event = clientEvent(String(data));
+        if (!event) return;
+        if (event.type === "subscribe" && !subscriptions2.has(event.sessionId)) {
+          if (subscriptions2.size >= MAX_SUBSCRIPTIONS) return;
+          subscriptions2.set(event.sessionId, subscribe(event.sessionId, send));
+          const state = runState(event.sessionId);
+          if (state) send({ type: "run", state });
+        } else if (event.type === "unsubscribe") {
+          subscriptions2.get(event.sessionId)?.();
+          subscriptions2.delete(event.sessionId);
+        }
+      });
+      ws.on("close", () => {
+        clearInterval(ping);
+        disconnect();
+        for (const unsubscribe of subscriptions2.values()) unsubscribe();
+      });
+    });
+    const shutdown = () => {
+      closeAll();
+      server.close();
+      setTimeout(() => process.exit(0), 500).unref();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+  return { url };
+}
+var SESSION_ID, MAX_SUBSCRIPTIONS;
+var init_server = __esm({
+  "src/server/server.ts"() {
+    "use strict";
+    init_app();
+    init_auth();
+    init_config();
+    init_feed();
+    init_push();
+    init_runner();
+    init_security();
+    SESSION_ID = /^[\w-]{1,100}$/;
+    MAX_SUBSCRIPTIONS = 64;
+  }
+});
+
+// src/shared/qr.ts
+import qrcode from "qrcode-generator";
+function qrModules(text2) {
+  const qr = qrcode(0, "M");
+  qr.addData(text2);
+  qr.make();
+  const size = qr.getModuleCount();
+  const rows = [];
+  for (let y = -QUIET; y < size + QUIET; y += 1) {
+    const row = [];
+    for (let x = -QUIET; x < size + QUIET; x += 1) row.push(x >= 0 && y >= 0 && x < size && y < size && qr.isDark(y, x));
+    rows.push(row);
+  }
+  return rows;
+}
+var QUIET;
+var init_qr = __esm({
+  "src/shared/qr.ts"() {
+    "use strict";
+    QUIET = 2;
+  }
+});
+
+// src/server/qr.ts
+var qr_exports = {};
+__export(qr_exports, {
+  qrTerminal: () => qrTerminal
+});
+function qrTerminal(text2) {
+  const rows = qrModules(text2);
+  const lines = [];
+  for (let y = 0; y < rows.length; y += 2) {
+    let line = "";
+    for (let x = 0; x < rows[y].length; x += 1) {
+      const top = rows[y][x] ? 16 : 231;
+      const bottom = rows[y + 1]?.[x] ? 16 : 231;
+      line += `\x1B[38;5;${top};48;5;${bottom}m\u2580`;
+    }
+    lines.push(`${line}\x1B[0m`);
+  }
+  return lines.join("\n");
+}
+var init_qr2 = __esm({
+  "src/server/qr.ts"() {
+    "use strict";
+    init_qr();
+  }
+});
+
+// src/server/cli.ts
+init_package();
+init_config();
+init_security();
+import { spawn as spawn2 } from "node:child_process";
+import { mkdir as mkdir7, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
+import os6 from "node:os";
+import path15 from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+var DOCS = "https://ki-seki.github.io/pelican/docs.html";
+var HELP = `Pelican ${package_default.version}: your Claude Code sessions, from any browser.
+
+Usage
+  pelican [options]           Start the server
+  pelican token               Print the link that signs a browser in
+  pelican token --reset       Make a new access token; old links stop working
+  pelican password            Sign in with a password instead of the token
+  pelican password --off      Remove the password; the token signs in again
+
+Options
+  -p, --port <port>           Port to listen on (default 7860, or PELICAN_PORT)
+  -H, --host <address>        Address to listen on (default 127.0.0.1, or PELICAN_HOST)
+      --name <name>           Name shown for this machine (default: its host name)
+      --no-auth               Ask no one to sign in. Only when something in front
+                              of Pelican already authenticates.
+      --demo                  Show made-up sessions; nothing runs
+      --open                  Open the browser
+  -v, --version               Print the version
+  -h, --help                  Show this help
+
+Pelican runs Claude Code, and so commands, as you. It listens on 127.0.0.1, and
+every browser signs in, with the access token in the link Pelican prints or
+with your password. To use it from your phone, see ${DOCS}#phone
+`;
+function askHidden(prompt) {
+  return new Promise((resolve, reject) => {
+    const input = process.stdin;
+    if (!input.isTTY) {
+      reject(new Error("Run `pelican password` in a terminal, or pipe the password in with --stdin."));
+      return;
+    }
+    process.stdout.write(prompt);
+    input.setRawMode(true);
+    input.resume();
+    input.setEncoding("utf8");
+    let value = "";
+    const onData = (chunk) => {
+      for (const char of chunk) {
+        if (char === "\r" || char === "\n") {
+          input.setRawMode(false);
+          input.pause();
+          input.off("data", onData);
+          process.stdout.write("\n");
+          resolve(value);
+          return;
+        }
+        if (char === "") {
+          process.stdout.write("\n");
+          process.exit(130);
+        }
+        if (char === "\x7F" || char === "\b") value = value.slice(0, -1);
+        else value += char;
+      }
+    };
+    input.on("data", onData);
+  });
+}
+async function readStdin() {
+  let data = "";
+  for await (const chunk of process.stdin) data += chunk;
+  return data.replace(/\r?\n$/, "");
+}
+async function passwordCommand(off, stdin) {
+  const { clearPassword: clearPassword2, loadAuth: loadAuth2, setPassword: setPassword2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await loadAuth2();
+  if (off) {
+    await clearPassword2();
+    console.log("Password removed: browsers sign in with the access token again (`pelican token`). Restart Pelican to apply.");
+    return;
+  }
+  const password2 = stdin ? await readStdin() : await askHidden("New password: ");
+  if (password2.length < 8) throw new Error("Use at least 8 characters.");
+  if (!stdin && await askHidden("Repeat it: ") !== password2) throw new Error("The two did not match.");
+  await setPassword2(password2);
+  console.log(`Password saved in ${config.configDir}. Restart Pelican to apply; signed-in browsers are signed out.`);
+}
+var tokenLink = (base, token2) => `${base}?token=${token2}`;
+function localAddress() {
+  const h = config.host;
+  const host = ["0.0.0.0", "::", "127.0.0.1", "localhost", "::1"].includes(h) ? "localhost" : h.includes(":") ? `[${h}]` : h;
+  return `http://${host}:${config.port}/`;
+}
+async function tokenCommand(reset) {
+  const { accessToken: accessToken2, authMode: authMode2, loadAuth: loadAuth2, resetToken: resetToken2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await loadAuth2();
+  if (authMode2() === "none") {
+    console.log("Sign-in is off (--no-auth or PELICAN_AUTH=none), so there is no access token.");
+    return;
+  }
+  if (reset) {
+    await resetToken2();
+    console.log("New access token made. Restart Pelican to apply; browsers signed in with the old one are signed out.");
+  }
+  if (authMode2() === "password") {
+    console.log("A password is set, so browsers sign in with it. `pelican password --off` goes back to the token.");
+    return;
+  }
+  const token2 = accessToken2();
+  if (token2) console.log(tokenLink(localAddress(), token2));
+}
+async function openPelican(address, token2) {
+  if (!token2 || process.platform !== "darwin") {
+    openBrowser(address);
+    return;
+  }
+  const file2 = path15.join(config.configDir, "open.html");
+  try {
+    await mkdir7(config.configDir, { recursive: true, mode: 448 });
+    await rm4(file2, { force: true });
+    const link = tokenLink(address, token2);
+    await writeFile6(file2, `<!doctype html><meta http-equiv="refresh" content="0;url=${link}"><a href="${link}">Open Pelican</a>
+`, { mode: 384 });
+    openBrowser(pathToFileURL(file2).href);
+    setTimeout(() => void rm4(file2, { force: true }), 3e4).unref();
+  } catch {
+    openBrowser(address);
+  }
+}
+function openBrowser(url) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn2(opener, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).on("error", () => {
+    }).unref();
+  } catch {
+  }
+}
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      port: { type: "string", short: "p" },
+      host: { type: "string", short: "H" },
+      name: { type: "string" },
+      "no-auth": { type: "boolean" },
+      demo: { type: "boolean" },
+      open: { type: "boolean" },
+      off: { type: "boolean" },
+      reset: { type: "boolean" },
+      stdin: { type: "boolean" },
+      version: { type: "boolean", short: "v" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) return void process.stdout.write(HELP);
+  if (values.version) return void console.log(package_default.version);
+  if (values.port) config.port = Number(values.port);
+  if (values.host) config.host = values.host;
+  if (values.name) config.machine = values.name;
+  if (values["no-auth"]) config.auth = "none";
+  if (!Number.isInteger(config.port) || config.port <= 0 || config.port > 65535) throw new Error(`Not a port: ${values.port}`);
+  if (positionals[0] === "password") return passwordCommand(Boolean(values.off), Boolean(values.stdin));
+  if (positionals[0] === "token") return tokenCommand(Boolean(values.reset));
+  if (positionals.length > 0) throw new Error(`Unknown command: ${positionals.join(" ")}. See pelican --help.`);
+  const noAuth = config.auth === "none";
+  if (values.demo) {
+    config.demo = true;
+    const { prepareDemo: prepareDemo2 } = await Promise.resolve().then(() => (init_demo(), demo_exports));
+    await prepareDemo2();
+    if (!values.name) config.machine = "demo";
+  }
+  const local = listensLocally(config.host);
+  if (config.demo) {
+    if (!local && !noAuth) throw new Error("The demo signs no one in, so it listens on 127.0.0.1 only. Pass --no-auth to show it on your network.");
+    config.auth = "none";
+  }
+  const { accessToken: accessToken2, authMode: authMode2, loadAuth: loadAuth2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await loadAuth2();
+  const { configWarnings: configWarnings2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  for (const warning of configWarnings2) console.warn(`pelican: ${warning}`);
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  const { url } = await startServer2();
+  const shown = url.replace("://127.0.0.1:", "://localhost:");
+  const token2 = accessToken2();
+  const mode = authMode2();
+  const interactive = Boolean(process.stdout.isTTY);
+  const open4 = token2 && interactive ? tokenLink(shown, token2) : shown;
+  const protection = config.demo ? "demo: made-up sessions, nothing runs" : mode === "password" ? "browsers sign in with your password" : mode === "token" ? interactive ? "the link signs a browser in (`pelican token` prints it again)" : "browsers sign in with the link `pelican token` prints" : local ? "no sign-in (--no-auth)" : "no sign-in (--no-auth): anyone who reaches this address can run commands as you";
+  console.log(`
+  Pelican ${package_default.version} \xB7 ${config.machine}
+  ${open4}
+  ${protection}
+`);
+  if (!config.webDir) console.log("  The web app is not built: run `npm run build` (or use `npm run dev`).\n");
+  if (!local) {
+    const { qrTerminal: qrTerminal2 } = await Promise.resolve().then(() => (init_qr2(), qr_exports));
+    const lan = Object.values(os6.networkInterfaces()).flat().find((a) => a && a.family === "IPv4" && !a.internal);
+    const base = config.host === "0.0.0.0" || config.host === "::" ? lan ? `http://${lan.address}:${config.port}/` : void 0 : url;
+    const phone = base && token2 && interactive ? tokenLink(base, token2) : base;
+    if (phone) console.log(`  On your phone: ${phone}
+${interactive ? `
+${qrTerminal2(phone).replace(/^/gm, "  ")}
+` : ""}`);
+  } else if (!config.demo) {
+    console.log(`  From your phone: ${DOCS}#phone
+`);
+  }
+  if (values.open) await openPelican(shown, token2);
+}
+main().catch((error) => {
+  console.error(`pelican: ${error.message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map