@gravitylabsllc/porthole 0.1.0 → 0.2.1

package/src/report.ts

@@ -0,0 +1,285 @@
+// Copyright 2026 Gravity Labs
+// SPDX-License-Identifier: Apache-2.0
+import type { Finding, Trace } from "./trace.js";
+import { frameBudgetMs } from "./trace.js";
+
+/**
+ * Lanes a reader should be told were checked and found quiet.
+ *
+ * Every key a lane can raise a finding from has to be listed here, or the
+ * footer ends up contradicting the list above it: a capture with three wedged
+ * HTTP calls printed "quiet: http" directly beneath the warning that named
+ * them, because the lane keyed on `http.failed` alone and a call that never
+ * returns never fails. The two must be added together, so a new lane metric is
+ * only half-added until it appears in this table.
+ */
+const CHECKED: Array<{ label: string; keys: string[] }> = [
+  { label: "http", keys: ["http.failed", "http.stillOpen"] },
+  { label: "db", keys: ["db.onMainThread", "db.stillOpen"] },
+  { label: "main thread", keys: ["mainThread.stalls"] },
+  { label: "frames", keys: ["frames.missed"] },
+  { label: "work", keys: ["work.retries", "work.failures", "work.stillOpen"] },
+  { label: "memory", keys: ["memory.blockingGcMs"] },
+];
+
+const LABEL: Record<Finding["severity"], string> = {
+  error: "ERROR  ",
+  warning: "WARNING",
+  note: "NOTE   ",
+};
+
+// Raw ANSI SGR codes — no dependency, for four escape sequences. Reset is a
+// full SGR reset (`\x1b[0m`) rather than a scoped "un-bold"/"un-dim" code so
+// that wrapping never depends on which attribute was opened.
+const ANSI_RESET = "\x1b[0m";
+const ANSI_RED = "\x1b[31m";
+const ANSI_YELLOW = "\x1b[33m";
+const ANSI_DIM = "\x1b[2m";
+
+const SEVERITY_COLOR: Record<Finding["severity"], string> = {
+  error: ANSI_RED,
+  warning: ANSI_YELLOW,
+  note: ANSI_DIM,
+};
+
+/**
+ * Whether the severity token in a rendered report should carry colour.
+ *
+ * Colour belongs on the TTY path a human reads — never on a pipe, CI, or the
+ * MCP tool result text an agent reads, where escape bytes are just noise a
+ * model has to see past. So this is a question about one output stream, not
+ * a global: `porthole capture` writes its summary to stderr while `porthole
+ * report` writes to stdout, and the two can disagree about whether they are
+ * a terminal (`cmd | less` redirects stdout but leaves stderr a TTY).
+ * Callers pass the stream they are about to write to.
+ *
+ * NO_COLOR (https://no-color.org) is honoured unconditionally when set to
+ * anything, including an empty string — the convention is "the variable is
+ * present", not "the variable is truthy", so this checks `undefined` rather
+ * than falsiness.
+ */
+export function shouldColor(
+  stream: { isTTY?: boolean } = process.stdout,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return Boolean(stream.isTTY) && env.NO_COLOR === undefined;
+}
+
+function colorSeverity(severity: Finding["severity"], color: boolean): string {
+  const label = LABEL[severity];
+  return color ? `${SEVERITY_COLOR[severity]}${label}${ANSI_RESET}` : label;
+}
+
+export interface RenderReportOptions {
+  /**
+   * Colour the severity token. Defaults to false: plain text is the safe
+   * default for every caller that does not explicitly opt in. That default —
+   * not a TTY check inside this function — is what keeps the MCP `findings`
+   * tool's text plain (it does not call this with `color: true`, and never
+   * will; it does not even call this function) and keeps every existing
+   * non-TTY test passing unchanged, by construction rather than by convention.
+   */
+  color?: boolean;
+}
+
+/**
+ * One of the footer counts, saying how many of them never finished.
+ *
+ * The counts deliberately include spans that were still open when the capture
+ * ended — a query that never came back still happened and still cost the wait.
+ * But "40 queries" reads as forty completions to anyone who does not know that,
+ * and this line is the part of the report people quote. The qualifier travels
+ * with the number, the same way `atLeastMs` carries its own. It is left off
+ * entirely when nothing was open, which is almost every run.
+ */
+function counted(trace: Trace, total: string, open: string, noun: string): string {
+  const stillOpen = trace.metrics[open] ?? 0;
+  const suffix = stillOpen > 0 ? ` (${stillOpen} still open)` : "";
+  return `${trace.metrics[total]} ${noun}${suffix}`;
+}
+
+export function renderReport(trace: Trace, options: RenderReportOptions = {}): string {
+  const color = options.color ?? false;
+  const lines: string[] = [];
+  const device = trace.device as Record<string, unknown>;
+  const hz = Number(device.refreshHz) || 60;
+
+  lines.push(
+    [
+      trace.scenario,
+      `${(trace.durationMs / 1000).toFixed(1)}s`,
+      `${device.model ?? "unknown device"} (${Math.round(hz)}Hz)`,
+      trace.app.packageName,
+    ]
+      .filter(Boolean)
+      .join(" · "),
+  );
+  lines.push("");
+
+  if (trace.findings.length === 0) {
+    lines.push("  nothing worth reporting");
+  }
+
+  // Severity order, not grouped by mark. Grouping reads well until the first
+  // marked run, where it drops an ERROR below two WARNINGs and defeats the one
+  // job of a prioritised list. The mark rides along on the line instead.
+  for (const finding of trace.findings) {
+    lines.push(`  ${colorSeverity(finding.severity, color)}  ${finding.title}`);
+    if (finding.during) lines.push(`           during "${finding.during}"`);
+    if (finding.detail) lines.push(`           ${finding.detail}`);
+  }
+
+  const quiet = CHECKED.filter((lane) =>
+    lane.keys.every((key) => (trace.metrics[key] ?? 0) === 0),
+  ).map((lane) => lane.label);
+
+  // Saying what was checked and found clean matters as much as the findings. A
+  // report that only ever lists problems gives no signal that the things it did
+  // not mention were looked at.
+  if (quiet.length > 0) {
+    lines.push("");
+    lines.push(`  quiet: ${quiet.join(", ")}`);
+  }
+
+  lines.push("");
+  lines.push(
+    `  frame budget ${frameBudgetMs(hz)}ms · ` +
+      `${trace.metrics["recompose.total"]} recompositions · ` +
+      `${counted(trace, "http.calls", "http.stillOpen", "calls")} · ` +
+      `${counted(trace, "db.queries", "db.stillOpen", "queries")}`,
+  );
+  if (trace.marks.length > 0) lines.push(`  ${trace.marks.length} marks`);
+  if (trace.driver) lines.push(`  driver: ${trace.driver}`);
+
+  return lines.join("\n") + "\n";
+}
+
+export interface Change {
+  key: string;
+  before: number;
+  after: number;
+  kind: "new" | "regressed" | "improved" | "unchanged";
+}
+
+/** Metrics where a larger number is better. Everything else is the other way. */
+const HIGHER_IS_BETTER = new Set<string>();
+
+/**
+ * Below both of these, a difference is noise.
+ *
+ * Timing metrics move run to run. With only a relative floor a small absolute
+ * change looks enormous; with only an absolute one a large metric never moves
+ * enough. Without both, every run is a regression and the check gets switched
+ * off, which is the real failure mode.
+ */
+const RELATIVE_FLOOR = 0.1;
+const ABSOLUTE_FLOOR = 3;
+
+export function compareMetrics(
+  before: Record<string, number>,
+  after: Record<string, number>,
+): Change[] {
+  const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort();
+
+  return keys.map((key) => {
+    const a = before[key] ?? 0;
+    const b = after[key] ?? 0;
+    const worse = HIGHER_IS_BETTER.has(key) ? b < a : b > a;
+
+    // Categorical, not a drift: the first main-thread query, the first failing
+    // call. No floor should hide one of these.
+    if (a === 0 && b > 0) return { key, before: a, after: b, kind: "new" as const };
+    if (a === b) return { key, before: a, after: b, kind: "unchanged" as const };
+
+    const absolute = Math.abs(b - a);
+    const relative = a === 0 ? 1 : absolute / a;
+    if (absolute < ABSOLUTE_FLOOR || relative < RELATIVE_FLOOR) {
+      return { key, before: a, after: b, kind: "unchanged" as const };
+    }
+
+    return { key, before: a, after: b, kind: worse ? "regressed" : "improved" };
+  });
+}
+
+/** Why two traces cannot honestly be compared, or null if they can. */
+export function comparability(before: Trace, after: Trace): string | null {
+  if (before.scenario !== after.scenario) {
+    return `different scenarios: "${before.scenario}" and "${after.scenario}"`;
+  }
+
+  const a = before.device as Record<string, unknown>;
+  const b = after.device as Record<string, unknown>;
+
+  // Only a known difference counts. A capture that attached to an app already
+  // running may not have seen the device profile, and two absent values are not
+  // a mismatch — compared as numbers they become NaN !== NaN, which refuses
+  // every pair of traces that happen to be missing the same field.
+  const differs = (key: string): boolean => {
+    const left = a[key];
+    const right = b[key];
+    if (left === undefined || right === undefined) return false;
+    return left !== right;
+  };
+
+  if (differs("refreshHz")) {
+    return `different refresh rates: ${a.refreshHz}Hz and ${b.refreshHz}Hz — frame budgets differ`;
+  }
+  if (differs("cores")) {
+    return `different core counts: ${a.cores} and ${b.cores}`;
+  }
+  if (differs("lowRamDevice")) {
+    return "one capture is from a low-RAM device and the other is not";
+  }
+  return null;
+}
+
+export function renderComparison(
+  before: Trace,
+  after: Trace,
+): { text: string; regressed: boolean; refused: boolean } {
+  const blocked = comparability(before, after);
+  if (blocked) {
+    return {
+      text:
+        `refusing to compare: ${blocked}\n\n` +
+        "  A number from two runs that were never comparable is worse than no\n" +
+        "  number, because someone will act on it.\n",
+      regressed: false,
+      refused: true,
+    };
+  }
+
+  const changes = compareMetrics(before.metrics, after.metrics);
+  const notable = changes.filter((c) => c.kind !== "unchanged");
+  const unchanged = changes.length - notable.length;
+  const lines: string[] = [];
+
+  lines.push(`${after.scenario} · against a baseline of ${before.capturedAt}`);
+  lines.push("");
+
+  for (const change of notable) {
+    const label = change.kind === "improved" ? "improved " : change.kind.toUpperCase().padEnd(9);
+    const delta =
+      change.kind === "new"
+        ? "new"
+        : `(${change.after > change.before ? "+" : ""}${Math.round(((change.after - change.before) / (change.before || 1)) * 100)}%)`;
+    lines.push(`  ${label} ${change.key.padEnd(24)} ${change.before} → ${change.after}  ${delta}`);
+  }
+
+  if (notable.length === 0) lines.push("  nothing moved");
+  lines.push("");
+  lines.push(`  unchanged: ${unchanged} other metrics`);
+
+  // An agentic driver reasons between steps and does not walk the same path
+  // twice, so its timings drift for reasons that are not the code's.
+  if (after.driver && after.driver !== before.driver) {
+    lines.push("");
+    lines.push(`  note: drivers differ ("${before.driver ?? "?"}" then "${after.driver}")`);
+  }
+
+  return {
+    text: lines.join("\n") + "\n",
+    regressed: notable.some((c) => c.kind === "regressed" || c.kind === "new"),
+    refused: false,
+  };
+}

package/src/save.ts

@@ -0,0 +1,322 @@
+// Copyright 2026 Gravity Labs
+// SPDX-License-Identifier: Apache-2.0
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { DeviceEvent } from "./device.js";
+import { buildTrace, resolveProfile, type ResolvedProfile, type Trace } from "./trace.js";
+import {
+  clippedMsOf,
+  fillWindowFromDisk,
+  listAllSessions,
+  sessionSizeBytes,
+  type ClippedMs,
+  type SessionMetaWithDir,
+} from "./sessions.js";
+
+/**
+ * GRA-54: turning a slice of what already happened into a named artifact,
+ * after the fact.
+ *
+ * Every other way Porthole produces a durable trace requires deciding to
+ * record in advance — `capture` wraps a command, `capture_system_trace`
+ * blocks for a fixed duration. Once GRA-53 put sessions on disk, the
+ * material for "something bad just happened, keep it" already exists; this
+ * module is the one place that turns a window someone already asked about
+ * (through `findings`, say) into a trace file, called from both the MCP tool
+ * `save_moment` (index.ts, which already has a live device's identity and a
+ * merged view to hand in) and the CLI's `porthole save` (which has neither,
+ * and resolves both from disk alone — see `saveFromSessions` below).
+ *
+ * Deliberately thin, on purpose, twice over:
+ *
+ *  - `buildTrace` (trace.ts) is the exact analyser `capture` and the live
+ *    `findings` tool both call. Byte-compatibility with `capture`'s output
+ *    is therefore a consequence of calling the same function, not a goal
+ *    pursued separately here — nothing in this module reimplements a
+ *    metric, a finding, or a percentile.
+ *  - The events handed to `buildSavedTrace` always already come from
+ *    `fillWindowFromDisk` (sessions.ts) — the same merge `findings`,
+ *    `what_was_happening` and `timeline` all use. This module does not read
+ *    `events.ndjson` itself and does not merge live and disk data a second
+ *    way; `saveFromSessions`'s own disk-only use of that same function is
+ *    the CLI's one exception to "always has a live device", not a new
+ *    mechanism.
+ */
+
+/** Recorded on every trace this module builds, so a reader can tell it apart from a live `capture`. Ruling 3. */
+export const SAVE_DRIVER = "session";
+
+export interface SaveWindow {
+  from: number;
+  to: number;
+}
+
+/** `Trace`, plus the one field `capture`'s own output never carries: how much of the requested window was actually recorded. */
+export interface SavedTrace extends Trace {
+  clippedMs: ClippedMs;
+}
+
+/**
+ * Ruling 1 / EM's open-question-2, ratified by the coordinator: a saved
+ * moment gets a name even when nobody gave it one, because a required
+ * `--scenario`/`scenario` is friction the ticket exists to remove. On the
+ * uptime clock the window itself is already expressed in, so two saves of
+ * the same window land on the same default name rather than one that
+ * depends on wall-clock time nobody asked about.
+ */
+export function defaultScenarioName(from: number, to: number): string {
+  return `moment-${from}-${to}`;
+}
+
+/**
+ * Ruling 1: the default output path — the same `.porthole/traces/`
+ * directory `capture_system_trace` already writes under, so a saved moment
+ * and a system trace from the same investigation land next to each other.
+ */
+export function defaultOutPath(projectRoot: string, scenario: string): string {
+  return path.join(projectRoot, ".porthole", "traces", `${validateScenario(scenario)}.json`);
+}
+
+/** Thrown by [validateScenario]; callers turn it into their own refusal (400, `fail()`, exit 2). */
+export class InvalidScenarioError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidScenarioError";
+  }
+}
+
+/**
+ * The scenario becomes a file name under `.porthole/traces/`, and it arrives
+ * from a POST body, a tool argument or a CLI flag — none of which is trusted
+ * to stay inside that directory on its own. GRA-116's QA showed
+ * `"../../../../tmp/evil"` escaping it. Letters, digits, space, dot, dash
+ * and underscore only; no separators of either kind; no name made of dots;
+ * a length that still fits a file name comfortably.
+ */
+export function validateScenario(scenario: string): string {
+  const trimmed = scenario.trim();
+  if (trimmed === "") throw new InvalidScenarioError("scenario must not be empty.");
+  if (trimmed.length > 120) throw new InvalidScenarioError("scenario must be 120 characters or fewer.");
+  if (!/^[A-Za-z0-9 ._-]+$/.test(trimmed)) {
+    throw new InvalidScenarioError(
+      "scenario may contain only letters, digits, spaces, dots, dashes and underscores — no path separators.",
+    );
+  }
+  if (/^\.+$/.test(trimmed)) throw new InvalidScenarioError("scenario must not be made of dots only.");
+  return trimmed;
+}
+
+export interface BuildSavedTraceOptions {
+  events: DeviceEvent[];
+  hello: Record<string, unknown> | null;
+  window: SaveWindow;
+  /** From the same merged view's `coveredFrom`/`coveredTo` — see `fillWindowFromDisk`. */
+  coveredFrom: number | null;
+  coveredTo: number | null;
+  scenario: string;
+  /** GRA-185: resolved by the caller through `resolveProfile` — see that function's own doc comment for why every caller resolves it the same way rather than this module doing it a second time. */
+  profile: ResolvedProfile;
+}
+
+/**
+ * Ruling 3: calls `buildTrace` exactly as `capture` does, with
+ * `driver: "session"` and `withEvents: false` always — `--with-events` is
+ * cut from this ticket (the EM's own recommendation, taken): a saved moment
+ * sits right next to the session file it came from on disk, so embedding a
+ * copy of the same events inside the trace would only double the bytes to
+ * hand back something already there.
+ *
+ * Ruling 4: `clippedMs` is computed by the exact function `findings` uses
+ * (`clippedMsOf`, sessions.ts) — not a second, hand-rolled copy of the same
+ * formula.
+ */
+export function buildSavedTrace(options: BuildSavedTraceOptions): SavedTrace {
+  const trace = buildTrace({
+    scenario: options.scenario,
+    driver: SAVE_DRIVER,
+    events: options.events,
+    hello: options.hello,
+    durationMs: Math.max(0, options.window.to - options.window.from),
+    withEvents: false,
+    profile: options.profile,
+  });
+  return {
+    ...trace,
+    clippedMs: clippedMsOf(options.window.from, options.window.to, options.coveredFrom, options.coveredTo),
+  };
+}
+
+/** Writes the trace to `outPath`, creating the directory if it does not exist yet. */
+export async function writeSavedTrace(trace: SavedTrace, outPath: string): Promise<void> {
+  await mkdir(path.dirname(outPath), { recursive: true });
+  await writeFile(outPath, JSON.stringify(trace, null, 2));
+}
+
+/**
+ * Ruling 4: "the tool's summary line states the coverage in words when it
+ * is not complete." One sentence, or "" when the window was fully covered
+ * — left off entirely rather than a hollow "0.0s was not recorded", the
+ * same convention `findings`' own `missing` string in index.ts already
+ * uses.
+ */
+export function coverageNote(clipped: ClippedMs): string {
+  const shortfallMs = clipped.start + clipped.end;
+  if (shortfallMs <= 0) return "";
+  const seconds = Math.round(shortfallMs / 100) / 10;
+  return ` ${seconds}s of the requested window was never recorded and is not in this trace.`;
+}
+
+// ---------------------------------------------------------------------------
+// the CLI's disk-only path — no live device, so both "which session" and
+// "what does --since count back from" have to come from what is on disk
+// ---------------------------------------------------------------------------
+
+export interface SaveFromSessionsOptions {
+  root: string;
+  projectRoot: string;
+  scenario?: string;
+  sinceMs?: number;
+  from?: number;
+  to?: number;
+  out?: string;
+}
+
+export interface CommandResult {
+  /** Process exit code: 0 success, 1 nothing to act on, 2 bad input. */
+  code: number;
+  message: string;
+}
+
+/**
+ * `porthole save`'s implementation. Unlike `save_moment` (index.ts), a
+ * fresh CLI invocation has no live device and no live buffer to ask "what
+ * does --since count back from" of — so both the identity to search and,
+ * for `--since`, the anchor the lookback counts from, are resolved from
+ * whichever session on disk was most recently written to. That is a real
+ * limitation worth naming plainly: with more than one app or device
+ * recording into the same sessions root, this picks the busiest one, not
+ * necessarily the one the caller meant. `--from`/`--to` (quoted from an
+ * earlier `findings` result) sidestep the ambiguity for the window itself,
+ * but still use the same most-recently-active session to decide *whose*
+ * sessions to search — there is no `--package`/`--device` flag on this
+ * command to disambiguate further (not asked for by the ticket, and adding
+ * one is a decision, not a bug fix).
+ */
+export async function saveFromSessions(options: SaveFromSessionsOptions): Promise<CommandResult> {
+  const sessions = await listAllSessions(options.root);
+  const withData = sessions.filter(
+    (session): session is SessionMetaWithDir & { firstT: number; lastT: number } =>
+      session.firstT !== null && session.lastT !== null,
+  );
+  if (withData.length === 0) {
+    return {
+      code: 1,
+      message: "No sessions recorded on disk yet. Run `porthole ui` or `porthole mcp` against the app first.",
+    };
+  }
+
+  // Most recently *active*, not most recently *started* — a session open
+  // for hours with a fresh event just now is the one worth calling "now",
+  // regardless of when it began.
+  const latest = withData.reduce((a, b) => (b.lastT > a.lastT ? b : a));
+  const identity = { packageName: latest.packageName, deviceId: latest.deviceId };
+
+  const to = options.to ?? latest.lastT;
+  const from = options.from ?? (options.sinceMs !== undefined ? to - options.sinceMs : latest.firstT);
+
+  const merged = await fillWindowFromDisk({
+    root: options.root,
+    identity,
+    buffered: [],
+    currentSessionDir: null,
+    from,
+    to,
+  });
+
+  let scenario: string;
+  let outPath: string;
+  try {
+    scenario = options.scenario === undefined ? defaultScenarioName(from, to) : validateScenario(options.scenario);
+    outPath = options.out ?? defaultOutPath(options.projectRoot, scenario);
+  } catch (error) {
+    if (error instanceof InvalidScenarioError) return { code: 2, message: `porthole save: ${error.message}` };
+    throw error;
+  }
+  const hello: Record<string, unknown> = {
+    packageName: latest.packageName,
+    versionName: latest.versionName,
+    device: latest.device,
+    sdkInt: latest.sdkInt,
+  };
+  // GRA-185: no live buffer here — this is the CLI's disk-only path — so the
+  // only source `resolveProfile` has beyond the 60Hz fallback is whatever
+  // `latest`'s own `meta.json` recorded (`SessionWriter.append` captured it
+  // when the session was written, if it was written after that existed).
+  const profile = resolveProfile({
+    liveEvents: [],
+    windowTo: to,
+    sessionProfile: latest.profile ?? null,
+    hello,
+  });
+  const trace = buildSavedTrace({
+    events: merged.events as unknown as DeviceEvent[],
+    hello,
+    window: { from, to },
+    coveredFrom: merged.coveredFrom,
+    coveredTo: merged.coveredTo,
+    scenario,
+    profile,
+  });
+  await writeSavedTrace(trace, outPath);
+
+  return {
+    code: 0,
+    message: `saved "${scenario}" (${trace.findings.length} finding(s)) to ${outPath}.${coverageNote(trace.clippedMs)}`,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// `porthole sessions`
+// ---------------------------------------------------------------------------
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function eventCount(session: SessionMetaWithDir): number {
+  return Object.values(session.eventCounts).reduce((sum, n) => sum + n, 0);
+}
+
+/**
+ * `porthole sessions`'s implementation. "current" is whichever session was
+ * most recently written to (greatest `updatedAt`) — purely a fact about
+ * what is on disk, deliberately not "is a device connected right now": a
+ * one-shot CLI invocation with no live `DeviceClient` has no cheap, honest
+ * way to answer that question without opening a socket and waiting on a
+ * device that may not even be plugged in, which is a different (and
+ * heavier) command than "list what is already recorded".
+ */
+export async function listSessionsText(root: string): Promise<CommandResult> {
+  const sessions = await listAllSessions(root);
+  if (sessions.length === 0) {
+    return { code: 0, message: "No sessions recorded on disk yet." };
+  }
+
+  const current = sessions.reduce((a, b) => (b.updatedAt > a.updatedAt ? b : a));
+
+  const lines: string[] = [];
+  for (const session of sessions) {
+    const marker = session.dir === current.dir ? "*" : " ";
+    const started = new Date(session.createdAt).toISOString();
+    const firstT = session.firstT ?? "-";
+    const lastT = session.lastT ?? "-";
+    const bytes = await sessionSizeBytes(session.dir);
+    lines.push(
+      `${marker} ${session.packageName} ${session.deviceId} started ${started} ` +
+        `t=[${firstT},${lastT}] events=${eventCount(session)} ${formatBytes(bytes)} ${session.dir}`,
+    );
+  }
+  return { code: 0, message: lines.join("\n") };
+}