@genesislcap/ai-assistant 15.86.1 → 15.87.0

package/dist/headless-server.mjs

@@ -0,0 +1,819 @@
+// src/headless-server/compact.ts
+var MESSAGE_LINES = 3;
+var MESSAGE_CHARS = 300;
+var TURN_TEXT_CHARS = 1500;
+function firstLines(text, lines, chars) {
+  const kept = text.split("\n").slice(0, lines).join("\n");
+  const cut = kept.length > chars ? `${kept.slice(0, chars)}\u2026` : kept;
+  return cut === text ? { text } : { text: cut, chars: text.length };
+}
+function present(source) {
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0 || value === null || value === "" || value === false) continue;
+    if (Array.isArray(value) && value.length === 0) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function compactEvent(event, options = {}) {
+  switch (event.type) {
+    case "decision":
+    case "working":
+      return void 0;
+    case "settled":
+      return {
+        event: "settled",
+        component: event.component,
+        ...present({
+          answeredBy: event.answeredBy,
+          auto: event.auto,
+          raw: event.raw,
+          resolvedItself: event.resolvedItself
+        })
+      };
+    case "message": {
+      const { text, chars } = firstLines(event.text, MESSAGE_LINES, MESSAGE_CHARS);
+      return { event: "message", text, ...present({ chars: chars ?? event.chars }) };
+    }
+    case "turn": {
+      const out = {
+        event: "turn",
+        reason: event.reason,
+        ...present({ failureReason: event.failureReason })
+      };
+      if (event.text) {
+        const { text, chars } = firstLines(event.text, Number.MAX_SAFE_INTEGER, TURN_TEXT_CHARS);
+        out.text = text;
+        if (chars ?? event.chars) out.chars = chars ?? event.chars;
+      }
+      return out;
+    }
+    case "autopilot":
+      if (event.mode === "unavailable" && !event.needsUser) return void 0;
+      return {
+        event: "autopilot",
+        mode: event.mode,
+        status: event.status,
+        ...present({ needsUser: event.needsUser, working: event.working, reason: event.reason })
+      };
+    case "error":
+      return { event: "error", where: event.where, message: event.message };
+    case "probe": {
+      const view = options.probeEvent;
+      if (!view) {
+        const changed = Object.fromEntries(event.changed.map((key) => [key, event.probe[key]]));
+        return { event: "probe", ...changed };
+      }
+      if (!event.changed.some((key) => view.keys.includes(key))) return void 0;
+      return {
+        event: view.name,
+        ...Object.fromEntries(view.keys.map((key) => [key, event.probe[key] ?? null]))
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+var PREVIEW_MARK = " (shown below as Now)";
+var NOW_PREFIX = "Now: ";
+var CUT_PREFIX = "[Cut at ";
+function leanDecisionText(text, views) {
+  const names = Object.keys(views ?? {});
+  if (!names.length) return text;
+  const lines = text.split("\n");
+  const marked = lines.findIndex((line) => line.endsWith(PREVIEW_MARK));
+  if (marked < 0) return text;
+  const startsEntry = (line, name) => line === `  ${name}${PREVIEW_MARK}` || line.startsWith(`  ${name} \u2014 `);
+  let entry = marked;
+  while (entry >= 0 && !names.some((n) => startsEntry(lines[entry], n))) entry -= 1;
+  const view = entry < 0 ? void 0 : names.find((n) => startsEntry(lines[entry], n));
+  if (view === void 0) return text;
+  const now = lines.findIndex((line, i) => i > marked && line.startsWith(NOW_PREFIX));
+  if (now < 0) return text;
+  const end = lines[now + 1]?.startsWith(CUT_PREFIX) ? now + 2 : now + 1;
+  lines.splice(
+    now,
+    end - now,
+    `(The "${view}" view is not repeated here: read it with read ${view}.)`
+  );
+  return lines.join("\n");
+}
+function compactDecision(description, decisionText = "full") {
+  const actions = description.actions.map((a) => ({
+    ...a.n !== void 0 ? { n: a.n } : {},
+    name: a.name,
+    ...present({ label: a.label !== a.name ? a.label : void 0 }),
+    enabled: a.enabled,
+    ...present({
+      unavailable: a.unavailable,
+      args: a.args,
+      argsSchema: a.args === "fields" ? a.argsSchema : void 0
+    })
+  }));
+  return {
+    interactionId: description.interactionId,
+    component: description.component,
+    text: decisionText === "lean" ? leanDecisionText(description.text, description.views) : description.text,
+    actions,
+    ...description.views && Object.keys(description.views).length ? { views: { ...description.views } } : {},
+    ...description.controller ? {} : { controller: false }
+  };
+}
+function shortDecision(interactionId, component, actions) {
+  return {
+    interactionId,
+    component,
+    actions: actions.map((a) => ({
+      ...a.n !== void 0 ? { n: a.n } : {},
+      name: a.name,
+      enabled: a.enabled
+    }))
+  };
+}
+var OUTPUT_CHARS = 4e3;
+function capOutput(output) {
+  let json;
+  try {
+    json = JSON.stringify(output);
+  } catch {
+    return String(output);
+  }
+  if (json === void 0 || json.length <= OUTPUT_CHARS) return output;
+  return { truncated: `${json.slice(0, OUTPUT_CHARS)}\u2026`, chars: json.length };
+}
+
+// src/headless-server/server.ts
+import { createWriteStream, mkdirSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { join, resolve } from "node:path";
+
+// src/headless-server/types.ts
+var DECISION_TEXTS = ["full", "lean"];
+var DEFAULT_DECISION_TEXT = "lean";
+
+// src/headless-server/server.ts
+var DEFAULT_MAX_WAIT_MS = 1e5;
+var MAX_WAIT_CAP_MS = 36e5;
+var BUILTIN_OPS = [
+  "send",
+  "act",
+  "resolve",
+  "autopilot",
+  "wait",
+  "state",
+  "read",
+  "debugLog",
+  "stop"
+];
+var BYTES_PER_KB = 1024;
+var MAX_BODY_MB = 16;
+var MAX_BODY_BYTES = MAX_BODY_MB * BYTES_PER_KB * BYTES_PER_KB;
+var HTTP_OK = 200;
+var HTTP_BAD_REQUEST = 400;
+var HTTP_FORBIDDEN = 403;
+var HTTP_NOT_FOUND = 404;
+var HTTP_UNSUPPORTED_MEDIA_TYPE = 415;
+var LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "[::1]", "::1"];
+var HTTP_SERVER_ERROR = 500;
+var CLOSE_GRACE_MS = 500;
+var MONEY_SCALE = 1e4;
+var WATCH_MS = 2e3;
+var ALL_EVENT_TYPES = [
+  "decision",
+  "working",
+  "settled",
+  "message",
+  "turn",
+  "autopilot",
+  "probe",
+  "error"
+];
+function untilOf(value) {
+  if (value === void 0) return void 0;
+  const names = (Array.isArray(value) ? value : [value]).map(String);
+  return {
+    types: names.filter(
+      (n) => ALL_EVENT_TYPES.includes(n)
+    ),
+    idle: names.includes("idle")
+  };
+}
+function waitMsOf(value, fallback) {
+  const n = Number(value ?? fallback);
+  return Number.isFinite(n) ? Math.min(Math.max(0, n), MAX_WAIT_CAP_MS) : fallback;
+}
+var hasOwn = (target, key) => !!target && Object.prototype.hasOwnProperty.call(target, key);
+var money = (usd) => Math.round(usd * MONEY_SCALE) / MONEY_SCALE;
+function createHeadlessServer(options) {
+  const runDir = resolve(options.runDir);
+  mkdirSync(runDir, { recursive: true });
+  const defaultMaxWaitMs = waitMsOf(options.defaultMaxWaitMs, DEFAULT_MAX_WAIT_MS);
+  let decisionText = options.decisionText ?? DEFAULT_DECISION_TEXT;
+  const announce = options.announce ?? ((line) => console.log(line));
+  const events = createWriteStream(join(runDir, "events.jsonl"), { flags: "a" });
+  const startedAt = Date.now();
+  let session;
+  let http;
+  let closing = false;
+  let loggedSeq = 0;
+  let applying = Promise.resolve();
+  let flushing = Promise.resolve();
+  let resolveClosed;
+  const closed = new Promise((r) => {
+    resolveClosed = r;
+  });
+  const appendLog = (line) => {
+    if (!events.writableEnded) events.write(`${JSON.stringify(line)}
+`);
+  };
+  function drainLog() {
+    if (!session) return;
+    for (const event of session.eventsSince(loggedSeq)) {
+      appendLog({ kind: "event", ...event });
+      loggedSeq = event.seq;
+    }
+  }
+  function flushAll() {
+    flushing = flushing.then(async () => {
+      try {
+        await options.flush?.();
+        await session?.flush();
+      } catch (e) {
+        appendLog({
+          kind: "error",
+          where: "flush",
+          message: e instanceof Error ? e.message : String(e)
+        });
+      }
+    });
+    return flushing;
+  }
+  async function watch(s) {
+    let cursor = s.state().lastSeq;
+    drainLog();
+    const watching = () => !closing && session === s;
+    while (watching()) {
+      try {
+        const woken = await s.wait({ since: cursor, until: ALL_EVENT_TYPES, maxWaitMs: WATCH_MS });
+        cursor = woken.nextSeq;
+        drainLog();
+        if (woken.events.some((e) => e.type === "turn")) await flushAll();
+        if (woken.status === "closed") break;
+      } catch (e) {
+        appendLog({
+          kind: "error",
+          where: "watch",
+          message: e instanceof Error ? e.message : String(e)
+        });
+        break;
+      }
+    }
+  }
+  const handle = {
+    get session() {
+      return session;
+    },
+    runDir,
+    get decisionText() {
+      return decisionText;
+    },
+    setDecisionText(mode) {
+      decisionText = mode;
+    },
+    attach(next) {
+      if (session === next) return;
+      session = next;
+      loggedSeq = 0;
+      void watch(next);
+    },
+    listen,
+    handle: runCommand,
+    shutdown,
+    closed
+  };
+  if (options.session) handle.attach(options.session);
+  const composerOf = (state) => {
+    if (!state) return "blocked:not-started";
+    const blocked = options.composerBlockedReason?.();
+    if (blocked) return `blocked:${blocked}`;
+    return state.busy ? "busy" : "open";
+  };
+  function statusNow(state) {
+    if (!state) return "idle";
+    if (state.pending) return "decision";
+    if (options.isEnded?.()) return "ended";
+    if (state.autopilot?.needsUser) return "needs-user";
+    return state.busy ? "working" : "idle";
+  }
+  const probeView = (state) => {
+    const view = options.probeEvent;
+    if (!view) return void 0;
+    return Object.fromEntries(view.keys.map((key) => [key, state.probe[key] ?? null]));
+  };
+  function stageOf(state, other) {
+    if (other) {
+      let stage;
+      try {
+        stage = options.describeWorking?.(other.interactionId, other.component);
+      } catch {
+      }
+      if (stage) return stage;
+      const idle = other.heldBy === "autopilot" && state.autopilot?.mode !== "running";
+      return other.heldBy !== "user" && !idle ? `${other.heldBy} is answering it` : void 0;
+    }
+    if (state.autopilot?.working && state.autopilot.mode === "running") {
+      return "autopilot is working";
+    }
+    return state.busy ? "assistant is thinking (no widget open)" : void 0;
+  }
+  function workingInfo(state, startedMs) {
+    const other = state.others.find((o) => !o.ready || o.heldBy !== "user") ?? state.others[0];
+    return {
+      ...other ? { component: other.component, heldBy: other.heldBy } : {},
+      elapsedMs: Date.now() - startedMs,
+      ...present({ probe: probeView(state), stage: stageOf(state, other) })
+    };
+  }
+  const decisionTextFor = (command) => DECISION_TEXTS.includes(command?.decisionText) ? command.decisionText : decisionText;
+  function reply(command, status, since, extra = {}, startedMs = Date.now()) {
+    const state = session?.state();
+    const compact = since.map((e) => compactEvent(e, { probeEvent: options.probeEvent })).filter((e) => !!e);
+    return {
+      ok: extra.ok ?? true,
+      ...command?.id !== void 0 ? { id: command.id } : {},
+      status,
+      ...compact.length ? { since: compact } : {},
+      ...state?.pending ? { decision: compactDecision(state.pending, decisionTextFor(command)) } : {},
+      ...status === "working" && state ? { working: workingInfo(state, startedMs) } : {},
+      composer: composerOf(state),
+      cost: { usd: money(state?.cost.costUsd ?? 0) },
+      nextSeq: state?.lastSeq ?? 0,
+      ...extra
+    };
+  }
+  function refuse(command, error, reason, since = void 0, shortFor) {
+    const state = session?.state();
+    const missed = session && since !== void 0 ? session.eventsSince(since) : [];
+    const pending = state?.pending;
+    return reply(command, statusNow(state), missed, {
+      ok: false,
+      error,
+      ...reason ? { reason } : {},
+      ...pending && shortFor !== void 0 && pending.interactionId === shortFor ? { decision: shortDecision(pending.interactionId, pending.component, pending.actions) } : {}
+    });
+  }
+  function edited(command, interactionId, result, cursor) {
+    const s = session;
+    const state = s.state();
+    const open = state.pending?.interactionId === interactionId ? state.pending : void 0;
+    const actions = result.description?.actions ?? open?.actions ?? result.actions;
+    const component = result.description?.component ?? open?.component ?? state.others.find((o) => o.interactionId === interactionId)?.component ?? "";
+    return reply(command, "edited", s.eventsSince(cursor), {
+      decision: shortDecision(interactionId, component, actions),
+      ...result.output !== void 0 ? { output: capOutput(result.output) } : {}
+    });
+  }
+  async function poll(command, cursor, startedMs, signal) {
+    const s = session;
+    if (!s) return reply(command, "idle", [], {}, startedMs);
+    const maxWaitMs = waitMsOf(command.maxWaitMs, defaultMaxWaitMs);
+    const deadline = startedMs + maxWaitMs;
+    const until = untilOf(command.until);
+    let waitFrom = cursor;
+    for (; ; ) {
+      const since = s.eventsSince(cursor);
+      const state = s.state();
+      const verdict = terminal(since, state, until);
+      if (verdict) {
+        if (since.some((e) => e.type === "turn") || verdict === "ended") await flushAll();
+        drainLog();
+        return reply(command, verdict, s.eventsSince(cursor), {}, startedMs);
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0 || signal?.aborted) {
+        drainLog();
+        return reply(command, "working", since, {}, startedMs);
+      }
+      const woken = await s.wait({
+        since: waitFrom,
+        ...until ? { until: until.types } : {},
+        maxWaitMs: remaining,
+        ...signal ? { signal } : {}
+      });
+      waitFrom = woken.nextSeq;
+      if (woken.status === "closed") {
+        drainLog();
+        return reply(command, "ended", s.eventsSince(cursor), {}, startedMs);
+      }
+    }
+  }
+  function terminal(since, state, until) {
+    const turnEnded = since.some((e) => e.type === "turn");
+    const failed = since.some((e) => e.type === "error" || e.type === "turn" && e.failureReason);
+    if (options.isEnded?.() && !state.pending && (turnEnded || !state.busy)) return "ended";
+    if (until) {
+      if (state.pending && until.types.includes("decision")) return "decision";
+      if (since.some((e) => until.types.includes(e.type))) {
+        return since.some((e) => e.type === "error") ? "error" : turnEnded ? "turn" : statusNow(state);
+      }
+      if (until.idle && !state.busy && !state.pending) return "idle";
+      return void 0;
+    }
+    if (state.pending) return "decision";
+    if (failed) return "error";
+    if (turnEnded) return "turn";
+    if (state.autopilot?.needsUser) return "needs-user";
+    return void 0;
+  }
+  const isOpen = (state, interactionId) => state.pending?.interactionId === interactionId || state.others.some((o) => o.interactionId === interactionId);
+  const gone = (command, interactionId, since) => refuse(
+    command,
+    `interaction ${interactionId} is not pending: it has settled, or never existed`,
+    "ended",
+    since
+  );
+  const notStarted = (command) => refuse(
+    command,
+    options.extraOps?.start ? 'not started: send {"op":"start", \u2026} first' : "no session is attached",
+    "not-started"
+  );
+  const str = (value) => typeof value === "string" ? value : void 0;
+  const actionOf = (value) => typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+  async function applyOp(command, s, cursor) {
+    const state = s.state();
+    switch (command.op) {
+      case "send": {
+        const text = str(command.text);
+        if (text === void 0) return refuse(command, "`send` needs `text`", "invalid-command");
+        const paths = Array.isArray(command.files) ? command.files.map(String) : [];
+        let attachments;
+        if (paths.length) {
+          if (!options.readAttachment) {
+            return refuse(command, "this server cannot read files", "invalid-command");
+          }
+          try {
+            attachments = await Promise.all(paths.map((p) => options.readAttachment(p)));
+          } catch (e) {
+            return refuse(
+              command,
+              `could not read a file: ${e instanceof Error ? e.message : String(e)}`,
+              "invalid-command"
+            );
+          }
+        }
+        const sent = s.send(text, {
+          ...attachments ? { attachments } : {},
+          ...str(command.agent) ? { agent: str(command.agent) } : {}
+        });
+        return sent.ok ? "poll" : refuse(command, sent.error, "refused", cursor);
+      }
+      case "act": {
+        const interactionId = str(command.interactionId);
+        if (!interactionId || command.action === void 0) {
+          return refuse(command, "`act` needs `interactionId` and `action`", "invalid-command");
+        }
+        if (!isOpen(state, interactionId)) return gone(command, interactionId, cursor);
+        const result = await s.act(interactionId, actionOf(command.action), {
+          ...str(command.text) !== void 0 ? { text: str(command.text) } : {},
+          ...Array.isArray(command.options) ? { options: command.options.map(String) } : {},
+          ...command.fields !== void 0 ? { fields: command.fields } : {}
+        });
+        if (!result.ok) return refuse(command, result.message, result.error, cursor, interactionId);
+        if (result.finished === false) return edited(command, interactionId, result, cursor);
+        return "poll";
+      }
+      case "resolve": {
+        const interactionId = str(command.interactionId);
+        if (!interactionId)
+          return refuse(command, "`resolve` needs `interactionId` and `result`", "invalid-command");
+        if (!isOpen(state, interactionId)) return gone(command, interactionId, cursor);
+        const resolved = s.resolve(interactionId, command.result);
+        return resolved.ok ? "poll" : refuse(command, resolved.error, "refused", cursor);
+      }
+      case "autopilot": {
+        const mode = {
+          pause: "pause",
+          paused: "pause",
+          resume: "resume",
+          running: "resume",
+          stop: "stop"
+        }[String(command.mode)];
+        if (!mode)
+          return refuse(
+            command,
+            "`autopilot` needs `mode`: running, paused or stop",
+            "invalid-command"
+          );
+        const done = s.autopilot(mode);
+        return done.ok ? "poll" : refuse(command, done.error, "refused", cursor);
+      }
+      case "wait":
+        return "poll";
+      default:
+        return refuse(command, `unknown op "${command.op}"`, "unknown-op");
+    }
+  }
+  async function readOp(command, s) {
+    switch (command.op) {
+      case "state": {
+        const state = s.state();
+        return reply(command, statusNow(state), [], {
+          ...state.others.length ? { others: state.others } : {},
+          ...state.autopilot ? { autopilot: state.autopilot } : {},
+          ...Object.keys(state.probe).length ? { probe: state.probe } : {},
+          busy: state.busy
+        });
+      }
+      case "read": {
+        const interactionId = str(command.interactionId);
+        if (!interactionId)
+          return refuse(command, "`read` needs `interactionId`", "invalid-command");
+        const read = await s.read(interactionId, {
+          ...str(command.view) ? { view: str(command.view) } : {},
+          ...str(command.tool) ? { tool: str(command.tool) } : {},
+          ...command.args && typeof command.args === "object" ? { args: command.args } : {}
+        });
+        return read.ok ? {
+          ok: true,
+          ...command.id !== void 0 ? { id: command.id } : {},
+          content: read.content
+        } : {
+          ok: false,
+          ...command.id !== void 0 ? { id: command.id } : {},
+          error: read.error
+        };
+      }
+      case "debugLog": {
+        await flushAll();
+        const log = await s.debugLog();
+        const path = join(runDir, "debug-log.json");
+        await writeFile(path, JSON.stringify(log));
+        const byKind = {};
+        for (const entry of log.timeline) {
+          const kind = String(entry.kind ?? "unknown");
+          byKind[kind] = (byKind[kind] ?? 0) + 1;
+        }
+        const usd = log.sessionUsage?.costUsd ?? s.state().cost.costUsd;
+        return reply(command, statusNow(s.state()), [], {
+          path,
+          entries: { total: log.timeline.length, byKind },
+          cost: { usd: money(usd) }
+        });
+      }
+      default:
+        return void 0;
+    }
+  }
+  async function runCommand(raw, signal) {
+    const startedMs = Date.now();
+    const command = raw;
+    if (!command || typeof command !== "object" || typeof command.op !== "string") {
+      return reply(void 0, statusNow(session?.state()), [], {
+        ok: false,
+        error: "a command is a JSON object with a string `op`",
+        reason: "invalid-command"
+      });
+    }
+    appendLog({ kind: "command", at: (/* @__PURE__ */ new Date()).toISOString(), command });
+    if (command.decisionText !== void 0 && !DECISION_TEXTS.includes(command.decisionText)) {
+      return refuse(
+        command,
+        `\`decisionText\` must be one of ${DECISION_TEXTS.join(", ")} (got ${JSON.stringify(command.decisionText)})`,
+        "invalid-command"
+      );
+    }
+    try {
+      const out = await dispatch(command, startedMs, signal);
+      drainLog();
+      return out;
+    } catch (e) {
+      drainLog();
+      appendLog({
+        kind: "error",
+        where: `op:${command.op}`,
+        message: e instanceof Error ? e.message : String(e)
+      });
+      return reply(command, statusNow(session?.state()), [], {
+        ok: false,
+        status: "error",
+        error: e instanceof Error ? e.message : String(e),
+        reason: "threw"
+      });
+    }
+  }
+  async function dispatch(command, startedMs, signal) {
+    if (command.op === "stop") {
+      session?.stop();
+      const out = reply(command, "ended", [], { stopped: true });
+      setTimeout(() => void shutdown(), 0);
+      return out;
+    }
+    const isBuiltin = BUILTIN_OPS.includes(command.op);
+    const extra = !isBuiltin && hasOwn(options.extraOps, command.op) ? options.extraOps[command.op] : void 0;
+    if (!extra && !isBuiltin) {
+      return refuse(command, `unknown op "${command.op}"`, "unknown-op");
+    }
+    if (command.op === "state" || command.op === "read" || command.op === "debugLog") {
+      if (!session) return notStarted(command);
+      return await readOp(command, session);
+    }
+    const cursor = typeof command.since === "number" ? command.since : session?.state().lastSeq ?? 0;
+    if (command.op === "wait") {
+      if (!session) return notStarted(command);
+      return poll(command, cursor, startedMs, signal);
+    }
+    const previous = applying;
+    let release;
+    applying = new Promise((r) => {
+      release = r;
+    });
+    let applied;
+    try {
+      await previous;
+      if (extra) {
+        applied = await extra(command, handle);
+      } else {
+        if (!session) return notStarted(command);
+        applied = await applyOp(command, session, cursor);
+      }
+    } finally {
+      release();
+    }
+    if (applied === "poll") return poll(command, cursor, startedMs, signal);
+    if ("status" in applied) return applied;
+    if (!applied.ok)
+      return refuse(
+        command,
+        applied.error ?? "refused",
+        "refused",
+        typeof command.since === "number" ? cursor : void 0
+      );
+    const wait = applied.poll ?? !!session;
+    if (!wait || !session) {
+      const pending = session?.state().pending;
+      return reply(
+        command,
+        statusNow(session?.state()),
+        [],
+        {
+          ...applied.fields,
+          ...applied.shortDecision && pending ? { decision: shortDecision(pending.interactionId, pending.component, pending.actions) } : {}
+        },
+        startedMs
+      );
+    }
+    const polled = await poll(command, cursor, startedMs, signal);
+    return { ...polled, ...applied.fields };
+  }
+  function readBody(req) {
+    return new Promise((resolveBody, reject) => {
+      const chunks = [];
+      let size = 0;
+      req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > MAX_BODY_BYTES) {
+          reject(new Error("the command is too large"));
+          req.destroy();
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => resolveBody(Buffer.concat(chunks).toString("utf8")));
+      req.on("error", reject);
+    });
+  }
+  function send(res, status, body) {
+    const json = JSON.stringify(body);
+    res.writeHead(status, {
+      "content-type": "application/json; charset=utf-8",
+      "content-length": Buffer.byteLength(json)
+    });
+    res.end(json);
+  }
+  function refusal(req, port) {
+    if (req.headers.origin !== void 0) {
+      return { status: HTTP_FORBIDDEN, error: "a request from a web page is refused" };
+    }
+    const bound = options.host ?? "127.0.0.1";
+    if (LOOPBACK_HOSTS.includes(bound)) {
+      const host = (req.headers.host ?? "").toLowerCase();
+      if (!LOOPBACK_HOSTS.some((name) => host === `${name}:${port}`)) {
+        return {
+          status: HTTP_FORBIDDEN,
+          error: `the Host must be 127.0.0.1:${port} or localhost:${port}`
+        };
+      }
+    }
+    if (req.method === "POST") {
+      const type = (req.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase();
+      if (type !== "application/json") {
+        return {
+          status: HTTP_UNSUPPORTED_MEDIA_TYPE,
+          error: "POST /cmd takes content-type: application/json"
+        };
+      }
+    }
+    return void 0;
+  }
+  async function onRequest(req, res) {
+    const refused = refusal(req, http.address().port);
+    if (refused) {
+      send(res, refused.status, { ok: false, status: "error", error: refused.error });
+      return;
+    }
+    const url = (req.url ?? "/").split("?")[0];
+    if (req.method === "GET" && url === "/health") {
+      const state = session?.state();
+      send(res, HTTP_OK, {
+        ok: true,
+        started: !!session,
+        runDir,
+        pid: process.pid,
+        uptimeMs: Date.now() - startedAt,
+        ...state ? { status: statusNow(state), nextSeq: state.lastSeq } : {}
+      });
+      return;
+    }
+    if (req.method === "POST" && url === "/cmd") {
+      let command;
+      try {
+        command = JSON.parse(await readBody(req));
+      } catch (e) {
+        send(res, HTTP_BAD_REQUEST, {
+          ok: false,
+          status: "error",
+          error: `bad command: ${e instanceof Error ? e.message : String(e)}`
+        });
+        return;
+      }
+      const gone2 = new AbortController();
+      res.on("close", () => {
+        if (!res.writableEnded) gone2.abort();
+      });
+      const out = await runCommand(command, gone2.signal);
+      if (!gone2.signal.aborted) send(res, HTTP_OK, out);
+      return;
+    }
+    send(res, HTTP_NOT_FOUND, {
+      ok: false,
+      error: "GET /health, or POST /cmd with one JSON command"
+    });
+  }
+  function listen() {
+    return new Promise((resolveListen, reject) => {
+      http = createServer((req, res) => {
+        onRequest(req, res).catch((e) => {
+          if (!res.headersSent)
+            send(res, HTTP_SERVER_ERROR, { ok: false, status: "error", error: String(e) });
+          else res.end();
+        });
+      });
+      http.once("error", reject);
+      http.listen(options.port ?? 0, options.host ?? "127.0.0.1", () => {
+        const { port } = http.address();
+        announce(`HEADLESS_READY port=${port} runDir=${runDir}`);
+        resolveListen({ port, runDir });
+      });
+    });
+  }
+  async function shutdown() {
+    if (closing) return closed;
+    closing = true;
+    try {
+      session?.stop();
+    } catch {
+    }
+    await flushAll();
+    drainLog();
+    await new Promise((r) => {
+      if (!http) {
+        r();
+        return;
+      }
+      http.close(() => r());
+      http.closeIdleConnections?.();
+      setTimeout(() => http?.closeAllConnections?.(), CLOSE_GRACE_MS).unref();
+    });
+    await new Promise((r) => {
+      events.end(r);
+    });
+    await options.onClosed?.();
+    resolveClosed();
+    return closed;
+  }
+  return handle;
+}
+export {
+  DECISION_TEXTS,
+  DEFAULT_DECISION_TEXT,
+  capOutput,
+  compactDecision,
+  compactEvent,
+  createHeadlessServer,
+  firstLines,
+  leanDecisionText,
+  shortDecision
+};
+//# sourceMappingURL=headless-server.mjs.map