omniagent 0.1.7 → 0.1.8

package/dist/pty-CZBSAJzE.js

@@ -0,0 +1,362 @@
+import { constants } from "node:fs";
+import { access, chmod } from "node:fs/promises";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import headless from "@xterm/headless";
+import pty from "node-pty";
+const { Terminal } = headless;
+const require$1 = createRequire(import.meta.url);
+class PtyScenarioError extends Error {
+  command;
+  args;
+  timedOut;
+  raw;
+  screen;
+  snapshots;
+  debug;
+  constructor(message, options) {
+    super(message);
+    this.name = "PtyScenarioError";
+    this.command = options.command;
+    this.args = options.args;
+    this.timedOut = options.timedOut;
+    this.raw = options.raw;
+    this.screen = options.screen;
+    this.snapshots = options.snapshots;
+    this.debug = options.debug;
+  }
+}
+function enterKey() {
+  return os.platform() === "win32" ? "\r" : "\r";
+}
+function escapeKey() {
+  return "\x1B";
+}
+function typeTextSteps(text, delayMs) {
+  return [...text].map((char) => ({ write: char, waitMs: delayMs }));
+}
+function createHeadlessTerminal(cols = 100, rows = 40) {
+  return new Terminal({
+    allowProposedApi: true,
+    cols,
+    rows,
+    scrollback: 1e3
+  });
+}
+async function runPtyScenario(options) {
+  const args = options.args ?? [];
+  const cols = options.cols ?? 100;
+  const rows = options.rows ?? 40;
+  const terminal = createHeadlessTerminal(cols, rows);
+  const snapshots = {};
+  let raw = "";
+  let exited = false;
+  let exitCode = null;
+  let timedOut = false;
+  let child = null;
+  let terminalDataDisposable = null;
+  let terminalBinaryDisposable = null;
+  let timeout = null;
+  let removeAbortListener = null;
+  let cancelScenario = null;
+  const timeoutMs = options.timeoutMs ?? 45e3;
+  const buildScenarioError = (message) => new PtyScenarioError(message, {
+    command: options.command,
+    args,
+    timedOut,
+    raw,
+    screen: readScreen(terminal),
+    snapshots: { ...snapshots },
+    debug: buildDebugArtifacts({
+      options,
+      args,
+      raw,
+      screen: readScreen(terminal),
+      snapshots
+    })
+  });
+  const cancellationPromise = new Promise((_, reject) => {
+    cancelScenario = (message) => {
+      if (!exited) {
+        timedOut = true;
+        if (child) {
+          safeKillPty(child);
+        }
+      }
+      reject(buildScenarioError(message));
+    };
+  });
+  cancellationPromise.catch(() => {
+  });
+  if (options.signal) {
+    const abortHandler = () => {
+      cancelScenario?.(formatAbortReason(options.signal, timeoutMs));
+    };
+    if (options.signal.aborted) {
+      abortHandler();
+    } else {
+      options.signal.addEventListener("abort", abortHandler, { once: true });
+      removeAbortListener = () => options.signal?.removeEventListener("abort", abortHandler);
+    }
+  } else {
+    timeout = setTimeout(() => {
+      cancelScenario?.(`PTY scenario timed out after ${formatDuration(timeoutMs)}.`);
+    }, timeoutMs);
+  }
+  const withScenarioTimeout = async (promise) => Promise.race([promise, cancellationPromise]);
+  const throwIfTimedOut = () => {
+    if (timedOut) {
+      throw buildScenarioError(`PTY scenario timed out after ${formatDuration(timeoutMs)}.`);
+    }
+  };
+  try {
+    await withScenarioTimeout(ensureNodePtySpawnHelperExecutable());
+    child = pty.spawn(options.command, args, {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd: options.cwd ?? process.cwd(),
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        ...options.env
+      }
+    });
+    terminalDataDisposable = terminal.onData((data) => {
+      if (!exited && child) {
+        child.write(data);
+      }
+    });
+    terminalBinaryDisposable = terminal.onBinary((data) => {
+      if (!exited && child) {
+        child.write(data);
+      }
+    });
+    child.onData((chunk) => {
+      raw += chunk;
+      terminal.write(chunk);
+    });
+    child.onExit((event) => {
+      exited = true;
+      exitCode = event.exitCode;
+    });
+    if (!exited) {
+      throwIfTimedOut();
+    }
+    for (const step of options.steps) {
+      throwIfTimedOut();
+      if (step.skipIf != null && matchesWaitFor(
+        step.skipIf,
+        step.skipIfSource ?? "raw",
+        () => raw,
+        () => readScreen(terminal)
+      )) {
+        continue;
+      }
+      if (step.waitMs != null) {
+        await withScenarioTimeout(sleep(step.waitMs));
+        throwIfTimedOut();
+      }
+      if (step.write != null) {
+        throwIfTimedOut();
+        child.write(step.write);
+      }
+      if (step.waitFor != null) {
+        const matched = await withScenarioTimeout(
+          waitForOutput({
+            match: step.waitFor,
+            source: step.waitForSource ?? "raw",
+            timeoutMs: step.waitForTimeoutMs ?? options.timeoutMs ?? 45e3,
+            getRaw: () => raw,
+            getScreen: () => readScreen(terminal)
+          })
+        );
+        throwIfTimedOut();
+        if (!matched && !step.optional) {
+          throw buildScenarioError(
+            `Timed out waiting for ${step.capture ?? "expected TUI output"}.`
+          );
+        }
+      }
+      if (step.capture != null) {
+        await withScenarioTimeout(sleep(step.captureWaitMs ?? 250));
+        throwIfTimedOut();
+        snapshots[step.capture] = {
+          raw,
+          screen: readScreen(terminal)
+        };
+      }
+    }
+    await withScenarioTimeout(sleep(options.finalWaitMs ?? 250));
+    throwIfTimedOut();
+    const screen = readScreen(terminal);
+    const debug = buildDebugArtifacts({ options, args, raw, screen, snapshots });
+    return {
+      command: options.command,
+      args,
+      exitCode,
+      timedOut,
+      raw,
+      screen,
+      snapshots,
+      debug
+    };
+  } catch (error) {
+    if (error instanceof PtyScenarioError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw buildScenarioError(message);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    removeAbortListener?.();
+    terminalDataDisposable?.dispose();
+    terminalBinaryDisposable?.dispose();
+    if (!exited && child) {
+      safeKillPty(child);
+    }
+    terminal.dispose();
+  }
+}
+function formatAbortReason(signal, timeoutMs) {
+  const reason = signal?.reason;
+  if (reason instanceof Error) {
+    return reason.message;
+  }
+  if (typeof reason === "string" && reason.trim().length > 0) {
+    return reason;
+  }
+  return `PTY scenario timed out after ${formatDuration(timeoutMs)}.`;
+}
+function readScreen(terminal) {
+  const buffer = terminal.buffer.active;
+  const lines = [];
+  for (let i = 0; i < buffer.length; i += 1) {
+    const line = buffer.getLine(i);
+    if (line == null) {
+      continue;
+    }
+    lines.push(line.translateToString(true));
+  }
+  return lines.join("\n");
+}
+function safeKillPty(child) {
+  try {
+    child.kill();
+  } catch {
+  }
+}
+function formatCommand(command, args) {
+  return [command, ...args].join(" ");
+}
+function buildDebugArtifacts(options) {
+  if (!options.options.debug?.enabled) {
+    return [];
+  }
+  const debug = [];
+  if (options.options.debug.includeRawOutput) {
+    debug.push({
+      type: "raw-output",
+      label: "pty.raw",
+      content: options.raw,
+      command: formatCommand(options.options.command, options.args)
+    });
+  }
+  if (options.options.debug.includeScreenSnapshots) {
+    for (const [label, snapshot] of Object.entries(options.snapshots)) {
+      debug.push({
+        type: "screen-snapshot",
+        label,
+        content: snapshot.screen,
+        mimeType: "text/plain"
+      });
+    }
+    debug.push({
+      type: "screen-snapshot",
+      label: "final",
+      content: options.screen,
+      mimeType: "text/plain"
+    });
+  }
+  return debug;
+}
+function formatDuration(timeoutMs) {
+  if (timeoutMs % 6e4 === 0) {
+    return `${timeoutMs / 6e4}m`;
+  }
+  if (timeoutMs % 1e3 === 0) {
+    return `${timeoutMs / 1e3}s`;
+  }
+  return `${timeoutMs}ms`;
+}
+async function waitForOutput(options) {
+  const intervalMs = 50;
+  const deadline = Date.now() + options.timeoutMs;
+  while (Date.now() <= deadline) {
+    if (matchesWaitFor(options.match, options.source, options.getRaw, options.getScreen)) {
+      return true;
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      break;
+    }
+    await sleep(Math.min(intervalMs, remainingMs));
+  }
+  return matchesWaitFor(options.match, options.source, options.getRaw, options.getScreen);
+}
+function matchesWaitFor(match, source, getRaw, getScreen) {
+  if (typeof match === "function") {
+    return match({ raw: getRaw(), screen: getScreen() });
+  }
+  const value = source === "screen" ? getScreen() : getRaw();
+  if (typeof match === "string") {
+    return value.includes(match);
+  }
+  match.lastIndex = 0;
+  return match.test(value);
+}
+async function ensureNodePtySpawnHelperExecutable() {
+  if (process.platform === "win32") {
+    return;
+  }
+  const packageRoot = path.dirname(require$1.resolve("node-pty/package.json"));
+  const candidates = [
+    path.join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
+    path.join(packageRoot, "build", "Release", "spawn-helper")
+  ];
+  for (const candidate of candidates) {
+    if (!await fileExists(candidate)) {
+      continue;
+    }
+    try {
+      await access(candidate, constants.X_OK);
+      return;
+    } catch {
+      try {
+        await chmod(candidate, 493);
+        return;
+      } catch {
+      }
+    }
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  escapeKey as a,
+  enterKey as e,
+  runPtyScenario as r,
+  typeTextSteps as t
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniagent",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Unified agent configuration CLI that compiles canonical agent configs to multiple runtimes.",
   "type": "module",
   "bin": {
@@ -43,8 +43,10 @@
   "author": "plsdontemailme@joeroddy.net",
   "license": "MIT",
   "dependencies": {
+    "@xterm/headless": "^5.5.0",
     "jiti": "^2.6.1",
     "minimatch": "^10.2.5",
+    "node-pty": "^1.0.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {