terminal-pilot 0.0.6 → 0.0.8

package/dist/commands/screenshot.js

@@ -1,20 +1,1028 @@
-// src/commands/screenshot.ts
-import { defineCommand, S } from "@poe-code/cmdkit";
-import { renderTerminalPng } from "terminal-png";
+// ../cmdkit/src/index.ts
+import { fileURLToPath } from "node:url";
 
-// src/commands/runtime.ts
-import { UserError } from "@poe-code/cmdkit";
+// ../cmdkit-schema/src/index.ts
+function assertValidEnumValues(values) {
+  if (values.length === 0) {
+    throw new Error("Enum schema requires at least one value");
+  }
+  const uniqueValues = new Set(values);
+  if (uniqueValues.size !== values.length) {
+    throw new Error("Enum schema values must be unique");
+  }
+}
+var S = {
+  String(options = {}) {
+    return {
+      kind: "string",
+      ...options
+    };
+  },
+  Number(options = {}) {
+    return {
+      kind: "number",
+      ...options
+    };
+  },
+  Boolean(options = {}) {
+    return {
+      kind: "boolean",
+      ...options
+    };
+  },
+  Enum(values, options = {}) {
+    assertValidEnumValues(values);
+    return {
+      kind: "enum",
+      values,
+      ...options
+    };
+  },
+  Array(item, options = {}) {
+    return {
+      kind: "array",
+      item,
+      ...options
+    };
+  },
+  Object(shape) {
+    return {
+      kind: "object",
+      shape
+    };
+  },
+  Optional(inner) {
+    return {
+      kind: "optional",
+      inner
+    };
+  }
+};
+
+// ../cmdkit/src/index.ts
+var commandConfigSymbol = /* @__PURE__ */ Symbol("cmdkit.command.config");
+var commandSourcePathSymbol = /* @__PURE__ */ Symbol("cmdkit.command.sourcePath");
+var UserError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserError";
+  }
+};
+function cloneScope(scope) {
+  return scope === void 0 ? void 0 : [...scope];
+}
+function cloneSecretDefinition(secret) {
+  return {
+    env: secret.env,
+    description: secret.description,
+    optional: secret.optional
+  };
+}
+function cloneSecrets(secrets) {
+  if (secrets === void 0) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(secrets).map(([key, secret]) => [key, cloneSecretDefinition(secret)])
+  );
+}
+function cloneRequires(requires) {
+  if (requires === void 0) {
+    return void 0;
+  }
+  return {
+    auth: requires.auth,
+    apiVersion: requires.apiVersion,
+    check: requires.check
+  };
+}
+function parseStackPath(candidate) {
+  if (candidate.startsWith("file://")) {
+    try {
+      return fileURLToPath(candidate);
+    } catch {
+      return void 0;
+    }
+  }
+  if (candidate.startsWith("/")) {
+    return candidate;
+  }
+  return void 0;
+}
+function extractStackPath(line) {
+  const trimmed = line.trim();
+  const fileIndex = trimmed.indexOf("file://");
+  if (fileIndex >= 0) {
+    const location2 = trimmed.slice(fileIndex);
+    const separatorIndex2 = location2.lastIndexOf(":");
+    const previousSeparatorIndex2 = separatorIndex2 >= 0 ? location2.lastIndexOf(":", separatorIndex2 - 1) : -1;
+    const candidate2 = separatorIndex2 >= 0 && previousSeparatorIndex2 >= 0 ? location2.slice(0, previousSeparatorIndex2) : location2;
+    return parseStackPath(candidate2);
+  }
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex < 0) {
+    return void 0;
+  }
+  const location = trimmed.slice(slashIndex);
+  const separatorIndex = location.lastIndexOf(":");
+  const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+  const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0 ? location.slice(0, previousSeparatorIndex) : location;
+  return parseStackPath(candidate);
+}
+function inferCommandSourcePath() {
+  const stack = new Error().stack;
+  if (typeof stack !== "string") {
+    return void 0;
+  }
+  for (const line of stack.split("\n").slice(1)) {
+    const candidate = extractStackPath(line);
+    if (candidate === void 0) {
+      continue;
+    }
+    if (candidate.includes("/packages/cmdkit/src/index.ts") || candidate.includes("/packages/cmdkit/dist/index.js")) {
+      continue;
+    }
+    return candidate;
+  }
+  return void 0;
+}
+function composeChecks(parentCheck, childCheck) {
+  if (parentCheck === void 0) {
+    return childCheck;
+  }
+  if (childCheck === void 0) {
+    return parentCheck;
+  }
+  return async (ctx) => {
+    const parentResult = await parentCheck(ctx);
+    if (!parentResult.ok) {
+      return parentResult;
+    }
+    return childCheck(ctx);
+  };
+}
+function mergeRequires(parent, child) {
+  if (parent === void 0 && child === void 0) {
+    return void 0;
+  }
+  const merged = {
+    auth: child?.auth ?? parent?.auth,
+    apiVersion: child?.apiVersion ?? parent?.apiVersion,
+    check: composeChecks(parent?.check, child?.check)
+  };
+  if (merged.auth === void 0 && merged.apiVersion === void 0 && merged.check === void 0) {
+    return void 0;
+  }
+  return merged;
+}
+function mergeSecrets(parent, child) {
+  return cloneSecrets({
+    ...parent,
+    ...child
+  });
+}
+function resolveCommandScope(ownScope, inheritedScope) {
+  return cloneScope(ownScope ?? inheritedScope) ?? ["cli", "sdk"];
+}
+function createBaseCommand(config) {
+  const command = {
+    kind: "command",
+    name: config.name,
+    description: config.description,
+    aliases: [...config.aliases ?? []],
+    positional: [...config.positional ?? []],
+    params: config.params,
+    secrets: cloneSecrets(config.secrets),
+    scope: resolveCommandScope(config.scope, void 0),
+    confirm: config.confirm ?? false,
+    requires: cloneRequires(config.requires),
+    handler: config.handler,
+    render: config.render
+  };
+  Object.defineProperty(command, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(config.scope),
+      secrets: cloneSecrets(config.secrets),
+      requires: cloneRequires(config.requires),
+      sourcePath: inferCommandSourcePath()
+    }
+  });
+  return command;
+}
+function getInternalCommandConfig(command) {
+  return command[commandConfigSymbol];
+}
+function materializeCommand(command, inherited) {
+  const internal = getInternalCommandConfig(command);
+  const materialized = {
+    kind: "command",
+    name: command.name,
+    description: command.description,
+    aliases: [...command.aliases],
+    positional: [...command.positional],
+    params: command.params,
+    secrets: mergeSecrets(inherited.secrets, internal.secrets),
+    scope: resolveCommandScope(internal.scope, inherited.scope),
+    confirm: command.confirm,
+    requires: mergeRequires(inherited.requires, internal.requires),
+    handler: command.handler,
+    render: command.render
+  };
+  Object.defineProperty(materialized, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(internal.scope),
+      secrets: cloneSecrets(internal.secrets),
+      requires: cloneRequires(internal.requires),
+      sourcePath: internal.sourcePath
+    }
+  });
+  Object.defineProperty(materialized, commandSourcePathSymbol, {
+    value: internal.sourcePath
+  });
+  return materialized;
+}
+function defineCommand(config) {
+  return materializeCommand(createBaseCommand(config), {
+    scope: void 0,
+    secrets: {},
+    requires: void 0
+  });
+}
+
+// ../terminal-png/src/index.ts
+import { writeFile } from "node:fs/promises";
+
+// ../terminal-png/src/ansi-parser.ts
+var ESC = "\x1B";
+function createDefaultStyle() {
+  return {
+    fg: null,
+    bg: null,
+    bold: false,
+    italic: false,
+    underline: false,
+    strikethrough: false,
+    dim: false
+  };
+}
+function cloneStyle(style) {
+  return { ...style };
+}
+function stylesEqual(left, right) {
+  return left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strikethrough === right.strikethrough && left.dim === right.dim && colorsEqual(left.fg, right.fg) && colorsEqual(left.bg, right.bg);
+}
+function colorsEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (!left || !right || left.type !== right.type) {
+    return false;
+  }
+  if (left.type === "rgb" && right.type === "rgb") {
+    return left.r === right.r && left.g === right.g && left.b === right.b;
+  }
+  if ((left.type === "ansi4" || left.type === "ansi8") && left.type === right.type) {
+    return left.index === right.index;
+  }
+  return false;
+}
+function pushRun(runs, style, text) {
+  if (text.length === 0) {
+    return;
+  }
+  const previous = runs.at(-1);
+  if (previous && text !== "\n" && previous.text !== "\n" && stylesEqual(previous, style)) {
+    previous.text += text;
+    return;
+  }
+  runs.push({
+    text,
+    fg: style.fg,
+    bg: style.bg,
+    bold: style.bold,
+    italic: style.italic,
+    underline: style.underline,
+    strikethrough: style.strikethrough,
+    dim: style.dim
+  });
+}
+function parseCsi(input, start) {
+  let index = start + 2;
+  while (index < input.length) {
+    const code = input.charCodeAt(index);
+    if (code >= 64 && code <= 126) {
+      return {
+        end: index + 1,
+        final: input[index],
+        params: input.slice(start + 2, index)
+      };
+    }
+    index += 1;
+  }
+  return {
+    end: input.length,
+    final: null,
+    params: input.slice(start + 2)
+  };
+}
+function toInteger(value) {
+  if (!value || value.length === 0) {
+    return null;
+  }
+  for (const char of value) {
+    if (char < "0" || char > "9") {
+      return null;
+    }
+  }
+  return Number.parseInt(value, 10);
+}
+function clampByte(value) {
+  if (value < 0) {
+    return 0;
+  }
+  if (value > 255) {
+    return 255;
+  }
+  return value;
+}
+function applyExtendedColor(params2, start) {
+  const mode = params2[start];
+  if (mode === 5) {
+    const index = params2[start + 1];
+    if (index === void 0) {
+      return null;
+    }
+    return {
+      color: { type: "ansi8", index: clampByte(index) },
+      consumed: 2
+    };
+  }
+  if (mode === 2) {
+    const r = params2[start + 1];
+    const g = params2[start + 2];
+    const b = params2[start + 3];
+    if (r === void 0 || g === void 0 || b === void 0) {
+      return null;
+    }
+    return {
+      color: { type: "rgb", r: clampByte(r), g: clampByte(g), b: clampByte(b) },
+      consumed: 4
+    };
+  }
+  return null;
+}
+function applySgr(style, paramsText) {
+  const nextStyle = cloneStyle(style);
+  const rawParams = paramsText.length === 0 ? ["0"] : paramsText.split(";");
+  const params2 = [];
+  for (const rawParam of rawParams) {
+    const value = toInteger(rawParam);
+    if (value === null) {
+      return nextStyle;
+    }
+    params2.push(value);
+  }
+  for (let index = 0; index < params2.length; index += 1) {
+    const value = params2[index];
+    if (value === 0) {
+      Object.assign(nextStyle, createDefaultStyle());
+      continue;
+    }
+    if (value === 1) {
+      nextStyle.bold = true;
+      continue;
+    }
+    if (value === 2) {
+      nextStyle.dim = true;
+      continue;
+    }
+    if (value === 22) {
+      nextStyle.bold = false;
+      nextStyle.dim = false;
+      continue;
+    }
+    if (value === 3) {
+      nextStyle.italic = true;
+      continue;
+    }
+    if (value === 23) {
+      nextStyle.italic = false;
+      continue;
+    }
+    if (value === 4) {
+      nextStyle.underline = true;
+      continue;
+    }
+    if (value === 24) {
+      nextStyle.underline = false;
+      continue;
+    }
+    if (value === 9) {
+      nextStyle.strikethrough = true;
+      continue;
+    }
+    if (value === 29) {
+      nextStyle.strikethrough = false;
+      continue;
+    }
+    if (value === 39) {
+      nextStyle.fg = null;
+      continue;
+    }
+    if (value === 49) {
+      nextStyle.bg = null;
+      continue;
+    }
+    if (value >= 30 && value <= 37) {
+      nextStyle.fg = { type: "ansi4", index: value - 30 };
+      continue;
+    }
+    if (value >= 90 && value <= 97) {
+      nextStyle.fg = { type: "ansi4", index: value - 90 + 8 };
+      continue;
+    }
+    if (value >= 40 && value <= 47) {
+      nextStyle.bg = { type: "ansi4", index: value - 40 };
+      continue;
+    }
+    if (value >= 100 && value <= 107) {
+      nextStyle.bg = { type: "ansi4", index: value - 100 + 8 };
+      continue;
+    }
+    if (value === 38 || value === 48) {
+      const extended = applyExtendedColor(params2, index + 1);
+      if (!extended) {
+        continue;
+      }
+      if (value === 38) {
+        nextStyle.fg = extended.color;
+      } else {
+        nextStyle.bg = extended.color;
+      }
+      index += extended.consumed;
+    }
+  }
+  return nextStyle;
+}
+function parseAnsi(input) {
+  const runs = [];
+  let style = createDefaultStyle();
+  let textStart = 0;
+  let index = 0;
+  while (index < input.length) {
+    const char = input[index];
+    if (char === "\n") {
+      pushRun(runs, style, input.slice(textStart, index));
+      pushRun(runs, style, "\n");
+      index += 1;
+      textStart = index;
+      continue;
+    }
+    if (char === ESC && input[index + 1] === "[") {
+      pushRun(runs, style, input.slice(textStart, index));
+      const sequence = parseCsi(input, index);
+      if (sequence.final === "m") {
+        style = applySgr(style, sequence.params);
+      }
+      index = sequence.end;
+      textStart = index;
+      continue;
+    }
+    index += 1;
+  }
+  pushRun(runs, style, input.slice(textStart));
+  return runs;
+}
+
+// ../terminal-png/src/png-renderer.ts
+import { Resvg } from "@resvg/resvg-js";
+
+// ../terminal-png/src/font.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var require2 = createRequire(import.meta.url);
+var fontPackageRoot = dirname(require2.resolve("jetbrains-mono/package.json"));
+var webfontRoot = join(fontPackageRoot, "fonts/webfonts");
+function readWebfontBase64(filename) {
+  return readFileSync(join(webfontRoot, filename)).toString("base64");
+}
+function resolveAssetPath(filename) {
+  return fileURLToPath2(new URL(`../assets/${filename}`, import.meta.url));
+}
+function createFontFace(base64, weight, style) {
+  return `@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: ${style};
+  font-weight: ${weight};
+  src: url('data:font/woff2;base64,${base64}') format('woff2');
+}`;
+}
+var JETBRAINS_MONO_BASE64 = readWebfontBase64("JetBrainsMono-Regular.woff2");
+var JETBRAINS_MONO_FONT_FILES = [
+  resolveAssetPath("jetbrains-mono-400-normal.ttf"),
+  resolveAssetPath("jetbrains-mono-700-normal.ttf"),
+  resolveAssetPath("jetbrains-mono-400-italic.ttf"),
+  resolveAssetPath("jetbrains-mono-700-italic.ttf")
+];
+var JETBRAINS_MONO_TTF_PATH = JETBRAINS_MONO_FONT_FILES[0];
+var FONT_FACE_CSS = [
+  createFontFace(JETBRAINS_MONO_BASE64, 400, "normal"),
+  createFontFace(readWebfontBase64("JetBrainsMono-Bold.woff2"), 700, "normal"),
+  createFontFace(readWebfontBase64("JetBrainsMono-Italic.woff2"), 400, "italic"),
+  createFontFace(readWebfontBase64("JetBrainsMono-BoldItalic.woff2"), 700, "italic")
+].join("\n");
+
+// ../terminal-png/src/png-renderer.ts
+function renderPng(svg) {
+  const resvg = new Resvg(svg, {
+    font: {
+      defaultFontFamily: "JetBrains Mono",
+      fontFiles: [...JETBRAINS_MONO_FONT_FILES],
+      loadSystemFonts: false,
+      monospaceFamily: "JetBrains Mono"
+    },
+    fitTo: {
+      mode: "zoom",
+      value: 4
+    }
+  });
+  const png = resvg.render();
+  return Buffer.from(png.asPng());
+}
+
+// ../terminal-png/src/svg-renderer.ts
+var ANSI_16_PALETTE = [
+  "#282a2e",
+  "#D74E6F",
+  "#31BB71",
+  "#D3E561",
+  "#8056FF",
+  "#ED61D7",
+  "#04D7D7",
+  "#C5C8C6",
+  "#4B4B4B",
+  "#FE5F86",
+  "#00D787",
+  "#EBFF71",
+  "#8F69FF",
+  "#FF7AEA",
+  "#00FEFE",
+  "#FFFFFF"
+];
+var XTERM_256_PALETTE = [
+  "#000000",
+  "#800000",
+  "#008000",
+  "#808000",
+  "#000080",
+  "#800080",
+  "#008080",
+  "#c0c0c0",
+  "#808080",
+  "#ff0000",
+  "#00ff00",
+  "#ffff00",
+  "#0000ff",
+  "#ff00ff",
+  "#00ffff",
+  "#ffffff",
+  "#000000",
+  "#00005f",
+  "#000087",
+  "#0000af",
+  "#0000d7",
+  "#0000ff",
+  "#005f00",
+  "#005f5f",
+  "#005f87",
+  "#005faf",
+  "#005fd7",
+  "#005fff",
+  "#008700",
+  "#00875f",
+  "#008787",
+  "#0087af",
+  "#0087d7",
+  "#0087ff",
+  "#00af00",
+  "#00af5f",
+  "#00af87",
+  "#00afaf",
+  "#00afd7",
+  "#00afff",
+  "#00d700",
+  "#00d75f",
+  "#00d787",
+  "#00d7af",
+  "#00d7d7",
+  "#00d7ff",
+  "#00ff00",
+  "#00ff5f",
+  "#00ff87",
+  "#00ffaf",
+  "#00ffd7",
+  "#00ffff",
+  "#5f0000",
+  "#5f005f",
+  "#5f0087",
+  "#5f00af",
+  "#5f00d7",
+  "#5f00ff",
+  "#5f5f00",
+  "#5f5f5f",
+  "#5f5f87",
+  "#5f5faf",
+  "#5f5fd7",
+  "#5f5fff",
+  "#5f8700",
+  "#5f875f",
+  "#5f8787",
+  "#5f87af",
+  "#5f87d7",
+  "#5f87ff",
+  "#5faf00",
+  "#5faf5f",
+  "#5faf87",
+  "#5fafaf",
+  "#5fafd7",
+  "#5fafff",
+  "#5fd700",
+  "#5fd75f",
+  "#5fd787",
+  "#5fd7af",
+  "#5fd7d7",
+  "#5fd7ff",
+  "#5fff00",
+  "#5fff5f",
+  "#5fff87",
+  "#5fffaf",
+  "#5fffd7",
+  "#5fffff",
+  "#870000",
+  "#87005f",
+  "#870087",
+  "#8700af",
+  "#8700d7",
+  "#8700ff",
+  "#875f00",
+  "#875f5f",
+  "#875f87",
+  "#875faf",
+  "#875fd7",
+  "#875fff",
+  "#878700",
+  "#87875f",
+  "#878787",
+  "#8787af",
+  "#8787d7",
+  "#8787ff",
+  "#87af00",
+  "#87af5f",
+  "#87af87",
+  "#87afaf",
+  "#87afd7",
+  "#87afff",
+  "#87d700",
+  "#87d75f",
+  "#87d787",
+  "#87d7af",
+  "#87d7d7",
+  "#87d7ff",
+  "#87ff00",
+  "#87ff5f",
+  "#87ff87",
+  "#87ffaf",
+  "#87ffd7",
+  "#87ffff",
+  "#af0000",
+  "#af005f",
+  "#af0087",
+  "#af00af",
+  "#af00d7",
+  "#af00ff",
+  "#af5f00",
+  "#af5f5f",
+  "#af5f87",
+  "#af5faf",
+  "#af5fd7",
+  "#af5fff",
+  "#af8700",
+  "#af875f",
+  "#af8787",
+  "#af87af",
+  "#af87d7",
+  "#af87ff",
+  "#afaf00",
+  "#afaf5f",
+  "#afaf87",
+  "#afafaf",
+  "#afafd7",
+  "#afafff",
+  "#afd700",
+  "#afd75f",
+  "#afd787",
+  "#afd7af",
+  "#afd7d7",
+  "#afd7ff",
+  "#afff00",
+  "#afff5f",
+  "#afff87",
+  "#afffaf",
+  "#afffd7",
+  "#afffff",
+  "#d70000",
+  "#d7005f",
+  "#d70087",
+  "#d700af",
+  "#d700d7",
+  "#d700ff",
+  "#d75f00",
+  "#d75f5f",
+  "#d75f87",
+  "#d75faf",
+  "#d75fd7",
+  "#d75fff",
+  "#d78700",
+  "#d7875f",
+  "#d78787",
+  "#d787af",
+  "#d787d7",
+  "#d787ff",
+  "#d7af00",
+  "#d7af5f",
+  "#d7af87",
+  "#d7afaf",
+  "#d7afd7",
+  "#d7afff",
+  "#d7d700",
+  "#d7d75f",
+  "#d7d787",
+  "#d7d7af",
+  "#d7d7d7",
+  "#d7d7ff",
+  "#d7ff00",
+  "#d7ff5f",
+  "#d7ff87",
+  "#d7ffaf",
+  "#d7ffd7",
+  "#d7ffff",
+  "#ff0000",
+  "#ff005f",
+  "#ff0087",
+  "#ff00af",
+  "#ff00d7",
+  "#ff00ff",
+  "#ff5f00",
+  "#ff5f5f",
+  "#ff5f87",
+  "#ff5faf",
+  "#ff5fd7",
+  "#ff5fff",
+  "#ff8700",
+  "#ff875f",
+  "#ff8787",
+  "#ff87af",
+  "#ff87d7",
+  "#ff87ff",
+  "#ffaf00",
+  "#ffaf5f",
+  "#ffaf87",
+  "#ffafaf",
+  "#ffafd7",
+  "#ffafff",
+  "#ffd700",
+  "#ffd75f",
+  "#ffd787",
+  "#ffd7af",
+  "#ffd7d7",
+  "#ffd7ff",
+  "#ffff00",
+  "#ffff5f",
+  "#ffff87",
+  "#ffffaf",
+  "#ffffd7",
+  "#ffffff",
+  "#080808",
+  "#121212",
+  "#1c1c1c",
+  "#262626",
+  "#303030",
+  "#3a3a3a",
+  "#444444",
+  "#4e4e4e",
+  "#585858",
+  "#606060",
+  "#666666",
+  "#767676",
+  "#808080",
+  "#8a8a8a",
+  "#949494",
+  "#9e9e9e",
+  "#a8a8a8",
+  "#b2b2b2",
+  "#bcbcbc",
+  "#c6c6c6",
+  "#d0d0d0",
+  "#dadada",
+  "#e4e4e4",
+  "#eeeeee"
+];
+var BACKGROUND = "#171717";
+var DEFAULT_FOREGROUND = "#c4c4c4";
+var FONT_FAMILY = "JetBrains Mono";
+var FONT_SIZE = 14;
+var LINE_HEIGHT = 1.2;
+var CHARACTER_WIDTH = 8.412666666666667;
+var TEXT_BOTTOM_PADDING = 11.6;
+var DEFAULT_PADDING = {
+  top: 20,
+  right: 40,
+  bottom: 20,
+  left: 20
+};
+var WINDOW_BAR_HEIGHT = 15;
+function renderSvg(runs, options = {}) {
+  const padding = options.padding === void 0 ? DEFAULT_PADDING : {
+    top: options.padding,
+    right: options.padding,
+    bottom: options.padding,
+    left: options.padding
+  };
+  const showWindow = options.window ?? true;
+  const titleBarHeight = showWindow ? WINDOW_BAR_HEIGHT : 0;
+  const textStartX = padding.left;
+  const lineHeightPx = FONT_SIZE * LINE_HEIGHT;
+  const textStartY = titleBarHeight + padding.top + lineHeightPx;
+  const lines = splitIntoLines(runs);
+  const contentWidth = measureLines(lines);
+  const width = padding.left + contentWidth + padding.right;
+  const height = titleBarHeight + padding.top + lines.length * lineHeightPx + padding.bottom + TEXT_BOTTOM_PADDING;
+  const svgWidth = formatNumber(width);
+  const svgHeight = formatNumber(height);
+  const viewBox = `0 0 ${svgWidth} ${svgHeight}`;
+  const textElements = renderLines(lines, textStartX, textStartY, lineHeightPx);
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${svgWidth}" height="${svgHeight}" viewBox="${viewBox}">`,
+    "<defs>",
+    "<style><![CDATA[",
+    FONT_FACE_CSS,
+    "]]></style>",
+    "</defs>",
+    `<rect x="0" y="0" width="${svgWidth}" height="${svgHeight}" fill="${BACKGROUND}" />`,
+    showWindow ? renderWindowControls() : "",
+    `<g font-family="${FONT_FAMILY}" font-size="${formatNumber(FONT_SIZE)}px" fill="${DEFAULT_FOREGROUND}">`,
+    textElements,
+    "</g>",
+    "</svg>"
+  ].join("");
+}
+function splitIntoLines(runs) {
+  const lines = [[]];
+  for (const run of runs) {
+    if (run.text === "\n") {
+      lines.push([]);
+      continue;
+    }
+    lines[lines.length - 1]?.push(run);
+  }
+  return lines;
+}
+function measureLines(lines) {
+  return Math.max(
+    ...lines.map((line) => line.reduce((width, run) => width + displayWidth(run.text) * CHARACTER_WIDTH, 0)),
+    0
+  );
+}
+function displayWidth(text) {
+  const segmenter = new Intl.Segmenter();
+  let width = 0;
+  for (const { segment } of segmenter.segment(text)) {
+    const cp = segment.codePointAt(0);
+    width += cp !== void 0 && isWideCodePoint(cp) ? 2 : 1;
+  }
+  return width;
+}
+function isWideCodePoint(cp) {
+  return cp >= 4352 && cp <= 4447 || // Hangul Jamo
+  cp === 9001 || cp === 9002 || // Angle brackets
+  cp >= 11904 && cp <= 12350 || // CJK Radicals, Kangxi
+  cp >= 12353 && cp <= 13247 || // Hiragana, Katakana, CJK symbols
+  cp >= 13312 && cp <= 19903 || // CJK Extension A
+  cp >= 19968 && cp <= 42191 || // CJK Unified Ideographs
+  cp >= 43360 && cp <= 43391 || // Hangul Jamo Extended-A
+  cp >= 44032 && cp <= 55215 || // Hangul Syllables
+  cp >= 63744 && cp <= 64255 || // CJK Compatibility Ideographs
+  cp >= 65040 && cp <= 65049 || // Vertical Forms
+  cp >= 65072 && cp <= 65135 || // CJK Compatibility Forms
+  cp >= 65280 && cp <= 65376 || // Fullwidth Latin, Halfwidth Katakana
+  cp >= 65504 && cp <= 65510 || // Fullwidth Signs
+  cp >= 110592 && cp <= 110847 || // Kana Supplement
+  cp >= 126980 && cp <= 126980 || // Mahjong tile
+  cp >= 127183 && cp <= 127183 || // Playing card black joker
+  cp >= 127488 && cp <= 131069 || // Enclosed CJK + Emoji
+  cp >= 131072 && cp <= 196605 || // CJK Extension B–F
+  cp >= 196608 && cp <= 262141;
+}
+function renderLines(lines, textStartX, textStartY, lineHeightPx) {
+  return lines.map((line, index) => {
+    const y = formatNumber(textStartY + index * lineHeightPx);
+    if (line.length === 0) {
+      return `<text x="${formatNumber(textStartX)}" y="${y}" xml:space="preserve"/>`;
+    }
+    return [
+      `<text x="${formatNumber(textStartX)}" y="${y}" xml:space="preserve">`,
+      line.map(renderRun).join(""),
+      "</text>"
+    ].join("");
+  }).join("");
+}
+function renderRun(run) {
+  const attributes = ['xml:space="preserve"'];
+  const color = resolveColor(run.fg);
+  const textDecorations = [];
+  if (color !== DEFAULT_FOREGROUND) {
+    attributes.push(`fill="${escapeXmlAttribute(color)}"`);
+  }
+  if (run.bold) {
+    attributes.push('font-weight="bold"');
+  }
+  if (run.italic) {
+    attributes.push('font-style="italic"');
+  }
+  if (run.underline) {
+    textDecorations.push("underline");
+  }
+  if (run.strikethrough) {
+    textDecorations.push("line-through");
+  }
+  if (textDecorations.length > 0) {
+    attributes.push(`text-decoration="${textDecorations.join(" ")}"`);
+  }
+  if (run.dim) {
+    attributes.push('opacity="0.7"');
+  }
+  return `<tspan ${attributes.join(" ")}>${escapeXmlText(run.text)}</tspan>`;
+}
+function renderWindowControls() {
+  return [
+    '<circle cx="13.5" cy="12" r="5.5" fill="#FF5A54" />',
+    '<circle cx="32.5" cy="12" r="5.5" fill="#E6BF29" />',
+    '<circle cx="51.5" cy="12" r="5.5" fill="#52C12B" />'
+  ].join("");
+}
+function resolveColor(color) {
+  if (color === null) {
+    return DEFAULT_FOREGROUND;
+  }
+  if (color.type === "ansi4") {
+    return ANSI_16_PALETTE[color.index] ?? DEFAULT_FOREGROUND;
+  }
+  if (color.type === "ansi8") {
+    if (color.index < ANSI_16_PALETTE.length) {
+      return ANSI_16_PALETTE[color.index] ?? DEFAULT_FOREGROUND;
+    }
+    return XTERM_256_PALETTE[color.index] ?? DEFAULT_FOREGROUND;
+  }
+  return `rgb(${color.r},${color.g},${color.b})`;
+}
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeXmlAttribute(value) {
+  return escapeXmlText(value).replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function formatNumber(value) {
+  return value.toFixed(2);
+}
+
+// ../terminal-png/src/index.ts
+async function renderTerminalPng(ansiText, options = {}) {
+  const runs = parseAnsi(ansiText);
+  const svg = renderSvg(runs, {
+    padding: options.padding,
+    window: options.window
+  });
+  const png = renderPng(svg);
+  if (options.output) {
+    await writeFile(options.output, png);
+  }
+  return png;
+}
 
 // src/terminal-pilot.ts
 import { randomUUID } from "node:crypto";
 
 // src/terminal-session.ts
-import { spawn as spawnChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
+import { accessSync, chmodSync, constants } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname2, join as join2 } from "node:path";
 import * as nodePty from "node-pty";
 
 // src/ansi.ts
-var ESC = 27;
+var ESC2 = 27;
 var BEL = 7;
 var ST = 156;
 var CSI = 155;
@@ -27,7 +1035,7 @@ function stripAnsi(input) {
   let output = "";
   for (let index = 0; index < input.length; index += 1) {
     const code = input.charCodeAt(index);
-    if (code === ESC) {
+    if (code === ESC2) {
       const nextCode = input.charCodeAt(index + 1);
       if (nextCode === 91) {
         index = consumeCsi(input, index + 2);
@@ -78,7 +1086,7 @@ function consumeTerminatedString(input, index, allowBellTerminator) {
     if (code === ST || allowBellTerminator && code === BEL) {
       return index;
     }
-    if (code === ESC && input.charCodeAt(index + 1) === 92) {
+    if (code === ESC2 && input.charCodeAt(index + 1) === 92) {
       return index + 1;
     }
     index += 1;
@@ -921,93 +1929,27 @@ function createPtyProcess({
   cols,
   rows
 }) {
-  try {
-    return nodePty.spawn(command, args, {
-      cwd,
-      env,
-      cols,
-      rows,
-      encoding: "utf8"
-    });
-  } catch {
-    return createChildProcessFallback({ command, args, cwd, env });
-  }
-}
-function createChildProcessFallback({
-  command,
-  args,
-  cwd,
-  env
-}) {
-  const child = spawnChildProcess(command, args, {
+  ensureSpawnHelperExecutable();
+  return nodePty.spawn(command, args, {
     cwd,
     env,
-    stdio: ["pipe", "pipe", "pipe"]
+    cols,
+    rows,
+    encoding: "utf8"
   });
-  return new ChildProcessFallback(child);
 }
-var ChildProcessFallback = class {
-  pid;
-  child;
-  dataEmitter = new EventEmitter();
-  exitEmitter = new EventEmitter();
-  constructor(child) {
-    this.child = child;
-    this.pid = child.pid ?? -1;
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", this.handleData);
-    child.stderr.on("data", this.handleData);
-    child.on("exit", (exitCode, signal) => {
-      this.exitEmitter.emit("exit", {
-        exitCode: exitCode ?? signalToExitCode(signal),
-        signal: void 0
-      });
-    });
-  }
-  write(data) {
-    this.child.stdin.write(data);
-  }
-  resize() {
-  }
-  kill(signal) {
-    this.child.kill(signal);
-  }
-  onData(listener) {
-    this.dataEmitter.on("data", listener);
-    return {
-      dispose: () => {
-        this.dataEmitter.off("data", listener);
-      }
-    };
-  }
-  onExit(listener) {
-    this.exitEmitter.on("exit", listener);
-    return {
-      dispose: () => {
-        this.exitEmitter.off("exit", listener);
-      }
-    };
-  }
-  handleData = (chunk) => {
-    this.dataEmitter.emit("data", String(chunk));
-  };
-};
-function signalToExitCode(signal) {
-  if (signal === null) {
-    return 0;
-  }
-  const signalNumbers = {
-    SIGTERM: 15,
-    SIGINT: 2,
-    SIGHUP: 1,
-    SIGKILL: 9
-  };
-  const signalNumber = signalNumbers[signal];
-  if (signalNumber === void 0) {
-    return 1;
+var spawnHelperChecked = false;
+function ensureSpawnHelperExecutable() {
+  if (spawnHelperChecked) return;
+  spawnHelperChecked = true;
+  const require3 = createRequire2(import.meta.url);
+  const nodePtyDir = dirname2(require3.resolve("node-pty"));
+  const helper = join2(nodePtyDir, "..", "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+  try {
+    accessSync(helper, constants.X_OK);
+  } catch {
+    chmodSync(helper, 493);
   }
-  return 128 + signalNumber;
 }
 function matchPattern(buffer, pattern) {
   const clean = normalizeHistoryBuffer(stripAnsi(buffer));