@visual-z/xeno 0.8.4 → 0.9.1

package/src/runtime/exec-sessions.ts

@@ -1,456 +0,0 @@
-/**
- * Processes that outlive one tool call: servers, REPLs, long builds, prompts.
- *
- * `exec_command` starts one and waits up to a yield time; if it is still
- * running, the model gets a session id and polls or types into it with
- * `write_stdin`. The shape and names follow Codex's unified exec
- * (codex-rs `unified_exec/`, Apache-2.0; design only), which is what GPT-family
- * models are trained against, and Warp's Terminal-Bench write-up found that
- * control over interactive programs was worth more than anything else.
- *
- * Every call still ends in one tool_result, so the log records each
- * observation in order (log-as-truth). What the log cannot hold is the
- * process itself: sessions belong to this OS process and die with it, and a
- * restarted xeno recovers observations from the log without reattaching a PID.
- *
- * Output is spooled to a file as it arrives. Each call archives exactly the
- * bytes since the previous call as an observation blob (D8), without keeping
- * cumulative output strings. Capture errors are explicit partial observations.
- */
-import { open, mkdir, rm, type FileHandle } from "node:fs/promises";
-import { createReadStream } from "node:fs";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-import { commandArgv, commandEnvironment, COMMAND_TERMINATION_GRACE_MS } from "../core/command-contract.ts";
-import { archiveObservation, type ArchivedObservation } from "../store/observations.ts";
-import { configDir } from "../store/config.ts";
-import { xenoBinDir } from "../store/tool-binaries.ts";
-import { ToolFault, NOT_STARTED } from "../core/tool-failure.ts";
-import { processReceipt, retainProcessReceipts, type ProcessReceipt, type ProcessSource } from "../core/process-receipt.ts";
-import type { CommandArtifactObserver } from "./command-artifacts.ts";
-import type { CommandArtifactReceipt } from "../core/command-artifacts.ts";
-
-/** Codex's default: long enough for most commands to finish in one call. */
-export const DEFAULT_YIELD_MS = 10_000;
-/** Bounds on a foreground poll or input send. Owned observation waits have no polling deadline. */
-export const MIN_YIELD_MS = 100;
-export const MAX_YIELD_MS = 30_000;
-
-/**
- * The wait actually taken, clamped like Codex's `clamp_yield_time` (S.6
- * item 5): an out-of-range value still runs the call, and `note` tells the
- * model what it waited instead of what it asked for.
- */
-export function yieldWait(value: unknown): { ms: number; note: string } {
-  const requested = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_YIELD_MS;
-  const ms = Math.min(MAX_YIELD_MS, Math.max(MIN_YIELD_MS, requested));
-  return { ms, note: ms === requested ? "" : ` · yield_time_ms ${requested} clamped to ${ms}` };
-}
-/**
- * Bounds on one owned empty wait's window, copied from Codex's empty
- * `write_stdin` (MIN_EMPTY_YIELD_TIME_MS, DEFAULT_MAX_BACKGROUND_TERMINAL_TIMEOUT_MS),
- * not measured. The floor is what stops a chatty process from waking the
- * model every line: below it, a 100 ms request brings the per-line wakeups back.
- */
-export const MIN_EMPTY_YIELD_MS = 5_000;
-export const MAX_EMPTY_YIELD_MS = 300_000;
-export function emptyYieldWait(value: unknown): { ms: number; note: string } {
-  const requested = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_YIELD_MS;
-  const ms = Math.min(MAX_EMPTY_YIELD_MS, Math.max(MIN_EMPTY_YIELD_MS, requested));
-  return { ms, note: ms === requested ? "" : ` · yield_time_ms ${requested} clamped to ${ms}` };
-}
-/**
- * Concurrent sessions. An assumption, not a measurement: comfortably above a
- * server + watcher + REPL, low enough that a runaway loop of starts is refused
- * well before it exhausts the machine.
- */
-export const MAX_SESSIONS = 16;
-/** Assumed drain bound for descendants which escaped the owned group; never claim EOF on expiry. */
-const EXIT_DRAIN_MS = 1_000;
-/** Disposable acceleration only. Original log receipts outlive these assumed memory bounds. */
-export const CLOSED_RECEIPT_LIMIT = 64;
-export const CLOSED_RECEIPT_AGE_MS = 10 * 60_000;
-
-type TakenOutput = {
-  stored: ArchivedObservation; receipt: ProcessReceipt; wallMs: number;
-  exit: number | null; stopped?: "timeout" | "cancelled";
-  /**
-   * Input that arrived after the process exited and was not written:
-   * "control" for interrupt/EOF, whose intent the exit already satisfied;
-   * "refused" for real input, which the caller must report as not sent.
-   */
-  unsent?: "control" | "refused";
-};
-type ClosedSession = { owner?: string; id: number; endedAt: number; receipt: ProcessReceipt };
-
-interface Session {
-  owner?: string;
-  id: number;
-  command: string;
-  cwd: string;
-  tty: boolean;
-  source: ProcessSource;
-  artifactObserver?: CommandArtifactObserver;
-  artifacts?: Promise<CommandArtifactReceipt>;
-  started: number;
-  pid: number;
-  spool: FileHandle;
-  spoolPath: string;
-  queue: Promise<unknown>;
-  operations: Promise<unknown>;
-  final?: TakenOutput;
-  captureError?: string;
-  written: number;
-  read: number;
-  exit: number | null;
-  stopped?: "timeout" | "cancelled";
-  escalation?: ReturnType<typeof setTimeout>;
-  timeoutMs: number;
-  exited: Promise<void>;
-  drained: Promise<void>;
-  finishing?: Promise<void>;
-  closeCapture(): Promise<void>;
-  alive(): boolean;
-  write(chars: string): void;
-  kill(signal: NodeJS.Signals): void;
-  timer: ReturnType<typeof setTimeout>;
-}
-
-const sessions = new Map<number, Session>();
-const closedSessions = new Map<number, ClosedSession>();
-// O.14: a restarted process must not accidentally reuse an old poll capability.
-let nextId = Number.parseInt(randomUUID().replaceAll("-", "").slice(0, 12), 16);
-let hooked = false;
-
-function killGroup(pid: number, signal: NodeJS.Signals): void {
-  try { process.kill(-pid, signal); } catch (error) {
-    if ((error as { code?: string }).code !== "ESRCH") {
-      try { process.kill(pid, signal); } catch { /* already gone */ }
-    }
-  }
-}
-
-/** Every session dies with xeno: a server nobody can poll is a leak, not a feature. */
-export function killAllExecSessions(): void {
-  for (const session of sessions.values()) {
-    clearTimeout(session.timer);
-    clearTimeout(session.escalation);
-    if (session.exit === null) session.kill("SIGKILL");
-    void session.spool.close().catch(() => {});
-    void rm(session.spoolPath, { force: true });
-  }
-  sessions.clear();
-  closedSessions.clear();
-}
-
-export function runningSessions(owner?: string): { id: number; command: string; exit: number | null }[] {
-  return [...sessions.values()].filter(session => session.owner === owner).map(({ id, command, exit }) => ({ id, command, exit }));
-}
-
-function pruneClosed(now: number): void {
-  const retained = retainProcessReceipts([...closedSessions.values()], now, CLOSED_RECEIPT_AGE_MS, CLOSED_RECEIPT_LIMIT);
-  closedSessions.clear();
-  for (const item of retained) closedSessions.set(item.id, item);
-}
-
-export function closedSession(id: number, owner?: string): ClosedSession | undefined {
-  pruneClosed(performance.now());
-  const item = closedSessions.get(id);
-  return item?.owner === owner ? item : undefined;
-}
-
-function append(session: Session, chunk: Uint8Array): void {
-  if (chunk.length === 0) return;
-  const bytes = chunk.slice();
-  session.queue = session.queue.then(async () => {
-    let offset = 0;
-    while (offset < bytes.length) {
-      const { bytesWritten } = await session.spool.write(bytes, offset, bytes.length - offset, session.written);
-      if (bytesWritten < 1) throw new Error("process output spool made no write progress");
-      offset += bytesWritten; session.written += bytesWritten;
-    }
-  }).catch(error => {
-    session.captureError = `process output capture failed: ${String(error)}`;
-    stopSession(session, "cancelled");
-  });
-}
-
-export async function startSession(input: {
-  command: string; cwd: string; tty: boolean; timeoutMs: number; spoolDir: string; source: ProcessSource; owner?: string;
-  artifactObserver?: CommandArtifactObserver;
-  /** Internal literal launch capability; model exec_command remains a Bash contract. */
-  argv?: readonly string[];
-}): Promise<Session | { error: string }> {
-  if (sessions.size >= MAX_SESSIONS) {
-    const list = runningSessions(input.owner).map((s) => s.id).join(", ");
-    return { error: `refused: managed process capacity ${MAX_SESSIONS} reached; your handles: ${list || "none"}; finish or cancel an owned process before starting another` };
-  }
-  if (!hooked) { hooked = true; process.once("exit", killAllExecSessions); }
-  await mkdir(input.spoolDir, { recursive: true });
-  const spoolPath = join(input.spoolDir, `.${randomUUID()}.session`);
-  const spool = await open(spoolPath, "w+", 0o600);
-  const env = commandEnvironment(process.env, xenoBinDir(configDir()));
-  let resolveExit!: () => void;
-  const exited = new Promise<void>((resolve) => { resolveExit = resolve; });
-  const session = {
-    id: nextId++, ...(input.owner === undefined ? {} : { owner: input.owner }), command: input.command, cwd: input.cwd, tty: input.tty, source: input.source, started: performance.now(),
-    spool, spoolPath, queue: Promise.resolve(), operations: Promise.resolve(), written: 0, read: 0,
-    exit: null, timeoutMs: input.timeoutMs, exited, drained: Promise.resolve(),
-    ...(input.artifactObserver ? { artifactObserver: input.artifactObserver } : {}),
-  } as Omit<Session, "pid" | "write" | "kill" | "timer"> as Session;
-
-  try { if (input.tty) {
-    // A PTY: the line discipline turns ^C into SIGINT for the foreground job,
-    // which is what an interactive program expects. Bun ships the PTY.
-    let drained!: () => void;
-    session.drained = new Promise<void>(resolve => { drained = resolve; });
-    const proc = Bun.spawn(input.argv ? [...input.argv] : commandArgv(input.command), {
-      cwd: input.cwd, env,
-      terminal: { cols: 120, rows: 40, data: (_terminal, data) => append(session, data),
-        // This callback closes the stream; only proc.exited supplies the command exit.
-        exit: (_terminal, code) => { if (code !== 0) session.captureError = "PTY output stream closed with a read error"; drained(); } },
-    });
-    session.pid = proc.pid;
-    session.alive = () => proc.exitCode === null;
-    session.write = (chars) => { proc.terminal?.write(chars); };
-    session.kill = (signal) => killGroup(proc.pid, signal);
-    session.closeCapture = async () => { proc.terminal?.close(); drained(); };
-    void proc.exited.then((code) => { session.exit = code; resolveExit(); void drainExitedSession(session); });
-  } else {
-    const proc = Bun.spawn(input.argv ? [...input.argv] : commandArgv(input.command), {
-      cwd: input.cwd, env, stdin: "pipe", stdout: "pipe", stderr: "pipe", detached: true,
-    });
-    session.pid = proc.pid;
-    session.alive = () => proc.exitCode === null;
-    // Without a terminal there is no line discipline, so the two control
-    // characters a model reaches for are mapped by hand: ^C interrupts the
-    // group, ^D closes stdin.
-    session.write = (chars) => {
-      for (const part of chars.split(/(\u0003|\u0004)/)) {
-        if (part === "\u0003") killGroup(proc.pid, "SIGINT");
-        else if (part === "\u0004") void proc.stdin.end();
-        else if (part.length > 0) { proc.stdin.write(part); void proc.stdin.flush(); }
-      }
-    };
-    session.kill = (signal) => killGroup(proc.pid, signal);
-    const readers: ReadableStreamDefaultReader<Uint8Array>[] = [];
-    const pump = async (stream: ReadableStream<Uint8Array>) => {
-      const reader = stream.getReader();
-      readers.push(reader);
-      try { for (;;) { const { done, value } = await reader.read(); if (done) return; append(session, value); await session.queue; } }
-      catch (error) { session.captureError = `process output stream failed: ${String(error)}`; }
-      finally { reader.releaseLock(); }
-    };
-    session.closeCapture = async () => { await Promise.allSettled(readers.map(reader => reader.cancel())); };
-    session.drained = Promise.all([pump(proc.stdout), pump(proc.stderr)]).then(() => {});
-    void proc.exited.then((code) => { session.exit = code; resolveExit(); void drainExitedSession(session); });
-  } } catch (error) {
-    await spool.close(); await rm(spoolPath, { force: true });
-    const os = (error as { code?: string }).code;
-    throw new ToolFault(os === "ENOENT" || os === "ENOTDIR" ? "environment_missing" : os === "EACCES" || os === "EPERM" ? "permission_denied" : "execution_failed", String(error), NOT_STARTED);
-  }
-  session.timer = setTimeout(() => stopSession(session, "timeout"), input.timeoutMs);
-  sessions.set(session.id, session);
-  return session;
-}
-
-export function findSession(id: number, owner?: string): Session | undefined {
-  const session = sessions.get(id);
-  return session?.owner === owner ? session : undefined;
-}
-
-function stopSession(session: Session, reason: "timeout" | "cancelled"): void {
-  if (session.stopped !== undefined || session.exit !== null) return;
-  session.stopped = reason;
-  clearTimeout(session.timer);
-  session.kill("SIGTERM");
-  session.escalation = setTimeout(() => session.kill("SIGKILL"), COMMAND_TERMINATION_GRACE_MS);
-}
-
-/** A managed group is owned for its foreground command lifetime, never silently detached. */
-function drainExitedSession(session: Session): Promise<void> {
-  // Once only: a later artifact retry must not signal a potentially reused PID/group.
-  session.finishing ??= (async () => {
-    try { await finishCapture(session); } catch (error) { session.captureError = `output drain failed: ${String(error)}`; }
-    // The exit owns this observation even if no model polls until files change again.
-    if (session.artifactObserver && session.exit !== null) {
-      session.artifacts = session.artifactObserver.finish({ exit: session.exit,
-        ...(session.stopped ? { stopped: session.stopped } : {}), capture: session.captureError ? "partial" : "complete" });
-      await session.artifacts;
-    }
-  })();
-  return session.finishing;
-}
-async function finishCapture(session: Session): Promise<void> {
-  session.kill("SIGKILL");
-  clearTimeout(session.escalation);
-  clearTimeout(session.timer);
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const deadline = new Promise<false>(resolve => { timer = setTimeout(() => resolve(false), EXIT_DRAIN_MS); });
-  const complete = await Promise.race([session.drained.then(() => true), deadline]);
-  clearTimeout(timer);
-  if (!complete) {
-    session.captureError = "output drain deadline reached; a descendant may have escaped the owned group";
-    await session.closeCapture();
-  }
-  await session.queue;
-}
-
-/** Wait for exit, the yield deadline or cancellation, whichever is first. */
-async function waitSession(session: Session, yieldMs: number, signal?: AbortSignal): Promise<void> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let onAbort: (() => void) | undefined;
-  const deadline = new Promise<void>((resolve) => { timer = setTimeout(resolve, yieldMs); });
-  const aborted = new Promise<void>((resolve) => {
-    if (signal === undefined) return;
-    onAbort = resolve;
-    if (signal.aborted) resolve();
-    else signal.addEventListener("abort", onAbort, { once: true });
-  });
-  try { await Promise.race([session.exited, deadline, aborted]); }
-  finally { clearTimeout(timer); if (onAbort) signal?.removeEventListener("abort", onAbort); }
-  if (signal?.aborted) stopSession(session, "cancelled");
-  if (session.stopped !== undefined) await session.exited;
-  if (session.exit !== null) await drainExitedSession(session);
-  await session.queue;
-}
-
-export interface ObservationWait {
-  /** Steering releases this observation wait without cancelling the owned command. */
-  wake?: AbortSignal;
-  onWaiting?: (active: boolean) => void;
-  /** One window; output is delivered at a window's end, never as it arrives. */
-  windowMs: number;
-}
-
-/**
- * OMP's job owner pattern: no paid model turn merely to observe elapsed time.
- * Exit, timeout, cancellation and steering end the wait at once. Output does
- * not: it is collected until the window ends, and a window with nothing new
- * rolls into the next. Waking per byte made a process that prints a warning
- * every few seconds cost one model request per line (session mv4wyiyg-lebu,
- * fix-owned-wait-coalesce-output); Codex collects to the deadline the same way.
- */
-async function waitForObservation(session: Session, signal: AbortSignal | undefined, wait: ObservationWait): Promise<void> {
-  await session.queue;
-  let interrupt!: () => void;
-  const interrupted = new Promise<void>(resolve => { interrupt = resolve; });
-  signal?.addEventListener("abort", interrupt, { once: true });
-  wait.wake?.addEventListener("abort", interrupt, { once: true });
-  const ended = () => session.exit !== null || signal?.aborted === true || wait.wake?.aborted === true;
-  const pending = !ended();
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  try {
-    if (pending) {
-      wait.onWaiting?.(true);
-      while (!ended()) {
-        const deadline = new Promise<void>(resolve => { timer = setTimeout(resolve, wait.windowMs); });
-        await Promise.race([session.exited, interrupted, deadline]);
-        clearTimeout(timer);
-        await session.queue;
-        if (session.written > session.read) break;
-      }
-    }
-  } finally {
-    clearTimeout(timer);
-    signal?.removeEventListener("abort", interrupt);
-    wait.wake?.removeEventListener("abort", interrupt);
-    if (pending) wait.onWaiting?.(false);
-  }
-  if (signal?.aborted) stopSession(session, "cancelled");
-  if (session.stopped !== undefined) await session.exited;
-  if (session.exit !== null) await drainExitedSession(session);
-  await session.queue;
-}
-
-/**
- * Bytes printed since the previous call, archived in full. A session whose
- * exit has now been reported is closed.
- */
-async function takeOutput(session: Session, outputStore: string, previewBytes: number): Promise<TakenOutput> {
-  if (session.exit !== null) await drainExitedSession(session);
-  await session.queue;
-  if (session.exit !== null) await drainExitedSession(session);
-  const from = session.read, to = session.written;
-  // Snapshot exit before async archival: a later exit belongs to the next observation.
-  const exit = session.exit;
-  const path = session.spoolPath;
-  async function* range(start: number): AsyncGenerator<Uint8Array> {
-    if (to <= start) return;
-    for await (const chunk of createReadStream(path, { start, end: to - 1 })) yield chunk as Uint8Array;
-  }
-  const stored = await archiveObservation(outputStore, range(from), previewBytes);
-  const full = exit === null ? undefined : from === 0 ? stored : await archiveObservation(outputStore, range(0), previewBytes);
-  const artifacts = exit === null ? session.artifactObserver?.pending : await session.artifacts;
-  // Neither the cursor nor the handle advances until every referenced artifact exists.
-  session.read = to;
-  const taken: TakenOutput = { stored, exit, ...(session.stopped ? { stopped: session.stopped } : {}), wallMs: performance.now() - session.started,
-    receipt: processReceipt({ session: session.id, source: session.source, exit, output: stored.ref, start: from, end: to,
-      ...(session.stopped ? { stopped: session.stopped } : {}), ...(full ? { fullOutput: full.ref } : {}),
-      ...(artifacts ? { artifacts } : {}),
-      ...(session.captureError ? { capture: "partial" } : exit !== null ? { capture: "complete" } : {}) }) };
-  if (exit !== null) {
-    clearTimeout(session.timer);
-    clearTimeout(session.escalation);
-    sessions.delete(session.id);
-    session.final = taken;
-    closedSessions.set(session.id, { ...(session.owner === undefined ? {} : { owner: session.owner }), id: session.id,
-      endedAt: performance.now(), receipt: taken.receipt });
-    pruneClosed(performance.now());
-    await session.closeCapture();
-    await session.spool.close().catch(() => {});
-    await rm(path, { force: true });
-  }
-  return taken;
-}
-
-/**
- * Input made only of Ctrl-C / Ctrl-D. Sent to a process that has already
- * exited, it asks for something the exit already did (stop, end of input), so
- * it is answered as a poll rather than refused -- otherwise the exit and the
- * unread tail wait for a second call the model may never make (ticket session
- * mv4ugd29, write-stdin-exited card).
- */
-export function isControlInput(chars: string): boolean {
-  return chars.length > 0 && /^[\u0003\u0004]+$/.test(chars);
-}
-
-/** One lease covers stdin, waiting, archival and cursor commit; cancellation can interrupt a queued wait. */
-export async function pollSession(session: Session, outputStore: string, previewBytes: number, yieldMs: number,
-  chars = "", signal?: AbortSignal, wait?: ObservationWait): Promise<TakenOutput> {
-  const cancel = () => stopSession(session, "cancelled");
-  if (signal?.aborted) cancel(); else signal?.addEventListener("abort", cancel, { once: true });
-  const result = session.operations.then(async () => {
-    if (session.final) {
-      if (chars.length > 0 && !isControlInput(chars)) throw new ToolFault("not_found", "process is closed; input was not sent", NOT_STARTED);
-      return { ...session.final, receipt: { ...session.final.receipt, replayed: true } };
-    }
-    // An exit not yet reported is still delivered with any late input: the
-    // input is never written, but the exit and unread output are not withheld.
-    let unsent: TakenOutput["unsent"];
-    if (chars.length > 0) {
-      if (session.exit !== null) unsent = isControlInput(chars) ? "control" : "refused";
-      else session.write(chars);
-    }
-    if (chars.length === 0 && wait) await waitForObservation(session, signal, wait);
-    else await waitSession(session, yieldMs, signal);
-    const taken = await takeOutput(session, outputStore, previewBytes);
-    return unsent === undefined ? taken : { ...taken, unsent };
-  });
-  session.operations = result.catch(() => {});
-  try { return await result; }
-  finally { signal?.removeEventListener("abort", cancel); }
-}
-
-/** Stop only this owner, drain its actual exit and preserve every unread byte (D8). */
-export async function disposeExecSessions(owner: string, outputStore: string, previewBytes: number) {
-  const owned = [...sessions.values()].filter(session => session.owner === owner);
-  const results = await Promise.all(owned.map(async session => {
-    stopSession(session, "cancelled");
-    const output = await pollSession(session, outputStore, previewBytes, 0);
-    if (output.exit === null) throw new Error("disposed process has no exit observation");
-    if (output.receipt.replayed) return null;
-    return { session: session.id, command: session.command, exit: output.exit, output: output.stored.ref, receipt: output.receipt };
-  }));
-  return results.filter(item => item !== null);
-}

package/src/runtime/execution-control.ts

@@ -1,40 +0,0 @@
-/** O.1: the creator owns cancellation and waits for cleanup before admitting another run. */
-export class ExecutionControl {
-  private active: { controller: AbortController; done: Promise<void>; finish: () => void } | null = null;
-
-  begin(parent?: AbortSignal): { signal: AbortSignal; finish: () => void } {
-    if (this.active !== null) throw new Error("this session already has an active execution");
-    const controller = new AbortController();
-    let finish!: () => void;
-    const done = new Promise<void>(resolve => { finish = resolve; });
-    const owned = { controller, done, finish };
-    this.active = owned;
-    const abort = () => controller.abort();
-    parent?.addEventListener("abort", abort, { once: true });
-    if (parent?.aborted) abort();
-    return {
-      signal: controller.signal,
-      finish: () => {
-        parent?.removeEventListener("abort", abort);
-        if (this.active === owned) this.active = null;
-        finish();
-      },
-    };
-  }
-
-  cancel(): void { this.active?.controller.abort(); }
-  whenIdle(): Promise<void> { return this.active?.done ?? Promise.resolve(); }
-  get running(): boolean { return this.active !== null; }
-  get signal(): AbortSignal | undefined { return this.active?.controller.signal; }
-}
-
-/** Only for admission waits: an unstarted action has no effect to drain. */
-export async function waitForAdmission<T>(pending: Promise<T>, signal?: AbortSignal): Promise<T | undefined> {
-  if (signal === undefined) return pending;
-  if (signal.aborted) return undefined;
-  let abort!: () => void;
-  const cancelled = new Promise<undefined>(resolve => { abort = () => resolve(undefined); });
-  signal.addEventListener("abort", abort, { once: true });
-  try { return await Promise.race([pending, cancelled]); }
-  finally { signal.removeEventListener("abort", abort); }
-}

package/src/runtime/extension-loader.ts

@@ -1,37 +0,0 @@
-/** Reload local dependency graphs without clearing unrelated process modules. */
-import { dirname, isAbsolute, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-
-export async function loadExtensionFactory(path: string, generation: number): Promise<unknown> {
-  // Pi uses a fresh jiti loader with moduleCache:false. Bun can rebuild the
-  // local graph itself, so this adds no production loader dependency (D13).
-  const result = await Bun.build({ entrypoints: [path], target: "bun", format: "esm",
-    plugins: [{ name: "extension-local-graph", setup(build) {
-      build.onResolve({ filter: /^[^./]/ }, args => {
-        if (isAbsolute(args.path) || args.path.startsWith("node:") || args.path.startsWith("bun:")) return undefined;
-        // A package belongs to the extension's installation. Never auto-install
-        // dependencies or resolve them against the current workspace.
-        return { path: Bun.resolveSync(args.path, dirname(args.importer || path)), external: true };
-      });
-      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async args => {
-        const url = pathToFileURL(args.path).href;
-        const transpiler = new Bun.Transpiler({ loader: /tsx$/.test(args.path) ? "tsx" : /jsx$/.test(args.path) ? "jsx" : "ts",
-          define: { "import.meta.url": JSON.stringify(url), "import.meta.dir": JSON.stringify(dirname(args.path)),
-            "import.meta.dirname": JSON.stringify(dirname(args.path)), "import.meta.path": JSON.stringify(args.path),
-            "import.meta.filename": JSON.stringify(args.path), "import.meta.main": "false" } });
-        return { contents: transpiler.transformSync(await Bun.file(args.path).text()), loader: "js" };
-      });
-    } }] });
-  if (!result.success || !result.outputs[0]) throw new Error(result.logs.map(log => log.message).join("\n") || "Extension build failed");
-  const code = await result.outputs[0].text() + `\n//# sourceURL=${pathToFileURL(path).href}?generation=${generation}\n`;
-  // A fresh file gives Bun an ordinary module identity without its data-URL
-  // path-length limit. The original import.meta locations were frozen above.
-  const staging = await mkdtemp(join(tmpdir(), "xeno-extension-module-"));
-  try {
-    const entry = join(staging, "extension.mjs"); await Bun.write(entry, code);
-    const module: { default?: unknown } = await import(pathToFileURL(entry).href);
-    return module.default;
-  } finally { await rm(staging, { recursive: true, force: true }); }
-}

package/src/runtime/extension-ui.ts

@@ -1,47 +0,0 @@
-/**
- * What an extension may do to the interactive UI (D20). The runtime never
- * constructs a terminal; the app supplies an implementation.
- *
- * Deliberately small. Extensions describe content (`render(width): string[]`
- * ANSI lines) and ask for decisions (select / confirm / input); they do not
- * own focus, overlays or the composer. That keeps a misbehaving extension
- * from wedging input, and keeps the UI framework replaceable without
- * breaking extensions again.
- */
-import type { Theme } from "../core/theme.ts";
-
-/** A block of ANSI lines that may depend on width. */
-export interface ExtensionComponent { render(width: number): string[]; dispose?(): void }
-
-export interface ExtensionTheme extends Theme {
-  fg(color: string, text: string): string; bg(color: string, text: string): string;
-  bold(text: string): string; italic(text: string): string; underline(text: string): string; dim(text: string): string; inverse(text: string): string; strikethrough(text: string): string;
-}
-
-export interface DialogOptions { signal?: AbortSignal; timeout?: number }
-
-export interface ExtensionUI {
-  select(title: string, options: string[], opts?: DialogOptions): Promise<string | undefined>;
-  confirm(title: string, message: string, opts?: DialogOptions): Promise<boolean>;
-  input(title: string, placeholder?: string, opts?: DialogOptions): Promise<string | undefined>;
-  /** Read-only block in a dialog; resolves when the user closes it. */
-  show(title: string, component: ExtensionComponent): Promise<void>;
-  notify(message: string, type?: "info" | "warning" | "error"): void;
-  setStatus(key: string, text: string | undefined): void;
-  /** Lines shown above the composer, keyed so an extension can replace or clear its own. */
-  setWidget(key: string, lines: string[] | undefined): void;
-  setWorkingMessage(message?: string): void;
-  setHiddenThinkingLabel(label?: string): void;
-  setTitle(title: string): void;
-  getEditorText(): string; setEditorText(text: string): void; pasteToEditor(text: string): void;
-  readonly theme: ExtensionTheme;
-  getToolsExpanded(): boolean; setToolsExpanded(expanded: boolean): void;
-}
-
-/** Headless extensions can notify; interactive requests fail explicitly. */
-export function headlessUI(notify: ExtensionUI["notify"]): ExtensionUI {
-  return new Proxy({ notify }, { get(target, key) {
-    if (key === "notify") return target.notify;
-    return () => { throw new Error("Extension UI requires an interactive terminal; check ctx.hasUI"); };
-  } }) as ExtensionUI;
-}