openpond 0.1.1 → 0.2.0

package/dist/chunks/chunk-OCBRPU2K.js

@@ -0,0 +1,629 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  ensureCapabilityToken,
+  ownHomeRuntime,
+  publishRuntimeEndpoint,
+  runAppServerJsonl
+} from "./chunk-X6F4LBTQ.js";
+import {
+  getBundledRuntimeVersion,
+  openUrlWithSystemBrowser
+} from "./chunk-6SMNG6YA.js";
+import {
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  VERSION,
+  parseListen
+} from "./chunk-KCRCIQPD.js";
+import {
+  ClientChoicesSchema,
+  MigrationResolutionsSchema,
+  configEditorSchema,
+  configRecoveryRevisions,
+  fileRevision,
+  initializeHome,
+  patchConfig,
+  readClientChoices,
+  readMigrationJournal,
+  readOptionalFile,
+  replaceConfigText,
+  resolveEffectiveConfig,
+  restartMigration,
+  restoreConfigRevision,
+  setProjectTrust,
+  updateClientChoices,
+  validateConfigText
+} from "./chunk-4KA25HUP.js";
+import {
+  PersistenceError,
+  persistenceIssue,
+  resolveOpenPondHome,
+  storagePaths
+} from "./chunk-ZNQEROWP.js";
+import {
+  external_exports
+} from "./chunk-FQS2QL5F.js";
+
+// ../server/src/api/startup-recovery.ts
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+
+// ../server/src/api/configuration-payloads.ts
+var operation = external_exports.discriminatedUnion("op", [
+  external_exports.strictObject({ op: external_exports.literal("set"), path: external_exports.array(external_exports.string().min(1)).min(1), value: external_exports.unknown() }),
+  external_exports.strictObject({ op: external_exports.literal("unset"), path: external_exports.array(external_exports.string().min(1)).min(1) })
+]);
+var requestSchema = external_exports.discriminatedUnion("action", [
+  external_exports.strictObject({ action: external_exports.literal("patch"), expectedRevision: external_exports.string(), operations: external_exports.array(operation).max(100) }),
+  external_exports.strictObject({ action: external_exports.literal("replace"), expectedRevision: external_exports.string(), text: external_exports.string().max(1048576) }),
+  external_exports.strictObject({ action: external_exports.literal("validate"), text: external_exports.string().max(1048576) }),
+  external_exports.strictObject({ action: external_exports.literal("restore"), expectedRevision: external_exports.string(), revision: external_exports.string() }),
+  external_exports.strictObject({ action: external_exports.literal("trust"), root: external_exports.string(), accountId: external_exports.string(), trusted: external_exports.boolean() }),
+  external_exports.strictObject({ action: external_exports.literal("client-state"), owner: external_exports.string(), patch: ClientChoicesSchema, importOnly: external_exports.boolean().optional() })
+]);
+function createConfigurationPayloads(home) {
+  let lastValid = null;
+  async function status(projectRoot, accountId) {
+    const file = storagePaths(home).config;
+    let text = null, issue = null, effective = null;
+    try {
+      text = await readOptionalFile(file);
+      effective = await resolveEffectiveConfig(home, { projectRoot, accountId });
+      if (!projectRoot) lastValid = effective;
+    } catch (error) {
+      issue = persistenceIssue(error, file);
+    }
+    const retained = effective ?? (projectRoot ? null : lastValid);
+    return {
+      path: file,
+      text,
+      rawRevision: fileRevision(text),
+      issue,
+      effective: retained,
+      usingLastValid: !effective && Boolean(retained),
+      applies: "next_turn",
+      recoverableRevisions: await configRecoveryRevisions(home),
+      clientState: issue ? null : await readClientChoices(home)
+    };
+  }
+  async function mutate(payload) {
+    const input = requestSchema.parse(payload);
+    if (input.action === "validate") return { valid: true, document: validateConfigText(input.text, storagePaths(home).config) };
+    if (input.action === "patch") await patchConfig(home, input.expectedRevision, input.operations);
+    if (input.action === "replace") await replaceConfigText(home, input.expectedRevision, input.text);
+    if (input.action === "restore") await restoreConfigRevision(home, input.revision, input.expectedRevision);
+    if (input.action === "trust") await setProjectTrust(home, input.root, input.accountId, input.trusted);
+    if (input.action === "client-state") return updateClientChoices(home, input.owner, input.patch, input.importOnly);
+    return status();
+  }
+  return { status, mutate, schema: configEditorSchema };
+}
+
+// ../server/src/api/http.ts
+import { Buffer } from "node:buffer";
+var CORS_HEADERS = {
+  "Access-Control-Allow-Headers": "authorization, content-type",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS"
+};
+var DEFAULT_JSON_BODY_LIMIT_BYTES = 25 * 1024 * 1024;
+var HttpBodyError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "HttpBodyError";
+  }
+  status;
+  code;
+};
+function applyCorsHeaders(request, response, options = {}) {
+  for (const [name, value] of Object.entries(CORS_HEADERS)) {
+    response.setHeader(name, value);
+  }
+  const origin = headerValue(request.headers.origin);
+  if (!origin) return { allowed: true, origin: null };
+  response.setHeader("Vary", appendVaryOrigin(response.getHeader("Vary")));
+  if (!isAllowedCorsOrigin(origin, options)) return { allowed: false, origin };
+  response.setHeader("Access-Control-Allow-Origin", origin);
+  return { allowed: true, origin };
+}
+function isAllowedCorsOrigin(origin, options = {}) {
+  if (origin === "null") return true;
+  const normalized = normalizeOrigin(origin);
+  if (!normalized) return false;
+  if (isLoopbackOrigin(normalized)) return true;
+  const allowedOrigins = new Set(
+    (options.allowedOrigins ?? []).map((value) => value ? normalizeOrigin(value) : null).filter((value) => Boolean(value))
+  );
+  return allowedOrigins.has(normalized);
+}
+function sendJson(response, status, payload) {
+  response.writeHead(status, {
+    "Content-Type": "application/json",
+    ...CORS_HEADERS
+  });
+  response.end(JSON.stringify(payload));
+}
+function sendText(response, status, payload) {
+  response.writeHead(status, {
+    "Content-Type": "text/plain; charset=utf-8",
+    ...CORS_HEADERS
+  });
+  response.end(payload);
+}
+function sendBinary(response, status, payload, contentType) {
+  response.writeHead(status, {
+    "Content-Type": contentType,
+    "Content-Length": String(payload.byteLength),
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff",
+    ...CORS_HEADERS
+  });
+  response.end(payload);
+}
+async function readJson(request, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_JSON_BODY_LIMIT_BYTES;
+  const contentType = headerValue(request.headers["content-type"]);
+  const chunks = [];
+  let byteLength = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.from(chunk);
+    byteLength += buffer.byteLength;
+    if (byteLength > maxBytes) {
+      throw new HttpBodyError(
+        413,
+        "request_body_too_large",
+        `JSON request body exceeds ${maxBytes} bytes.`
+      );
+    }
+    chunks.push(buffer);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  if (!isJsonContentType(contentType)) {
+    throw new HttpBodyError(
+      415,
+      "unsupported_media_type",
+      "JSON request body requires Content-Type: application/json."
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new HttpBodyError(400, "invalid_json", "Request body is not valid JSON.");
+  }
+}
+function hasAuth(request, _url, token) {
+  const header = request.headers.authorization;
+  const bearer = typeof header === "string" && header.startsWith("Bearer ") ? header.slice(7) : null;
+  return bearer === token;
+}
+function headerValue(value) {
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value ?? null;
+}
+function isJsonContentType(contentType) {
+  if (!contentType) return false;
+  const mediaType = contentType.split(";")[0]?.trim().toLowerCase();
+  return mediaType === "application/json" || Boolean(mediaType?.endsWith("+json"));
+}
+function normalizeOrigin(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
+function isLoopbackOrigin(origin) {
+  const url = new URL(origin);
+  return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]";
+}
+function appendVaryOrigin(value) {
+  const existing = Array.isArray(value) ? value.join(", ") : value ? String(value) : "";
+  const parts = existing.split(",").map((part) => part.trim()).filter(Boolean);
+  if (!parts.some((part) => part.toLowerCase() === "origin")) parts.push("Origin");
+  return parts.join(", ");
+}
+
+// ../server/src/api/startup-recovery-page.ts
+function startupRecoveryPage(nonce) {
+  return `<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>OpenPond recovery</title>
+<style nonce="${nonce}">body{font:16px system-ui;background:#171819;color:#eee;max-width:850px;margin:6vh auto;padding:24px}textarea{box-sizing:border-box;width:100%;min-height:280px;background:#222;color:#eee;padding:14px;border:1px solid #777;border-radius:8px;font:14px monospace}button,input,select{font:inherit;margin:6px;padding:8px}pre{white-space:pre-wrap}code{overflow-wrap:anywhere}button{cursor:pointer}p{line-height:1.5}</style>
+<h1>OpenPond needs a storage repair</h1><p id="issue" role="alert">Loading recovery details\u2026</p><p><code id="file"></code></p>
+<p id="action"></p><p>Migration backups and the source installation remain available. Execution services are stopped while recovery is open.</p>
+<details id="editor"><summary>Edit configuration</summary><textarea id="text" aria-label="Configuration TOML" spellcheck="false"></textarea><button id="save">Validate and save</button><button id="reload">Reload file</button><select id="revisions" aria-label="Restore a verified configuration revision"><option value="">Restore a verified revision\u2026</option></select></details>
+<details><summary>Migration sources and diagnostics</summary><pre id="migration"></pre><label>Previous app home <input id="appHome"></label><label>Previous account config <input id="configSource"></label><label>Configuration conflict choices (JSON from the preview) <textarea id="resolutions" aria-label="Migration conflict choices" spellcheck="false" placeholder='[{"path":["chat","steer_active_responses"],"choice":"existing"}]'></textarea></label><button id="preview">Preview migration</button><button id="migrate">Use these sources</button><button id="restart">Restart failed preparation</button><button id="diagnostics">Export diagnostics</button></details>
+<button id="retry">Retry startup</button><p id="message" role="status"></p>
+<script nonce="${nonce}">
+let token='',state=null,editing=false,revision=null;
+const el=id=>document.getElementById(id);
+async function request(route,body){const r=await fetch(route,{method:body?'POST':'GET',headers:{'Content-Type':'application/json',Authorization:'Bearer '+token},body:body?JSON.stringify(body):undefined});const v=await r.json();if(!r.ok)throw Error(v.error||'Recovery request failed');return v;}
+function message(error){el('message').textContent=error instanceof Error?error.message:String(error);}
+async function load(){state=await request('/v1/recovery');el('issue').textContent=state.issue.message;el('action').textContent=state.issue.action;el('file').textContent=state.issue.path;el('migration').textContent=JSON.stringify(state.migration,null,2);if(!editing){el('text').value=state.config.text||'schema_version = 1\\n';revision=state.config.rawRevision;}el('revisions').replaceChildren(new Option('Restore a verified revision\u2026',''),...state.config.recoverableRevisions.map(r=>new Option(r.createdAt,r.revision)));el('editor').hidden=!state.configEditable;}
+el('text').oninput=()=>{editing=true};
+el('reload').onclick=()=>{editing=false;load().catch(message)};
+el('save').onclick=async()=>{try{await request('/v1/configuration',{action:'replace',text:el('text').value,expectedRevision:revision});editing=false;await load();message('Configuration saved. Retry startup when ready.')}catch(e){message(e)}};
+el('revisions').onchange=async e=>{if(!e.target.value)return;try{await request('/v1/configuration',{action:'restore',revision:e.target.value,expectedRevision:state.config.rawRevision});editing=false;await load();message('Verified revision restored.')}catch(e){message(e)}};
+for(const [id,action] of [['preview','preview'],['migrate','migrate'],['restart','restart']])el(id).onclick=async()=>{try{const result=await request('/v1/recovery',{action,sourceAppHome:el('appHome').value||undefined,sourceConfig:el('configSource').value||undefined,resolutions:el('resolutions').value?JSON.parse(el('resolutions').value):undefined});el('migration').textContent=JSON.stringify(result,null,2);message(action==='preview'?'Review the source paths above.':'Migration operation completed; retry startup.')}catch(e){message(e)}};
+el('diagnostics').onclick=()=>{if(!state)return;const blob=new Blob([JSON.stringify({issue:state.issue,migration:state.migration,config:{path:state.config.path,rawRevision:state.config.rawRevision,issue:state.config.issue}},null,2)],{type:'application/json'});const a=document.createElement('a');a.href=URL.createObjectURL(blob);a.download='openpond-recovery-diagnostics.json';a.click();URL.revokeObjectURL(a.href)};
+el('retry').onclick=async()=>{try{await request('/v1/recovery',{action:'retry'});message('Starting OpenPond\u2026');const timer=setInterval(async()=>{try{const h=await(await fetch('/health')).json();if(!h.recovery){clearInterval(timer);const next=new URLSearchParams(location.hash.slice(1)).get('returnTo');if(next){const u=new URL(next);if(['localhost','127.0.0.1','[::1]'].includes(u.hostname)){location.replace(u.toString());return}}location.reload();}}catch{}},500)}catch(e){message(e)}};
+(async()=>{const params=new URLSearchParams(location.hash.slice(1));token=params.get('openpondToken')||'';if(!token&&window.openpond?.getConnection)token=(await window.openpond.getConnection()).token;if(!token){message('Open the authenticated recovery URL from the launcher.');return}await load()})().catch(message);
+</script></html>`;
+}
+
+// ../server/src/api/startup-recovery.ts
+var recoveryRequest = external_exports.strictObject({ action: external_exports.enum(["preview", "migrate", "restart", "retry"]), sourceAppHome: external_exports.string().optional(), sourceConfig: external_exports.string().optional(), resolutions: MigrationResolutionsSchema.optional() });
+function isRecoverableStartupError(error) {
+  return error instanceof PersistenceError && /^(PRIVATE_STORAGE_|UNSAFE_STORAGE_|INVALID_CONFIG|CONFIG_|MIGRATION_|SOURCE_CHANGED_|CREDENTIAL_|UNSUPPORTED_STORAGE_|INVALID_MIGRATION_|INVALID_ACCOUNT_|MISSING_INSTRUCTION_|INVALID_PROFILE_|DATABASE_RECOVERY_)/.test(error.issue.code);
+}
+async function startRecoveryServer(home, port, initialError) {
+  const readOnlyHome = /^(UNSUPPORTED_STORAGE_|INVALID_MIGRATION_|UNSAFE_STORAGE_|PRIVATE_STORAGE_)/.test(initialError.issue.code);
+  const runtimeHome = readOnlyHome ? await fs.mkdtemp(path.join(os.tmpdir(), "openpond-recovery-")) : home;
+  return ownHomeRuntime(runtimeHome, async () => {
+    const { token, tokenFile } = await ensureCapabilityToken(runtimeHome);
+    const configuration = createConfigurationPayloads(home);
+    let issue = initialError.issue;
+    let ready;
+    const repaired = new Promise((resolve) => {
+      ready = resolve;
+    });
+    const server = createServer((request, response) => {
+      void (async () => {
+        const url2 = new URL(request.url ?? "/", "http://127.0.0.1");
+        if (!applyCorsHeaders(request, response).allowed) {
+          sendJson(response, 403, { error: "Origin not allowed" });
+          return;
+        }
+        if (request.method === "OPTIONS") {
+          sendJson(response, 204, {});
+          return;
+        }
+        if (request.method === "GET" && url2.pathname === "/health") {
+          sendJson(response, 200, { ok: true, server: "openpond-app-server", version: VERSION, recovery: true });
+          return;
+        }
+        if (request.method === "GET" && url2.pathname === "/") {
+          const nonce = randomBytes(18).toString("base64");
+          response.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "Content-Security-Policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'` });
+          response.end(startupRecoveryPage(nonce));
+          return;
+        }
+        if (!hasAuth(request, url2, token)) {
+          sendJson(response, 401, { error: "Unauthorized" });
+          return;
+        }
+        const configEditable = !readOnlyHome;
+        if (request.method === "GET" && url2.pathname === "/v1/recovery") {
+          sendJson(response, 200, { issue, configEditable, config: readOnlyHome ? { path: storagePaths(home).config, text: null, rawRevision: "unavailable", issue, recoverableRevisions: [] } : await configuration.status(), migration: await readMigrationJournal(home).catch((error) => ({ issue: persistenceIssue(error, home) })) });
+          return;
+        }
+        if (request.method === "POST" && url2.pathname === "/v1/configuration" && configEditable) {
+          sendJson(response, 200, await configuration.mutate(await readJson(request)));
+          return;
+        }
+        if (request.method === "POST" && url2.pathname === "/v1/recovery") {
+          const input = recoveryRequest.parse(await readJson(request));
+          if (readOnlyHome && input.action !== "retry" && input.action !== "preview") throw initialError;
+          if (input.action === "restart") {
+            sendJson(response, 200, await restartMigration(home));
+            return;
+          }
+          if (input.action === "preview" || input.action === "migrate") {
+            sendJson(response, 200, await initializeHome(home, { sourceAppHome: input.sourceAppHome, sourceConfig: input.sourceConfig, resolutions: input.resolutions, dryRun: input.action === "preview" }));
+            return;
+          }
+          await initializeHome(home);
+          await resolveEffectiveConfig(home);
+          sendJson(response, 200, { ready: true });
+          ready();
+          return;
+        }
+        sendJson(response, 503, { error: `${issue.message} ${issue.action}`, issue, recovery: true });
+      })().catch((error) => {
+        issue = persistenceIssue(error, home);
+        sendJson(response, 422, { error: `${issue.message} ${issue.action}`, issue });
+      });
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    const actualPort = server.address().port;
+    const url = `http://127.0.0.1:${actualPort}`;
+    await publishRuntimeEndpoint(runtimeHome, url, "startup-recovery");
+    return {
+      url,
+      port: actualPort,
+      token,
+      tokenFile,
+      storePath: storagePaths(home).database,
+      repaired,
+      close: async () => {
+        server.closeIdleConnections();
+        await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+        if (readOnlyHome) await fs.rm(runtimeHome, { recursive: true, force: true });
+      }
+    };
+  }).catch(async (error) => {
+    if (readOnlyHome) await fs.rm(runtimeHome, { recursive: true, force: true });
+    throw error;
+  });
+}
+
+// ../server/src/cli.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+function requireValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value.`);
+  return value;
+}
+function parsePort(value, flag) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isFinite(port) || port < 0 || port > 65535) throw new Error(`${flag} must be a port from 0 to 65535.`);
+  return port;
+}
+function parseCliArgs(args) {
+  let mode = "serve";
+  let host = DEFAULT_HOST;
+  let port = DEFAULT_PORT;
+  let webRoot = null;
+  let openBrowser = false;
+  let printAccessUrl = false;
+  let storeDir = null;
+  let sourceBrowserState;
+  let index = 0;
+  const command = args[0];
+  if (command && !command.startsWith("-")) {
+    if (command === "serve" || command === "server") mode = "serve";
+    else if (command === "app-server") mode = "app-server";
+    else if (command === "web") mode = "web";
+    else if (command === "help") {
+      return { mode, host, port, webRoot, openBrowser, printAccessUrl, storeDir, help: true };
+    } else throw new Error(`Unknown command: ${command}`);
+    index = 1;
+  }
+  for (let i = index; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      return { mode, host, port, webRoot, openBrowser, printAccessUrl, storeDir, help: true };
+    }
+    if (arg === "--listen") {
+      const listen = parseListen(requireValue(args, i, arg));
+      host = listen.host;
+      port = parsePort(String(listen.port), arg);
+      i += 1;
+    } else if (arg === "--hostname" || arg === "--host") {
+      host = requireValue(args, i, arg);
+      i += 1;
+    } else if (arg === "--port") {
+      port = parsePort(requireValue(args, i, arg), arg);
+      i += 1;
+    } else if (arg === "--web-root") {
+      webRoot = path2.resolve(requireValue(args, i, arg));
+      i += 1;
+    } else if (arg === "--source-browser-state") {
+      sourceBrowserState = path2.resolve(requireValue(args, i, arg));
+      i += 1;
+    } else if (arg === "--store-dir") {
+      throw new Error("--store-dir has been replaced by --home. Use --home <directory> or OPENPOND_HOME.");
+    } else if (arg === "--home") {
+      storeDir = path2.resolve(requireValue(args, i, arg));
+      i += 1;
+    } else if (arg === "--open-browser") {
+      openBrowser = true;
+    } else if (arg === "--print-access-url") {
+      printAccessUrl = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (openBrowser && printAccessUrl) {
+    throw new Error("--open-browser and --print-access-url cannot be used together.");
+  }
+  if (mode !== "web" && (openBrowser || printAccessUrl)) {
+    throw new Error("Browser options are only available in web mode.");
+  }
+  return { mode, host, port, webRoot, openBrowser, printAccessUrl, storeDir, sourceBrowserState, help: false };
+}
+function defaultWebRootCandidates() {
+  return [
+    process.env.OPENPOND_WEB_ROOT,
+    path2.resolve(process.cwd(), "apps/web/dist"),
+    path2.resolve(__dirname, "../../web/dist"),
+    path2.resolve(process.cwd(), "web"),
+    path2.resolve(__dirname, "../web")
+  ].filter((candidate) => Boolean(candidate));
+}
+function resolveWebRoot(explicitWebRoot) {
+  const candidates = explicitWebRoot ? [explicitWebRoot] : defaultWebRootCandidates();
+  for (const candidate of candidates) {
+    const resolved = path2.resolve(candidate);
+    if (existsSync(path2.join(resolved, "index.html"))) return resolved;
+  }
+  return null;
+}
+function formatHostForUrl(host) {
+  const browserHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+  return browserHost.includes(":") && !browserHost.startsWith("[") ? `[${browserHost}]` : browserHost;
+}
+function browserBaseUrl(instance) {
+  return `http://${formatHostForUrl(instance.status.host)}:${instance.status.port}`;
+}
+function tokenizedWebUrl(baseUrl, token) {
+  const url = new URL(baseUrl);
+  const params = new URLSearchParams();
+  params.set("openpondServerUrl", baseUrl);
+  params.set("openpondToken", token);
+  url.hash = params.toString();
+  return url.toString();
+}
+async function resolveWebLaunchMessages(input, handOffToBrowser = openUrlWithSystemBrowser) {
+  const accessUrl = tokenizedWebUrl(input.baseUrl, input.token);
+  if (input.printAccessUrl) {
+    return { stdout: [`OpenPond access URL: ${accessUrl}`], stderr: [] };
+  }
+  if (!input.openBrowser) {
+    return { stdout: [`OpenPond web UI: ${input.baseUrl}`], stderr: [] };
+  }
+  const handoff = await handOffToBrowser(accessUrl);
+  if (handoff.opened) {
+    return { stdout: [`Opened OpenPond in your browser: ${input.baseUrl}`], stderr: [] };
+  }
+  return {
+    stdout: [`OpenPond access URL: ${accessUrl}`],
+    stderr: [`Could not open the system browser: ${handoff.error}`]
+  };
+}
+function printHelp() {
+  console.log(`Usage:
+  openpond-app-server serve [--hostname HOST] [--port PORT]
+  openpond-app-server app-server [--home DIR]
+  openpond-app-server web [--hostname HOST] [--port PORT] [--web-root DIR]
+
+Options:
+  --listen HOST:PORT     Set host and port together
+  --hostname HOST        Bind host (default ${DEFAULT_HOST})
+  --port PORT            Bind port, or 0 for any free port (default ${DEFAULT_PORT})
+  --web-root DIR         Directory containing the built web UI for web mode
+  --home DIR        Local app-server state directory
+  --open-browser         Open the authenticated web URL in the system browser
+  --print-access-url     Print the authenticated URL instead of opening it
+`);
+}
+async function runOpenPondServerCli(factories) {
+  const args = parseCliArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  const webRoot = args.mode === "web" ? resolveWebRoot(args.webRoot) : null;
+  if (args.mode === "web" && !webRoot) {
+    throw new Error("Could not find a built OpenPond web UI. Run `pnpm build:web` or pass --web-root.");
+  }
+  if (args.mode === "app-server") {
+    await runAgentServer(factories.createOpenPondAppServer, args.storeDir);
+    return;
+  }
+  if (args.storeDir) process.env.OPENPOND_HOME = args.storeDir;
+  let instance;
+  let port = args.port;
+  while (true) {
+    try {
+      instance = await factories.createOpenPondServer({
+        host: args.host,
+        port,
+        webRoot,
+        sourceBrowserState: args.sourceBrowserState,
+        ...args.storeDir ? { storeDir: args.storeDir } : {},
+        httpEnabled: true
+      });
+      break;
+    } catch (error) {
+      if (!isRecoverableStartupError(error)) throw error;
+      const recovery = await startRecoveryServer(resolveOpenPondHome({ home: args.storeDir ?? void 0 }), port, error);
+      port = recovery.port;
+      console.log(`OPENPOND_APP_SERVER_READY ${JSON.stringify({ mode: "recovery", url: recovery.url, tokenFile: recovery.tokenFile, storePath: recovery.storePath })}`);
+      console.error(`${error.issue.code}: ${error.issue.message} ${error.issue.action}`);
+      const messages = await resolveWebLaunchMessages({ baseUrl: recovery.url, openBrowser: args.openBrowser, printAccessUrl: args.printAccessUrl, token: recovery.token });
+      for (const message of messages.stdout) console.log(message);
+      for (const message of messages.stderr) console.error(message);
+      const close = () => {
+        void recovery.close().finally(() => process.exit(0));
+      };
+      process.once("SIGINT", close);
+      process.once("SIGTERM", close);
+      try {
+        await recovery.repaired;
+      } finally {
+        process.off("SIGINT", close);
+        process.off("SIGTERM", close);
+        await recovery.close();
+      }
+    }
+  }
+  const webBaseUrl = args.mode === "web" ? browserBaseUrl(instance) : null;
+  console.log(
+    `OPENPOND_APP_SERVER_READY ${JSON.stringify({
+      mode: args.mode,
+      url: instance.url,
+      webUrl: null,
+      webRoot,
+      tokenFile: instance.tokenFile,
+      storePath: instance.storePath,
+      runtime: getBundledRuntimeVersion()
+    })}`
+  );
+  if (webBaseUrl) {
+    const messages = await resolveWebLaunchMessages({
+      baseUrl: webBaseUrl,
+      openBrowser: args.openBrowser,
+      printAccessUrl: args.printAccessUrl,
+      token: instance.token
+    });
+    for (const message of messages.stderr) console.error(message);
+    for (const message of messages.stdout) console.log(message);
+  } else {
+    console.log(`OpenPond API server: ${instance.url}`);
+  }
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    await instance.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+  await new Promise(() => {
+  });
+}
+async function runOpenPondAppServerCli(createOpenPondAppServer) {
+  const rawArgs = process.argv.slice(2);
+  const args = parseCliArgs(
+    !rawArgs[0] || rawArgs[0].startsWith("-") ? ["app-server", ...rawArgs] : rawArgs
+  );
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (args.mode !== "app-server") {
+    throw new Error("The app-server entrypoint only accepts the app-server command.");
+  }
+  await runAgentServer(createOpenPondAppServer, args.storeDir);
+}
+async function runAgentServer(createOpenPondAppServer, storeDir) {
+  if (storeDir) process.env.OPENPOND_HOME = storeDir;
+  const appServer = await createOpenPondAppServer({
+    ...storeDir ? { storeDir } : {}
+  });
+  await runAppServerJsonl({
+    appServer,
+    readable: process.stdin,
+    writable: process.stdout
+  });
+}
+
+export {
+  createConfigurationPayloads,
+  HttpBodyError,
+  applyCorsHeaders,
+  sendJson,
+  sendText,
+  sendBinary,
+  readJson,
+  hasAuth,
+  resolveWebLaunchMessages,
+  runOpenPondServerCli,
+  runOpenPondAppServerCli
+};

package/dist/chunks/{chunk-2JABRRNR.js → chunk-PS37DB5F.js}

@@ -4,7 +4,7 @@ import {
   getAnyCliOptionKind,
   getCliCommandDefinition,
   getCliOptionKind
-} from "./chunk-N3TGCM7J.js";
+} from "./chunk-7RIGZB7N.js";
 import {
   parseJsonOption
 } from "./chunk-MUMPWI4O.js";

package/dist/chunks/{chunk-C5TKGE5Y.js → chunk-UZMVNKXM.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   now
-} from "./chunk-DJL4TJYG.js";
+} from "./chunk-KCRCIQPD.js";
 
 // ../server/src/workspace/workspace-command.ts
 import { spawn, spawnSync } from "node:child_process";