pyre-cli 9.5.1 → 10.0.0

package/dist/ioreport.py

@@ -0,0 +1,72 @@
+import ctypes, ctypes.util, json, time, sys
+
+try:
+    libIOReport = ctypes.cdll.LoadLibrary('/usr/lib/libIOReport.dylib')
+    CF = ctypes.cdll.LoadLibrary(ctypes.util.find_library('CoreFoundation'))
+    CFStringRef = ctypes.c_void_p
+    CFDictionaryRef = ctypes.c_void_p
+    CFArrayRef = ctypes.c_void_p
+    CFIndex = ctypes.c_long
+
+    CF.CFStringCreateWithCString.restype = CFStringRef
+    CF.CFStringCreateWithCString.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_uint32]
+    CF.CFStringGetCString.restype = ctypes.c_bool
+    CF.CFStringGetCString.argtypes = [CFStringRef, ctypes.c_char_p, CFIndex, ctypes.c_uint32]
+    CF.CFDictionaryGetValue.restype = ctypes.c_void_p
+    CF.CFDictionaryGetValue.argtypes = [CFDictionaryRef, ctypes.c_void_p]
+    CF.CFArrayGetCount.restype = CFIndex
+    CF.CFArrayGetCount.argtypes = [CFArrayRef]
+    CF.CFArrayGetValueAtIndex.restype = ctypes.c_void_p
+    CF.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]
+
+    def cf_str(t):
+        return CF.CFStringCreateWithCString(None, t.encode('utf-8'), 0x08000100)
+
+    def cf_to_str(c):
+        if not c: return ''
+        b = ctypes.create_string_buffer(128)
+        return b.value.decode('utf-8') if CF.CFStringGetCString(c, b, 128, 0x08000100) else ''
+
+    libIOReport.IOReportCopyChannelsInGroup.restype = CFDictionaryRef
+    libIOReport.IOReportCopyChannelsInGroup.argtypes = [CFStringRef, CFStringRef, ctypes.c_uint64, ctypes.c_uint64, ctypes.c_uint64]
+    libIOReport.IOReportCreateSubscription.restype = ctypes.c_void_p
+    libIOReport.IOReportCreateSubscription.argtypes = [ctypes.c_void_p, CFDictionaryRef, ctypes.POINTER(CFDictionaryRef), ctypes.c_uint64, ctypes.c_void_p]
+    libIOReport.IOReportCreateSamples.restype = CFDictionaryRef
+    libIOReport.IOReportCreateSamples.argtypes = [ctypes.c_void_p, CFDictionaryRef, ctypes.c_void_p]
+    libIOReport.IOReportCreateSamplesDelta.restype = CFDictionaryRef
+    libIOReport.IOReportCreateSamplesDelta.argtypes = [CFDictionaryRef, CFDictionaryRef, ctypes.c_void_p]
+    libIOReport.IOReportChannelGetChannelName.restype = CFStringRef
+    libIOReport.IOReportChannelGetChannelName.argtypes = [CFDictionaryRef]
+    libIOReport.IOReportChannelGetUnitLabel.restype = CFStringRef
+    libIOReport.IOReportChannelGetUnitLabel.argtypes = [CFDictionaryRef]
+    libIOReport.IOReportSimpleGetIntegerValue.restype = ctypes.c_int64
+    libIOReport.IOReportSimpleGetIntegerValue.argtypes = [CFDictionaryRef, ctypes.c_int32]
+
+    ch = libIOReport.IOReportCopyChannelsInGroup(cf_str('Energy Model'), None, 0, 0, 0)
+    sub_ch = CFDictionaryRef()
+    sub = libIOReport.IOReportCreateSubscription(None, ch, ctypes.byref(sub_ch), 0, None)
+    s1 = libIOReport.IOReportCreateSamples(sub, sub_ch, None)
+    dt = 0.08
+    time.sleep(dt)
+    s2 = libIOReport.IOReportCreateSamples(sub, sub_ch, None)
+    delta = libIOReport.IOReportCreateSamplesDelta(s1, s2, None)
+    arr = CF.CFDictionaryGetValue(delta, cf_str('IOReportChannels'))
+    cnt = CF.CFArrayGetCount(arr)
+    cpu_w = 0.0
+    gpu_w = 0.0
+    ane_w = 0.0
+    for i in range(cnt):
+        item = CF.CFArrayGetValueAtIndex(arr, i)
+        n = cf_to_str(libIOReport.IOReportChannelGetChannelName(item))
+        if n in ('GPU Energy', 'CPU Energy', 'ANE'):
+            u = cf_to_str(libIOReport.IOReportChannelGetUnitLabel(item))
+            v = libIOReport.IOReportSimpleGetIntegerValue(item, 0)
+            sc = 1e9 if u == 'nJ' else (1e6 if u == 'uJ' else 1e3)
+            w = round((v / sc) / dt, 2)
+            if n == 'CPU Energy': cpu_w = w
+            elif n == 'GPU Energy': gpu_w = w
+            elif n == 'ANE': ane_w = w
+    combined_w = round(cpu_w + gpu_w + ane_w, 2)
+    print(json.dumps({'cpuWatts': cpu_w, 'gpuWatts': gpu_w, 'aneWatts': ane_w, 'combinedWatts': combined_w}))
+except Exception:
+    print('{}')

package/dist/netUsageCmd-WKBTW2YG.js

@@ -0,0 +1,90 @@
+import {
+  formatBytes
+} from "./chunk-6UHZP4QP.js";
+import "./chunk-ZLVIVFSO.js";
+import {
+  collectPackets
+} from "./chunk-GHRDW646.js";
+import "./chunk-M73HCQD2.js";
+import "./chunk-VIACN2RU.js";
+import "./chunk-MZO5QKUR.js";
+
+// src/netUsageCmd.ts
+import chalk from "chalk";
+async function runNetUsageCommand(opts = {}) {
+  const topCount = opts.top || 15;
+  const sortKey = opts.sort || "total";
+  const packetData = await collectPackets();
+  if (!packetData || !packetData.allProcesses || packetData.allProcesses.length === 0) {
+    if (opts.json) {
+      console.log(JSON.stringify({ processes: [], totalRx: 0, totalTx: 0 }));
+      return;
+    }
+    console.log(chalk.yellow("\n  \u26A0 No active per-application network sockets detected."));
+    console.log(chalk.dim("  Ensure network activity is present or run with elevated permissions if required.\n"));
+    return;
+  }
+  const appMap = /* @__PURE__ */ new Map();
+  for (const proc of packetData.allProcesses) {
+    const key = proc.command || `pid-${proc.pid}`;
+    const rx = proc.rxBytes || 0;
+    const tx = proc.txBytes || 0;
+    const conns = proc.connections ? proc.connections.length : 0;
+    const existing = appMap.get(key);
+    if (existing) {
+      existing.rxBytes += rx;
+      existing.txBytes += tx;
+      existing.totalBytes += rx + tx;
+      existing.connections += conns;
+    } else {
+      appMap.set(key, {
+        pid: proc.pid,
+        command: key,
+        rxBytes: rx,
+        txBytes: tx,
+        totalBytes: rx + tx,
+        connections: conns
+      });
+    }
+  }
+  const sorted = Array.from(appMap.values()).sort((a, b) => {
+    if (sortKey === "rx") return b.rxBytes - a.rxBytes;
+    if (sortKey === "tx") return b.txBytes - a.txBytes;
+    return b.totalBytes - a.totalBytes;
+  });
+  const displayList = sorted.slice(0, topCount);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      totalRx: packetData.rxPackets,
+      totalTx: packetData.txPackets,
+      activeConnections: packetData.connections,
+      processes: displayList
+    }, null, 2));
+    return;
+  }
+  console.log(chalk.bold("\n  \u{1F525} pyre netusage \u2014 Per-Application Network Traffic\n"));
+  const pidW = 8;
+  const appW = 28;
+  const rxW = 14;
+  const txW = 14;
+  const totalW = 14;
+  const connsW = 8;
+  const header = chalk.bold.hex("#f8f8f2").bgHex("#44475a")(" PID    ") + chalk.bold.hex("#f8f8f2").bgHex("#44475a")(" APPLICATION                ") + chalk.bold.hex("#f8f8f2").bgHex("#44475a")(" DOWN (RX)    ") + chalk.bold.hex("#f8f8f2").bgHex("#44475a")(" UP (TX)      ") + chalk.bold.hex("#f8f8f2").bgHex("#44475a")(" TOTAL        ") + chalk.bold.hex("#f8f8f2").bgHex("#44475a")(" CONNS  ");
+  console.log("  " + header);
+  console.log("  " + chalk.dim("\u2500".repeat(pidW + appW + rxW + txW + totalW + connsW)));
+  for (const p of displayList) {
+    const pidStr = String(p.pid).padEnd(pidW);
+    const appStr = (p.command.length > appW - 2 ? p.command.slice(0, appW - 3) + "\u2026" : p.command).padEnd(appW);
+    const rxStr = chalk.green(formatBytes(p.rxBytes).padStart(rxW - 2)) + "  ";
+    const txStr = chalk.cyan(formatBytes(p.txBytes).padStart(txW - 2)) + "  ";
+    const totStr = chalk.bold(formatBytes(p.totalBytes).padStart(totalW - 2)) + "  ";
+    const connsStr = String(p.connections).padStart(connsW - 2);
+    console.log(`  ${pidStr}${appStr}${rxStr}${txStr}${totStr}${connsStr}`);
+  }
+  console.log();
+  console.log(chalk.dim(`  Total active socket connections: ${chalk.bold(String(packetData.connections))}  |  Showing top ${displayList.length} apps`));
+  console.log();
+}
+export {
+  runNetUsageCommand
+};

package/dist/{pipeCmd-7THXEGDH.js → pipeCmd-7REDBLBU.js}

@@ -1,8 +1,10 @@
-import "./chunk-SG26Y3WF.js";
+import "./chunk-IM3IQMMT.js";
 import {
   collectAll
-} from "./chunk-HGRBBPYX.js";
-import "./chunk-FH5WDJBF.js";
+} from "./chunk-GHRDW646.js";
+import "./chunk-M73HCQD2.js";
+import "./chunk-VIACN2RU.js";
+import "./chunk-MZO5QKUR.js";
 
 // src/pipeCmd.ts
 async function runPipeCommand(opts = {}) {

package/dist/profileProcCmd-N4H6MCBT.js

@@ -0,0 +1,107 @@
+// src/profileProcCmd.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+var execFileAsync = promisify(execFile);
+async function runProfileProcCommand(opts) {
+  const { pid, durationSec = 5, raw } = opts;
+  if (isNaN(pid) || pid <= 0) {
+    console.error(chalk.red("\n  \u2716 Error: Valid PID is required. Usage: pyre profile-proc <pid> [--duration <sec>]\n"));
+    process.exit(1);
+  }
+  try {
+    process.kill(pid, 0);
+  } catch {
+    console.error(chalk.red(`
+  \u2716 Error: Process with PID ${pid} is not running or accessible.
+`));
+    process.exit(1);
+  }
+  console.log(chalk.bold(`
+  \u{1F525} pyre profile-proc \u2014 Profiling PID ${pid} for ${durationSec}s...
+`));
+  let sampleOutput = "";
+  let usedFallback = false;
+  if (process.platform === "darwin") {
+    try {
+      const { stdout } = await execFileAsync("sample", [String(pid), String(durationSec), "-file", "/dev/stdout"], {
+        timeout: (durationSec + 5) * 1e3,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      sampleOutput = stdout;
+    } catch (err) {
+      sampleOutput = err.stdout || "";
+    }
+  }
+  if (!sampleOutput || sampleOutput.length < 100) {
+    usedFallback = true;
+    try {
+      const { stdout } = await execFileAsync("ps", ["-M", "-p", String(pid), "-o", "pid,thread,pcpu,pmem,state,time,command"]);
+      sampleOutput = stdout;
+    } catch {
+      sampleOutput = `Process PID ${pid} active. Deep stack sampling requires elevated permissions or user-owned process.`;
+    }
+  }
+  if (raw) {
+    console.log(sampleOutput);
+    return;
+  }
+  if (!usedFallback) {
+    const lines = sampleOutput.split("\n");
+    const headerLines = [];
+    const stackLines = [];
+    let inCallGraph = false;
+    for (const line of lines) {
+      if (line.includes("Analysis of sampling") || line.includes("Process:") || line.includes("Path:") || line.includes("Identifier:")) {
+        headerLines.push(line.trim());
+      }
+      if (line.includes("Call graph:") || line.includes("+ Line Coverage")) {
+        inCallGraph = true;
+        continue;
+      }
+      if (inCallGraph) {
+        if (line.includes("Total number in stack") || line.includes("Binary Images:")) {
+          inCallGraph = false;
+        } else if (line.trim().length > 0 && stackLines.length < 35) {
+          stackLines.push(line);
+        }
+      }
+    }
+    if (headerLines.length > 0) {
+      console.log(chalk.dim("  Process Info:"));
+      for (const h of headerLines.slice(0, 4)) {
+        console.log(`    ${chalk.cyan(h)}`);
+      }
+      console.log();
+    }
+    console.log(chalk.bold("  Top Call Stacks & Hot Functions:"));
+    console.log(chalk.dim("  " + "\u2500".repeat(70)));
+    if (stackLines.length === 0) {
+      for (const l of lines.slice(0, 20)) {
+        if (l.trim()) console.log(`  ${l}`);
+      }
+    } else {
+      for (const l of stackLines) {
+        if (l.includes("???")) {
+          console.log(chalk.dim(`  ${l}`));
+        } else if (l.includes("+")) {
+          console.log(chalk.yellow(`  ${l}`));
+        } else {
+          console.log(`  ${l}`);
+        }
+      }
+    }
+  } else {
+    console.log(chalk.yellow("  Note: Kernel/SIP restriction prevented deep call-graph unwind."));
+    console.log(chalk.dim("  Showing process thread snapshot:\n"));
+    for (const l of sampleOutput.split("\n")) {
+      if (l.trim()) console.log(`    ${l}`);
+    }
+  }
+  console.log();
+  console.log(chalk.green(`  \u2714 Sampling complete for PID ${pid} (${durationSec}s profile duration).`));
+  console.log();
+}
+export {
+  runProfileProcCommand
+};

package/dist/prometheus-5BL5PVLC.js

@@ -0,0 +1,6 @@
+import {
+  formatPrometheusMetrics
+} from "./chunk-HT4VQ4OH.js";
+export {
+  formatPrometheusMetrics
+};

package/dist/prometheusCmd-PL64BLN5.js

@@ -0,0 +1,93 @@
+import {
+  formatPrometheusMetrics
+} from "./chunk-HT4VQ4OH.js";
+import "./chunk-IM3IQMMT.js";
+import {
+  collectAll
+} from "./chunk-GHRDW646.js";
+import "./chunk-M73HCQD2.js";
+import "./chunk-VIACN2RU.js";
+import "./chunk-MZO5QKUR.js";
+
+// src/prometheusCmd.ts
+import http from "http";
+import os from "os";
+import chalk from "chalk";
+async function runPrometheusServer(opts) {
+  const { port, interval, detailed } = opts;
+  let latestData = await collectAll({ detailed });
+  let lastCollect = Date.now();
+  const refreshTimer = setInterval(async () => {
+    try {
+      latestData = await collectAll({ detailed });
+      lastCollect = Date.now();
+    } catch {
+    }
+  }, interval * 1e3);
+  const server = http.createServer(async (req, res) => {
+    const url = req.url?.split("?")[0] ?? "/";
+    if (url === "/metrics") {
+      try {
+        if (Date.now() - lastCollect > interval * 2e3) {
+          latestData = await collectAll({ detailed });
+          lastCollect = Date.now();
+        }
+        const body = formatPrometheusMetrics(latestData);
+        res.writeHead(200, {
+          "Content-Type": "text/plain; version=0.0.4; charset=utf-8",
+          "Content-Length": Buffer.byteLength(body)
+        });
+        res.end(body);
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end(`# collection error: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+      return;
+    }
+    if (url === "/health" || url === "/api/health") {
+      const body = JSON.stringify({ status: "ok", uptime: os.uptime(), timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(body);
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not found. Available endpoints: /metrics  /health\n");
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(chalk.red(`  \u2716 Port ${port} is already in use. Try --prometheus-port <other-port>`));
+    } else {
+      console.error(chalk.red(`  \u2716 Server error: ${err.message}`));
+    }
+    clearInterval(refreshTimer);
+    process.exit(1);
+  });
+  await new Promise((resolve) => server.listen(port, "0.0.0.0", resolve));
+  console.log(chalk.bold("\n  \u{1F525} pyre \u2014 Prometheus Exporter\n"));
+  console.log(`  ${chalk.green("\u2714")} Metrics endpoint: ${chalk.cyan(`http://0.0.0.0:${port}/metrics`)}`);
+  console.log(`  ${chalk.green("\u2714")} Health endpoint:  ${chalk.cyan(`http://0.0.0.0:${port}/health`)}`);
+  console.log(`  ${chalk.dim(`Refresh interval: ${interval}s  |  Detailed mode: ${detailed ? "on" : "off"}`)}`);
+  console.log(`
+  ${chalk.dim("Add to prometheus.yml:")}`);
+  console.log(chalk.dim(`    - job_name: 'pyre'`));
+  console.log(chalk.dim(`      static_configs:`));
+  console.log(chalk.dim(`        - targets: ['localhost:${port}']`));
+  console.log(`
+  ${chalk.dim("Press Ctrl+C to stop.")}
+`);
+  const shutdown = () => {
+    clearInterval(refreshTimer);
+    server.close(() => {
+      console.log(chalk.dim("\n  Prometheus server stopped."));
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+export {
+  runPrometheusServer
+};

package/dist/replayCmd-Z3PYXY7V.js

@@ -0,0 +1,164 @@
+// src/replayCmd.ts
+import fs from "fs";
+import readline from "readline";
+import chalk from "chalk";
+function parseLogFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const rows = [];
+  for (const line of content.split("\n").slice(1)) {
+    if (!line.trim()) continue;
+    const parts = line.split(",");
+    if (parts.length < 3) continue;
+    const cpuUsage = parseFloat(parts[1]);
+    const memUsage = parseFloat(parts[2]);
+    if (isNaN(cpuUsage) || isNaN(memUsage)) continue;
+    rows.push({
+      timestamp: parts[0]?.trim() ?? "",
+      cpuUsage,
+      memUsage,
+      tempC: parts[3] ? parseFloat(parts[3]) || void 0 : void 0,
+      rxBytes: parts[4] ? parseFloat(parts[4]) || void 0 : void 0,
+      txBytes: parts[5] ? parseFloat(parts[5]) || void 0 : void 0,
+      rxPackets: parts[6] ? parseFloat(parts[6]) || void 0 : void 0,
+      txPackets: parts[7] ? parseFloat(parts[7]) || void 0 : void 0,
+      connections: parts[8] ? parseInt(parts[8], 10) || void 0 : void 0,
+      thermalState: parts[9]?.trim() || void 0
+    });
+  }
+  return rows;
+}
+function fmtBytes(bytes) {
+  if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
+  if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)} MB`;
+  if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(0)} KB`;
+  return `${bytes} B`;
+}
+function bar(pct, width = 20) {
+  const filled = Math.max(0, Math.min(Math.round(pct / 100 * width), width));
+  const color = pct >= 90 ? chalk.red : pct >= 70 ? chalk.yellow : chalk.green;
+  return color("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(width - filled));
+}
+function renderFrame(row, idx, total, speed, paused, cols) {
+  const lines = [];
+  const divider = chalk.dim("\u2500".repeat(Math.min(cols - 2, 78)));
+  lines.push("");
+  lines.push(chalk.bold.hex("#ff5500")("  \u{1F525} pyre replay") + "  " + chalk.dim(row.timestamp || ""));
+  lines.push("  " + divider);
+  lines.push("");
+  lines.push(`  CPU        ${bar(row.cpuUsage)} ${String(row.cpuUsage.toFixed(1)).padStart(5)}%`);
+  lines.push(`  Memory     ${bar(row.memUsage)} ${String(row.memUsage.toFixed(1)).padStart(5)}%`);
+  if (row.tempC !== void 0 && !isNaN(row.tempC)) {
+    const tc = row.tempC >= 90 ? chalk.red : row.tempC >= 70 ? chalk.yellow : chalk.cyan;
+    lines.push(`  Temp       ${tc(`${row.tempC.toFixed(1)}\xB0C`)}`);
+  }
+  if (row.rxBytes !== void 0 || row.txBytes !== void 0) {
+    const rx = row.rxBytes !== void 0 ? fmtBytes(row.rxBytes) : "N/A";
+    const tx = row.txBytes !== void 0 ? fmtBytes(row.txBytes) : "N/A";
+    lines.push(`  Network    \u2193 ${chalk.green(rx)}  \u2191 ${chalk.blue(tx)}`);
+  }
+  if (row.connections !== void 0) {
+    lines.push(`  Conns      ${chalk.cyan(String(row.connections))}`);
+  }
+  if (row.thermalState && row.thermalState !== "Nominal") {
+    const sc = row.thermalState === "Critical" ? chalk.red : chalk.yellow;
+    lines.push(`  Thermal    ${sc(row.thermalState)}`);
+  }
+  lines.push("");
+  lines.push("  " + divider);
+  const progWidth = 30;
+  const progress = total > 1 ? Math.round(idx / (total - 1) * progWidth) : 0;
+  const progressBar = chalk.cyan("\u2588".repeat(progress)) + chalk.dim("\u2591".repeat(progWidth - progress));
+  const icon = paused ? chalk.yellow("\u23F8") : chalk.green("\u25B6");
+  const spStr = speed === 1 ? "1\xD7" : `${speed}\xD7`;
+  lines.push(`  ${icon} ${progressBar}  ${chalk.bold(`${idx + 1}/${total}`)}  ${chalk.dim(spStr)}`);
+  lines.push("");
+  lines.push(chalk.dim("  Space/p=pause  ]/[=speed  \u2190/\u2192=step  q=quit"));
+  return lines;
+}
+async function runReplayCommand(opts) {
+  const { file, speed: initialSpeed = 1, plain } = opts;
+  if (!fs.existsSync(file)) {
+    console.error(chalk.red(`  \u2716 File not found: ${file}`));
+    process.exit(1);
+  }
+  let rows;
+  try {
+    rows = parseLogFile(file);
+  } catch (err) {
+    console.error(chalk.red(`  \u2716 Could not parse log file: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+  if (rows.length === 0) {
+    console.log(chalk.yellow("  No data rows found in the log file."));
+    return;
+  }
+  if (plain) chalk.level = 0;
+  let frameIdx = 0;
+  let speed = initialSpeed;
+  let paused = false;
+  let running = true;
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  readline.emitKeypressEvents(process.stdin);
+  const cols = process.stdout.columns || 80;
+  process.stdout.write("\x1B[?25l\x1B[2J\x1B[H");
+  function renderCurrent() {
+    const lines = renderFrame(rows[frameIdx], frameIdx, rows.length, speed, paused, cols);
+    process.stdout.write("\x1B[H" + lines.map((l) => `\x1B[2K${l}`).join("\r\n") + "\x1B[0J");
+  }
+  renderCurrent();
+  process.stdin.on("keypress", (str, key) => {
+    if (!key) return;
+    if (key.ctrl && key.name === "c" || key.name === "q") {
+      running = false;
+      process.stdout.write("\x1B[?25h\x1B[2J\x1B[H");
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.exit(0);
+    }
+    if (key.name === "space" || key.name === "p") {
+      paused = !paused;
+      renderCurrent();
+      return;
+    }
+    if (str === "]") {
+      speed = Math.min(speed * 2, 32);
+      renderCurrent();
+      return;
+    }
+    if (str === "[") {
+      speed = Math.max(speed / 2, 0.125);
+      renderCurrent();
+      return;
+    }
+    if (key.name === "right") {
+      frameIdx = Math.min(frameIdx + 1, rows.length - 1);
+      renderCurrent();
+      return;
+    }
+    if (key.name === "left") {
+      frameIdx = Math.max(frameIdx - 1, 0);
+      renderCurrent();
+      return;
+    }
+  });
+  const BASE_MS = 2e3;
+  const tick = () => {
+    if (!running) return;
+    if (!paused) {
+      frameIdx++;
+      if (frameIdx >= rows.length) {
+        paused = true;
+        frameIdx = rows.length - 1;
+      }
+      renderCurrent();
+    }
+    setTimeout(tick, BASE_MS / speed);
+  };
+  setTimeout(tick, BASE_MS / speed);
+  await new Promise(() => {
+  });
+}
+export {
+  runReplayCommand
+};

package/dist/run-HOGQDDTA.js

@@ -0,0 +1,8 @@
+import {
+  run,
+  runPowerShell
+} from "./chunk-MZO5QKUR.js";
+export {
+  run,
+  runPowerShell
+};