apexrest 0.4.0-beta.1

package/dist/runtime/chunk-RF4XQO6I.mjs

@@ -0,0 +1,13 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  browserInstructions,
+  externalBrowserCommand,
+  openVerificationBrowser
+} from "./chunk-QLRGI23I.mjs";
+import "./chunk-2SZCZZ3J.mjs";
+import "./chunk-IPU64TJI.mjs";
+export {
+  browserInstructions,
+  externalBrowserCommand,
+  openVerificationBrowser
+};

package/dist/runtime/chunk-VPCUV5QA.mjs

@@ -0,0 +1,237 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  recordedExecutionMode,
+  resolveWorkRequest,
+  teamMessageSchema,
+  teamStartSchema
+} from "./chunk-QLRGI23I.mjs";
+import {
+  external_exports,
+  parse,
+  requireTrust
+} from "./chunk-2SZCZZ3J.mjs";
+import {
+  Fault,
+  canonical,
+  contained,
+  exists,
+  hash,
+  hashFile,
+  readJson,
+  withLock,
+  writeJson
+} from "./chunk-IPU64TJI.mjs";
+
+// packages/core/src/team-source.ts
+import path from "node:path";
+import { readdir, readlink } from "node:fs/promises";
+async function teamSourceDigest(root) {
+  const files = {};
+  let count = 0;
+  const walk = async (relative) => {
+    for (const entry of await readdir(path.join(root, relative), { withFileTypes: true })) {
+      if ([".git", ".apexrest", "node_modules", ".DS_Store"].includes(entry.name)) continue;
+      const name = path.join(relative, entry.name), file = path.join(root, name);
+      if (++count > 2e4)
+        throw new Fault("TEAM_SOURCE_LIMIT", "The team source inventory exceeds 20000 entries.", 2);
+      if (entry.isDirectory()) await walk(name);
+      else if (entry.isSymbolicLink()) files[name] = "link:" + await readlink(file);
+      else if (entry.isFile()) files[name] = await hashFile(file);
+      else throw new Fault("TEAM_SOURCE_TYPE", "The team workspace contains an unsupported special file.", 2);
+    }
+  };
+  await walk("");
+  return hash(canonical(files));
+}
+
+// packages/core/src/team.ts
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readdir as readdir2 } from "node:fs/promises";
+var teamActive = /* @__PURE__ */ new Set(["queued", "running", "cancelling"]);
+var teamRuntime = () => path2.join(path2.dirname(fileURLToPath(import.meta.url)), "apexrest.mjs");
+function currentSessionHandoff(state) {
+  return {
+    teamId: state.id,
+    executionMode: "single",
+    executionHost: "current_session",
+    browserMode: state.browserMode ?? "codex",
+    status: state.status,
+    nextAction: state.status !== "current_session" ? "This request has ended. Inspect its recorded status; do not resume it automatically." : "Implement and verify directly in this Codex chat using its context/model. No new agents, App Server, team polling or automatic panel. " + (state.sandbox === "read-only" ? "This request is read-only; do not edit files. " : "") + "Keep host permissions and deployment safeguards. This receipt is not completion; report results and handle steering here."
+  };
+}
+var TeamService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  async directory(id) {
+    parse(external_exports.uuid(), id);
+    return contained(this.ctx.root, ".apexrest/teams/" + id);
+  }
+  async start(input, id = randomUUID()) {
+    await requireTrust(this.ctx.root);
+    if (process.env.APEXREST_TEAM_WORKER === "1")
+      throw new Fault("TEAM_RECURSION", "Team workers cannot create another team.", 2);
+    const request = await resolveWorkRequest(this.ctx.root, parse(teamStartSchema, input));
+    const root = await this.directory(id);
+    if (await exists(path2.join(root, "request.json")))
+      throw new Fault(
+        "TEAM_ALREADY_STARTED",
+        "This team request already exists; inspect its status.",
+        5,
+        "conflict"
+      );
+    await writeJson(path2.join(root, "request.json"), {
+      ...request,
+      project: this.ctx.root,
+      multiAgentEnabled: request.executionMode === "team"
+    });
+    const state = {
+      id,
+      executionMode: request.executionMode,
+      executionHost: request.executionMode === "single" ? "current_session" : "worker",
+      sandbox: request.sandbox,
+      browserMode: request.browserMode,
+      status: request.executionMode === "single" ? "current_session" : "queued",
+      phase: "queued",
+      revision: 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      members: [],
+      messages: [],
+      result: "",
+      diagnostics: [],
+      reviews: [],
+      qa: []
+    };
+    await writeJson(path2.join(root, "state.json"), state);
+    if (state.executionHost === "current_session") return currentSessionHandoff(state);
+    const worker = spawn(process.execPath, [teamRuntime(), "--team-worker", this.ctx.root, id], {
+      cwd: this.ctx.root,
+      env: process.env,
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    try {
+      await new Promise((resolve, reject) => {
+        worker.once("spawn", resolve);
+        worker.once("error", reject);
+      });
+      worker.unref();
+    } catch {
+      const state2 = await this.status(id);
+      await writeJson(path2.join(root, "state.json"), {
+        ...state2,
+        status: "blocked",
+        diagnostics: ["Team worker could not start."]
+      });
+      throw new Fault("TEAM_START_FAILED", "Team worker could not start.", 3, "blocked");
+    }
+    return {
+      teamId: id,
+      executionHost: "worker",
+      executionMode: request.executionMode,
+      browserMode: request.browserMode,
+      status: "queued",
+      nextAction: "Use team status for progress and verification evidence; team message sends task updates; team cancel requests a stop."
+    };
+  }
+  async status(id) {
+    const state = await readJson(path2.join(await this.directory(id), "state.json"));
+    state.executionMode = recordedExecutionMode(state);
+    if (teamActive.has(state.status) && Date.parse(state.updatedAt) + 6e4 < Date.now())
+      return {
+        ...state,
+        status: "outcome_unknown",
+        diagnostics: [
+          ...state.diagnostics,
+          "Worker heartbeat expired. Inspect changes before starting another team."
+        ]
+      };
+    return state;
+  }
+  async snapshot(id) {
+    const state = await this.status(id);
+    const single = state.executionMode === "single";
+    if (state.status === "completed" && (single ? state.completedDigest : state.approvedDigest) !== await teamSourceDigest(this.ctx.root)) {
+      state.status = single ? "result_stale" : "review_stale";
+      state.diagnostics.push(
+        single ? "Project files changed after verification. Verify the new source." : "Project files changed after approval. Run the full review cycle for the new source."
+      );
+    }
+    return {
+      ...state,
+      observations: state.observations?.slice(-8).map((entry) => ({ ...entry, detail: entry.detail.slice(0, 200) })),
+      result: state.result.slice(0, 4e3),
+      members: state.members.map((m) => ({ ...m, result: m.result.slice(-800) })),
+      messages: state.messages.slice(-10).map((m) => ({ ...m, text: m.text.slice(0, 160) })),
+      reviews: state.reviews.slice(-6).map((r) => ({
+        ...r,
+        report: {
+          ...r.report,
+          summary: r.report.summary.slice(0, 400),
+          findings: r.report.findings.slice(0, 3).map((f) => f.slice(0, 200))
+        }
+      })),
+      qa: state.qa.slice(-3).map((q) => ({
+        ...q,
+        report: {
+          ...q.report,
+          summary: q.report.summary.slice(0, 400),
+          checks: q.report.checks.slice(0, 4).map((c) => ({ ...c, name: c.name.slice(0, 100), evidence: c.evidence.slice(0, 200) }))
+        }
+      })),
+      verification: (state.verification ?? []).slice(-3).map((v) => ({
+        ...v,
+        report: {
+          ...v.report,
+          summary: v.report.summary.slice(0, 400),
+          checks: v.report.checks.slice(0, 4).map((c) => ({ ...c, name: c.name.slice(0, 100), evidence: c.evidence.slice(0, 200) }))
+        }
+      })),
+      fullReport: ".apexrest/teams/" + id + "/state.json"
+    };
+  }
+  async message(id, message) {
+    await requireTrust(this.ctx.root);
+    parse(teamMessageSchema, { id, message });
+    const root = await this.directory(id);
+    return withLock(path2.join(root, "control.lock"), async () => {
+      if (!teamActive.has((await this.status(id)).status))
+        throw new Fault("TEAM_FINISHED", "This team has ended; its result remains available.", 5, "conflict");
+      const queue = await exists(path2.join(root, "inbox")) ? await readdir2(path2.join(root, "inbox")) : [];
+      if (queue.length >= 100)
+        throw new Fault("TEAM_MESSAGE_LIMIT", "This team reached its message limit.", 2);
+      const messageId = randomUUID();
+      await writeJson(await contained(root, "inbox/" + messageId + ".json"), { id: messageId, message });
+      return {
+        teamId: id,
+        messageId,
+        status: "queued",
+        nextAction: "Team status reports delivery. A task change invalidates earlier approvals."
+      };
+    });
+  }
+  async cancel(id) {
+    await requireTrust(this.ctx.root);
+    const root = await this.directory(id);
+    return withLock(path2.join(root, "control.lock"), async () => {
+      if (!teamActive.has((await this.status(id)).status)) return this.snapshot(id);
+      await writeJson(path2.join(root, "cancel.json"), {
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return { teamId: id, status: "cancellation_requested", rollbackConfirmed: false };
+    });
+  }
+};
+
+export {
+  teamSourceDigest,
+  teamActive,
+  teamRuntime,
+  currentSessionHandoff,
+  TeamService
+};

package/dist/runtime/chunk-WMJTK7ZB.mjs

@@ -0,0 +1,201 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  PanelService,
+  panelActionSchema
+} from "./chunk-5GOWABKB.mjs";
+import {
+  teamRuntime
+} from "./chunk-VPCUV5QA.mjs";
+import {
+  parse,
+  resourceRoot
+} from "./chunk-2SZCZZ3J.mjs";
+import {
+  Fault,
+  contained,
+  exists,
+  failure,
+  readJson,
+  withLock,
+  writeJson
+} from "./chunk-IPU64TJI.mjs";
+
+// packages/core/src/panel-server.ts
+import path from "node:path";
+import { createServer } from "node:http";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+function validSession(value) {
+  const s = value;
+  return !!s && Number.isInteger(s.port) && s.port > 0 && s.port < 65536 && typeof s.token === "string" && /^[a-f0-9]{64}$/.test(s.token) && typeof s.project === "string";
+}
+async function panelDocument() {
+  const root = path.join(resourceRoot(), "panel");
+  const [html, css, js] = await Promise.all(
+    ["index.html", "panel.css", "panel.js"].map((file) => readFile(path.join(root, file), "utf8"))
+  );
+  return html.replace('<link rel="stylesheet" href="/panel.css">', () => "<style>" + css + "</style>").replace('<script src="/panel.js" defer></script>', "").replace("</body>", () => "<script>" + js.replaceAll("</script", "<\\/script") + "</script>\n</body>");
+}
+async function startPanelServer(root, idleMs = 36e5) {
+  const token = randomBytes(32).toString("hex");
+  const service = new PanelService(root);
+  let lastRequest = Date.now(), origin = "";
+  const server = createServer(async (req, res) => {
+    res.setHeader("Cache-Control", "no-store");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Referrer-Policy", "no-referrer");
+    res.setHeader(
+      "Content-Security-Policy",
+      "default-src 'self'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self' data:; frame-ancestors 'self'"
+    );
+    const json = (status, data) => {
+      res.writeHead(status, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(data));
+    };
+    try {
+      if (req.headers.host !== origin.slice(7) || req.headers.origin && req.headers.origin !== origin) {
+        json(403, { error: "Origin rejected." });
+        return;
+      }
+      const url = new URL(req.url ?? "/", origin);
+      const assets = {
+        "/": ["index.html", "text/html; charset=utf-8"],
+        "/panel.css": ["panel.css", "text/css; charset=utf-8"],
+        "/panel.js": ["panel.js", "text/javascript; charset=utf-8"]
+      };
+      if (req.method === "GET" && assets[url.pathname]) {
+        const [file, type] = assets[url.pathname];
+        res.writeHead(200, { "Content-Type": type });
+        res.end(await readFile(path.join(resourceRoot(), "panel", file)));
+        return;
+      }
+      const supplied = Buffer.from(String(req.headers.authorization ?? "").replace(/^Bearer /, ""));
+      if (supplied.length !== token.length || !timingSafeEqual(supplied, Buffer.from(token))) {
+        json(401, { error: "Open this panel from Codex to authorize the local session." });
+        return;
+      }
+      lastRequest = Date.now();
+      if (req.method === "GET" && url.pathname === "/health") {
+        json(200, { project: root });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/status") {
+        json(200, await service.snapshot(url.searchParams.get("team") ?? void 0));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/action") {
+        if (req.headers["content-type"] !== "application/json") {
+          json(415, { error: "Expected JSON." });
+          return;
+        }
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of req) {
+          bytes += chunk.length;
+          if (bytes > 32768) {
+            json(413, { error: "Request too large." });
+            return;
+          }
+          chunks.push(chunk);
+        }
+        const { action } = parse(panelActionSchema, {
+          action: JSON.parse(Buffer.concat(chunks).toString("utf8"))
+        });
+        json(200, await service.act(action));
+        return;
+      }
+      json(404, { error: "Not found." });
+    } catch (error) {
+      json(400, failure("panel", error));
+    }
+  });
+  server.requestTimeout = 15e3;
+  server.headersTimeout = 1e4;
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Panel could not bind localhost.");
+  origin = `http://127.0.0.1:${address.port}`;
+  const timer = setInterval(
+    () => {
+      if (Date.now() - lastRequest > idleMs) void close();
+    },
+    Math.min(idleMs, 6e4)
+  );
+  const close = () => {
+    clearInterval(timer);
+    server.closeIdleConnections();
+    return new Promise((resolve) => server.close(() => resolve()));
+  };
+  return {
+    session: { port: address.port, token, project: root, pid: process.pid },
+    close
+  };
+}
+async function servePanel(root) {
+  const handle = await startPanelServer(root);
+  await writeJson(await contained(root, ".apexrest/panel/session.json"), handle.session);
+  process.once("SIGTERM", () => {
+    void handle.close();
+  });
+  process.once("SIGINT", () => {
+    void handle.close();
+  });
+}
+async function openPanel(root) {
+  const file = await contained(root, ".apexrest/panel/session.json");
+  const read = async () => {
+    if (!await exists(file)) return null;
+    const session = await readJson(file).catch(() => null);
+    if (!validSession(session) || session.project !== root) return null;
+    try {
+      const response = await fetch(`http://127.0.0.1:${session.port}/health`, {
+        headers: { Authorization: "Bearer " + session.token },
+        redirect: "error",
+        signal: AbortSignal.timeout(1e3)
+      });
+      if (response.ok && (await response.json()).project === root) return session;
+    } catch {
+    }
+    return null;
+  };
+  return withLock(await contained(root, ".apexrest/panel/start.lock"), async () => {
+    let session = await read();
+    if (!session) {
+      const worker = spawn(process.execPath, [teamRuntime(), "--panel-worker", root], {
+        cwd: root,
+        env: process.env,
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      });
+      await new Promise((resolve, reject) => {
+        worker.once("spawn", resolve);
+        worker.once("error", reject);
+      });
+      worker.unref();
+      for (let i = 0; i < 50 && !session; i++) {
+        await delay(100);
+        session = await read();
+      }
+      if (!session)
+        throw new Fault("PANEL_START_FAILED", "The local panel did not become ready.", 3, "blocked");
+    }
+    return {
+      project: root,
+      url: `http://127.0.0.1:${session.port}/#session=${session.token}`,
+      nextAction: "Open this URL in the Codex in-app browser using open_in_codex when available. Codex CLI: apexrest panel tui --project PATH."
+    };
+  });
+}
+
+export {
+  panelDocument,
+  startPanelServer,
+  servePanel,
+  openPanel
+};

package/dist/runtime/chunk-WROK6RQH.mjs

@@ -0,0 +1,200 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  clip,
+  paint,
+  wrap
+} from "./chunk-ZQFJ2BNZ.mjs";
+import {
+  teamLabel
+} from "./chunk-GFRSRK3K.mjs";
+import {
+  PanelService
+} from "./chunk-5GOWABKB.mjs";
+import "./chunk-VPCUV5QA.mjs";
+import "./chunk-QLRGI23I.mjs";
+import "./chunk-Z6Y72JVG.mjs";
+import "./chunk-2SZCZZ3J.mjs";
+import {
+  Fault
+} from "./chunk-IPU64TJI.mjs";
+
+// packages/cli/src/panel-tui.ts
+import { emitKeypressEvents } from "node:readline";
+function panelLines(data, tab) {
+  const team = data.team;
+  if (tab === 3)
+    return [
+      `Database network: ${data.sqlcl.databaseTransport === "ords" ? "ORDS HTTP(S)" : "Direct Oracle listener"}`,
+      `SQLcl execution: ${data.sqlcl.mode.toUpperCase()} \xB7 restriction ${data.sqlcl.mcpRestrictLevel}`,
+      `Trusted: ${data.trusted} \xB7 configured: ${data.configured}`,
+      "Future work defaults: " + JSON.stringify(data.preferences),
+      "Model selection: Auto (task complexity and implementation repair results; no manual override).",
+      ...JSON.stringify(
+        {
+          project: data.configuration,
+          toolchain: data.toolchain,
+          connections: data.connections,
+          authorization: data.permissions
+        },
+        null,
+        2
+      ).split("\n")
+    ];
+  if (tab === 2)
+    return [
+      "APEX OPERATIONS",
+      ...data.jobs.flatMap((job) => [`${job.operation} \xB7 ${job.status}`, job.summary]),
+      ...data.jobs.length ? [] : ["No operation jobs recorded."],
+      "",
+      "DEPLOYMENT & IMPORT JOURNAL",
+      ...data.deployments.flatMap((run) => [run.status + " \xB7 " + run.at, run.details]),
+      "",
+      "Commands: apexrest apex validate \xB7 apexrest test unit \xB7 apexrest deploy plan --env NAME --out PATH",
+      "Existing project trust and deployment authorization remain required."
+    ];
+  const lines = [
+    team ? `${team.executionMode === "single" ? "SINGLE AGENT" : "TEAM"} \xB7 ${team.status} \xB7 ${team.phase} \xB7 revision ${team.revision}` : 'No team yet. Use apexrest team start "Task" in Codex.',
+    ""
+  ];
+  if (data.task) lines.push(data.task, "");
+  if (team?.modelPolicy)
+    lines.push("Auto models \xB7 " + team.modelPolicy.complexity + " \xB7 " + team.modelPolicy.reason);
+  if (team?.limits) lines.push("Task time limit: " + team.limits.timeoutSeconds + " seconds");
+  if (team?.members.length)
+    lines.push("Tokens are cumulative, including cached input; not a cost estimate.", "");
+  for (const member of team?.members ?? [])
+    lines.push(
+      `${teamLabel(member.role)} \xB7 ${member.status}`,
+      member.currentAction?.title ?? "No active tool reported",
+      [
+        member.configuration?.model,
+        member.configuration?.reasoningEffort,
+        member.configuration?.sandbox,
+        member.totalTokens == null ? "" : member.totalTokens + " tokens"
+      ].filter(Boolean).join(" \xB7 "),
+      member.selection ? "Auto \xB7 " + member.selection.tier + " \xB7 " + member.selection.reason : "",
+      member.tokenUsage ? [
+        member.tokenUsage.inputTokens == null ? "" : "Input " + member.tokenUsage.inputTokens,
+        member.tokenUsage.cachedInputTokens == null ? "" : "Cached input " + member.tokenUsage.cachedInputTokens,
+        member.tokenUsage.outputTokens == null ? "" : "Output " + member.tokenUsage.outputTokens,
+        member.tokenUsage.reasoningOutputTokens == null ? "" : "Reasoning output " + member.tokenUsage.reasoningOutputTokens
+      ].filter(Boolean).join(" \xB7 ") : "",
+      ""
+    );
+  if (tab === 1) {
+    lines.push(
+      (team?.executionMode ?? data.preferences.executionMode) === "single" ? "AGENT VERIFICATION" : "MANDATORY REVIEWS"
+    );
+    for (const v of team?.verification ?? [])
+      lines.push(
+        `${v.report.decision} \xB7 revision ${v.revision}`,
+        v.report.summary,
+        ...v.report.checks.map((c) => `${c.status} \xB7 ${c.name}: ${c.evidence}`)
+      );
+    for (const r of team?.reviews ?? [])
+      lines.push(
+        `${r.phase}: ${r.report.decision} \xB7 revision ${r.revision}`,
+        r.report.summary,
+        ...r.report.findings
+      );
+    for (const q of team?.qa ?? [])
+      lines.push(
+        `QA: ${q.report.decision} \xB7 revision ${q.revision}`,
+        q.report.summary,
+        ...q.report.checks.map((c) => `${c.status} \xB7 ${c.name}: ${c.evidence}`)
+      );
+    lines.push("", "PEER MESSAGES");
+    for (const m of team?.messages ?? [])
+      lines.push(`${teamLabel(m.from)} \u2192 ${teamLabel(m.to)} \xB7 ${m.status}`, m.text);
+  } else {
+    lines.push("WORKING CHANGES", ...data.changes.files, "", "OBSERVED AGENT STEPS");
+    for (const o of [...team?.observations ?? []].reverse())
+      lines.push(`${teamLabel(o.role)} \xB7 ${o.kind}`, o.detail);
+  }
+  if (team?.diagnostics.length) lines.push("", ...team.diagnostics);
+  return lines;
+}
+async function runPanelTui(root) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || process.env.TERM === "dumb")
+    throw new Fault("TTY_REQUIRED", "Use an interactive Codex terminal, or apexrest panel status --json.", 2);
+  const service = new PanelService(root), output = process.stdout, input = process.stdin;
+  let data, error = "", tab = 0, offset = 0, refreshing = false, stopped = false;
+  const color = !process.env.NO_COLOR;
+  const draw = () => {
+    if (stopped) return;
+    const width = Math.max(20, output.columns || 80), height = Math.max(7, output.rows || 24);
+    const body = data ? panelLines(data, tab).flatMap((line) => wrap(line, width - 2)) : [];
+    offset = Math.max(0, Math.min(offset, Math.max(0, body.length - (height - 6))));
+    const lines = [
+      paint(" APEXREST \xB7 Development panel", "accent", color),
+      clip(" " + root, width),
+      ["Overview", "Agent team", "APEX operations", "Settings"].map((name, i) => `${i + 1} ${i === tab ? "[" + name + "]" : name}`).join("  "),
+      error ? "Disconnected \xB7 " + error : data ? "Live \xB7 " + new Date(data.updatedAt).toLocaleTimeString() : "Connecting\u2026",
+      ...body.slice(offset, offset + height - 6),
+      "1\u20134 / \u2190\u2192 views \xB7 \u2191\u2193 scroll \xB7 r refresh \xB7 q exit | Actions: apexrest panel action --help"
+    ];
+    output.write("\x1B[H\x1B[2J" + lines.map((line, i) => i === 0 ? line : clip(line, width)).join("\r\n"));
+  };
+  const refresh = async () => {
+    if (refreshing || stopped) return;
+    refreshing = true;
+    try {
+      data = await service.snapshot();
+      error = "";
+    } catch (e) {
+      error = e instanceof Error ? e.message : String(e);
+    } finally {
+      refreshing = false;
+      draw();
+    }
+  };
+  const wasRaw = input.isRaw;
+  emitKeypressEvents(input);
+  input.setRawMode(true);
+  input.resume();
+  output.write("\x1B[?1049h\x1B[?25l");
+  await new Promise((resolve) => {
+    const close = () => {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+      input.off("keypress", key);
+      output.off("resize", draw);
+      process.off("SIGINT", close);
+      process.off("SIGTERM", close);
+      input.setRawMode(wasRaw);
+      input.pause();
+      output.write("\x1B[?25h\x1B[?1049l");
+      resolve();
+    };
+    const key = (_text, k) => {
+      if (k.name === "q" || k.ctrl && k.name === "c") return close();
+      if (/^[1-4]$/.test(k.name ?? "")) {
+        tab = Number(k.name) - 1;
+        offset = 0;
+      }
+      if (k.name === "right" || k.name === "left") {
+        tab = (tab + (k.name === "right" ? 1 : 3)) % 4;
+        offset = 0;
+      }
+      if (k.name === "up") offset--;
+      if (k.name === "down") offset++;
+      if (k.name === "pageup") offset -= 10;
+      if (k.name === "pagedown") offset += 10;
+      if (k.name === "r") void refresh();
+      else draw();
+    };
+    const timer = setInterval(() => {
+      void refresh();
+    }, 2e3);
+    input.on("keypress", key);
+    output.on("resize", draw);
+    process.once("SIGINT", close);
+    process.once("SIGTERM", close);
+    void refresh();
+  });
+}
+export {
+  panelLines,
+  runPanelTui
+};