parallel-codex-tui 0.1.3 → 0.1.4

package/dist/tui/theme-contrast.js

@@ -0,0 +1,144 @@
+export const TUI_THEME_MIN_CONTRAST_RATIO = 4.5;
+export const TUI_THEME_RENDERED_CONTRAST_PAIRS = Object.freeze([
+    ["text", "chrome"],
+    ["muted", "chrome"],
+    ["accent", "chrome"],
+    ["text", "surface"],
+    ["muted", "surface"],
+    ["accent", "surface"],
+    ["warning", "surface"],
+    ["success", "surface"],
+    ["text", "rail"],
+    ["muted", "rail"],
+    ["accent", "rail"],
+    ["warning", "rail"],
+    ["success", "rail"],
+    ["danger", "rail"],
+    ["success", "successSurface"],
+    ["danger", "dangerSurface"]
+]);
+const ANSI_16_RGB = Object.freeze([
+    [0, 0, 0],
+    [205, 0, 0],
+    [0, 205, 0],
+    [205, 205, 0],
+    [0, 0, 238],
+    [205, 0, 205],
+    [0, 205, 205],
+    [229, 229, 229],
+    [127, 127, 127],
+    [255, 0, 0],
+    [0, 255, 0],
+    [255, 255, 0],
+    [92, 92, 255],
+    [255, 0, 255],
+    [0, 255, 255],
+    [255, 255, 255]
+]);
+const NAMED_COLOR_INDEX = Object.freeze({
+    black: 0,
+    red: 1,
+    green: 2,
+    yellow: 3,
+    blue: 4,
+    magenta: 5,
+    cyan: 6,
+    white: 7,
+    blackBright: 8,
+    gray: 8,
+    grey: 8,
+    redBright: 9,
+    greenBright: 10,
+    yellowBright: 11,
+    blueBright: 12,
+    magentaBright: 13,
+    cyanBright: 14,
+    whiteBright: 15
+});
+export function auditTuiThemeContrast(theme) {
+    const measurements = TUI_THEME_RENDERED_CONTRAST_PAIRS.map(([foreground, background]) => ({
+        foreground,
+        background,
+        ratio: tuiThemeContrastRatio(theme[foreground], theme[background])
+    }));
+    return Object.freeze({
+        measurements: Object.freeze(measurements),
+        issues: Object.freeze(measurements.filter(({ ratio }) => ratio < TUI_THEME_MIN_CONTRAST_RATIO)),
+        minimumRatio: Math.min(...measurements.map(({ ratio }) => ratio))
+    });
+}
+export function tuiThemeContrastRatio(foreground, background) {
+    const foregroundRgb = tuiThemeColorRgb(foreground);
+    const backgroundRgb = tuiThemeColorRgb(background);
+    if (!foregroundRgb || !backgroundRgb) {
+        throw new Error(`Cannot measure TUI theme contrast: ${foreground} on ${background}`);
+    }
+    const foregroundLuminance = relativeLuminance(foregroundRgb);
+    const backgroundLuminance = relativeLuminance(backgroundRgb);
+    const lighter = Math.max(foregroundLuminance, backgroundLuminance);
+    const darker = Math.min(foregroundLuminance, backgroundLuminance);
+    return (lighter + 0.05) / (darker + 0.05);
+}
+export function tuiThemeColorRgb(color) {
+    const namedIndex = NAMED_COLOR_INDEX[color];
+    if (namedIndex !== undefined) {
+        return ANSI_16_RGB[namedIndex] ?? null;
+    }
+    const ansiMatch = color.match(/^ansi256\(\s*(\d+)\s*\)$/);
+    if (ansiMatch) {
+        return ansi256Rgb(Number(ansiMatch[1]));
+    }
+    const rgbMatch = color.match(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+    if (rgbMatch) {
+        const rgb = [Number(rgbMatch[1]), Number(rgbMatch[2]), Number(rgbMatch[3])];
+        return rgb.every(isByte) ? rgb : null;
+    }
+    const shortHexMatch = color.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i);
+    if (shortHexMatch) {
+        return [
+            Number.parseInt(`${shortHexMatch[1]}${shortHexMatch[1]}`, 16),
+            Number.parseInt(`${shortHexMatch[2]}${shortHexMatch[2]}`, 16),
+            Number.parseInt(`${shortHexMatch[3]}${shortHexMatch[3]}`, 16)
+        ];
+    }
+    const longHexMatch = color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    if (!longHexMatch) {
+        return null;
+    }
+    return [
+        Number.parseInt(longHexMatch[1] ?? "0", 16),
+        Number.parseInt(longHexMatch[2] ?? "0", 16),
+        Number.parseInt(longHexMatch[3] ?? "0", 16)
+    ];
+}
+function ansi256Rgb(index) {
+    if (!Number.isInteger(index) || index < 0 || index > 255) {
+        return null;
+    }
+    if (index < 16) {
+        return ANSI_16_RGB[index] ?? null;
+    }
+    if (index >= 232) {
+        const channel = 8 + ((index - 232) * 10);
+        return [channel, channel, channel];
+    }
+    const cubeIndex = index - 16;
+    const levels = [0, 95, 135, 175, 215, 255];
+    return [
+        levels[Math.floor(cubeIndex / 36)] ?? 0,
+        levels[Math.floor(cubeIndex / 6) % 6] ?? 0,
+        levels[cubeIndex % 6] ?? 0
+    ];
+}
+function relativeLuminance([red, green, blue]) {
+    const [r, g, b] = [red, green, blue].map((channel) => {
+        const normalized = channel / 255;
+        return normalized <= 0.03928
+            ? normalized / 12.92
+            : ((normalized + 0.055) / 1.055) ** 2.4;
+    });
+    return (0.2126 * (r ?? 0)) + (0.7152 * (g ?? 0)) + (0.0722 * (b ?? 0));
+}
+function isByte(value) {
+    return Number.isInteger(value) && value >= 0 && value <= 255;
+}

package/dist/tui/theme-preview.js

@@ -0,0 +1,109 @@
+import { resolveTuiTheme, TUI_THEME_NAMES } from "./theme.js";
+const ANSI_RESET = "\u001b[0m";
+const NAMED_ANSI_FOREGROUND_CODES = Object.freeze({
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37,
+    gray: 90,
+    grey: 90,
+    blackBright: 90,
+    redBright: 91,
+    greenBright: 92,
+    yellowBright: 93,
+    blueBright: 94,
+    magentaBright: 95,
+    cyanBright: 96,
+    whiteBright: 97
+});
+export function formatTuiThemePreview(theme) {
+    return [
+        `preview: ${[
+            themeSwatch("chrome", theme.chrome, theme.text),
+            themeSwatch("surface", theme.surface, theme.text),
+            themeSwatch("rail", theme.rail, theme.text)
+        ].join(" ")}`,
+        `semantic: ${[
+            themeSwatch("success", theme.successSurface, theme.success),
+            themeSwatch("danger", theme.dangerSurface, theme.danger),
+            themeSwatch("accent", theme.surface, theme.accent),
+            themeSwatch("warning", theme.surface, theme.warning),
+            themeSwatch("muted", theme.surface, theme.muted)
+        ].join(" ")}`
+    ];
+}
+export function formatTuiThemeCatalog(themeNames = TUI_THEME_NAMES) {
+    const lines = ["parallel-codex-tui themes"];
+    for (const themeName of themeNames) {
+        const theme = resolveTuiTheme({ theme: themeName });
+        lines.push(`${themeName}: ${formatTuiThemePalette(theme)}`);
+        lines.push("  palette:");
+        lines.push(...formatTuiThemePaletteGroups(theme).map((line) => `    ${line}`));
+        lines.push(...formatTuiThemePreview(theme).map((line) => `  ${line}`));
+    }
+    return lines;
+}
+export function formatTuiThemePalette(theme) {
+    return [
+        `chrome=${theme.chrome}`,
+        `surface=${theme.surface}`,
+        `rail=${theme.rail}`,
+        `accent=${theme.accent}`
+    ].join(", ");
+}
+export function formatTuiThemePaletteGroups(theme) {
+    return [
+        `chrome=${theme.chrome}, surface=${theme.surface}, rail=${theme.rail}`,
+        `text=${theme.text}, muted=${theme.muted}, accent=${theme.accent}`,
+        `successSurface=${theme.successSurface}, success=${theme.success}, warning=${theme.warning}`,
+        `dangerSurface=${theme.dangerSurface}, danger=${theme.danger}`
+    ];
+}
+function themeSwatch(label, backgroundColor, foregroundColor) {
+    return `${ansiOpen(backgroundColor, "background")}${ansiOpen(foregroundColor, "foreground")} ${label} ${ANSI_RESET}`;
+}
+function ansiOpen(color, mode) {
+    const ansi256Match = color.match(/^ansi256\((\d+)\)$/);
+    if (ansi256Match) {
+        return `\u001b[${modePrefix(mode)};5;${ansi256Match[1]}m`;
+    }
+    const rgbMatch = color.match(/^rgb\((\d+),(\d+),(\d+)\)$/);
+    if (rgbMatch) {
+        return `\u001b[${modePrefix(mode)};2;${rgbMatch[1]};${rgbMatch[2]};${rgbMatch[3]}m`;
+    }
+    const hexRgb = hexToRgb(color);
+    if (hexRgb) {
+        return `\u001b[${modePrefix(mode)};2;${hexRgb.join(";")}m`;
+    }
+    const namedCode = NAMED_ANSI_FOREGROUND_CODES[color];
+    if (namedCode !== undefined) {
+        return `\u001b[${mode === "background" ? namedCode + 10 : namedCode}m`;
+    }
+    return "";
+}
+function modePrefix(mode) {
+    return mode === "background" ? 48 : 38;
+}
+function hexToRgb(color) {
+    const shortMatch = color.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i);
+    if (shortMatch) {
+        return [
+            Number.parseInt(`${shortMatch[1]}${shortMatch[1]}`, 16),
+            Number.parseInt(`${shortMatch[2]}${shortMatch[2]}`, 16),
+            Number.parseInt(`${shortMatch[3]}${shortMatch[3]}`, 16)
+        ];
+    }
+    const longMatch = color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    if (!longMatch) {
+        return null;
+    }
+    return [
+        Number.parseInt(longMatch[1] ?? "0", 16),
+        Number.parseInt(longMatch[2] ?? "0", 16),
+        Number.parseInt(longMatch[3] ?? "0", 16)
+    ];
+}

package/dist/tui/theme.js

@@ -0,0 +1,158 @@
+import { foregroundColorNames } from "chalk";
+const bg = (value) => value;
+const fg = (value) => value;
+export const TUI_THEME_NAMES = Object.freeze(["codex", "graphite", "paper", "aurora", "studio"]);
+export const TUI_THEME_FIELDS = Object.freeze([
+    "chrome",
+    "surface",
+    "rail",
+    "successSurface",
+    "dangerSurface",
+    "text",
+    "muted",
+    "accent",
+    "warning",
+    "success",
+    "danger"
+]);
+export const TUI_THEME_PRESETS = Object.freeze({
+    codex: freezeTuiTheme({
+        chrome: bg("ansi256(233)"),
+        surface: bg("ansi256(234)"),
+        rail: bg("ansi256(236)"),
+        successSurface: bg("ansi256(22)"),
+        dangerSurface: bg("ansi256(52)"),
+        text: fg("ansi256(253)"),
+        muted: fg("ansi256(247)"),
+        accent: fg("ansi256(81)"),
+        warning: fg("ansi256(179)"),
+        success: fg("ansi256(114)"),
+        danger: fg("ansi256(210)")
+    }),
+    graphite: freezeTuiTheme({
+        chrome: bg("ansi256(236)"),
+        surface: bg("ansi256(233)"),
+        rail: bg("ansi256(238)"),
+        successSurface: bg("ansi256(22)"),
+        dangerSurface: bg("ansi256(52)"),
+        text: fg("ansi256(255)"),
+        muted: fg("ansi256(249)"),
+        accent: fg("ansi256(117)"),
+        warning: fg("ansi256(214)"),
+        success: fg("ansi256(150)"),
+        danger: fg("ansi256(217)")
+    }),
+    paper: freezeTuiTheme({
+        chrome: bg("ansi256(254)"),
+        surface: bg("ansi256(231)"),
+        rail: bg("ansi256(255)"),
+        successSurface: bg("ansi256(194)"),
+        dangerSurface: bg("ansi256(224)"),
+        text: fg("ansi256(235)"),
+        muted: fg("ansi256(240)"),
+        accent: fg("ansi256(25)"),
+        warning: fg("ansi256(94)"),
+        success: fg("ansi256(22)"),
+        danger: fg("ansi256(124)")
+    }),
+    aurora: freezeTuiTheme({
+        chrome: bg("ansi256(19)"),
+        surface: bg("ansi256(233)"),
+        rail: bg("ansi256(53)"),
+        successSurface: bg("ansi256(22)"),
+        dangerSurface: bg("ansi256(52)"),
+        text: fg("ansi256(255)"),
+        muted: fg("ansi256(109)"),
+        accent: fg("ansi256(159)"),
+        warning: fg("ansi256(222)"),
+        success: fg("ansi256(121)"),
+        danger: fg("ansi256(210)")
+    }),
+    studio: freezeTuiTheme({
+        chrome: bg("ansi256(236)"),
+        surface: bg("ansi256(235)"),
+        rail: bg("ansi256(238)"),
+        successSurface: bg("ansi256(22)"),
+        dangerSurface: bg("ansi256(52)"),
+        text: fg("ansi256(254)"),
+        muted: fg("ansi256(249)"),
+        accent: fg("ansi256(147)"),
+        warning: fg("ansi256(215)"),
+        success: fg("ansi256(151)"),
+        danger: fg("ansi256(217)")
+    })
+});
+const DEFAULT_TUI_THEME_NAME = "codex";
+export let TUI_THEME = TUI_THEME_PRESETS[DEFAULT_TUI_THEME_NAME];
+export function resolveTuiTheme(options = {}) {
+    const theme = normalizeTuiThemeName(options.theme);
+    const name = theme ?? DEFAULT_TUI_THEME_NAME;
+    return freezeTuiTheme({
+        ...TUI_THEME_PRESETS[name],
+        ...normalizeTuiThemeOverrides(options.colors)
+    });
+}
+export function configureTuiTheme(options = {}) {
+    TUI_THEME = resolveTuiTheme(options);
+    return TUI_THEME;
+}
+export function resetTuiTheme() {
+    TUI_THEME = TUI_THEME_PRESETS[DEFAULT_TUI_THEME_NAME];
+    return TUI_THEME;
+}
+export function isTuiThemeColorValue(value) {
+    return normalizeTuiThemeColorValue(value) !== null;
+}
+export function normalizeTuiThemeColorValue(value) {
+    const color = value?.trim();
+    if (!color) {
+        return null;
+    }
+    if (foregroundColorNames.includes(color)) {
+        return color;
+    }
+    if (/^#[0-9a-f]{3}(?:[0-9a-f]{3})?$/i.test(color)) {
+        return color.toLowerCase();
+    }
+    const ansiMatch = color.match(/^ansi256\(\s*(\d+)\s*\)$/);
+    if (ansiMatch) {
+        const value = normalizeByteColorValue(ansiMatch[1] ?? "");
+        return value !== null ? `ansi256(${value})` : null;
+    }
+    const rgbMatch = color.match(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+    if (rgbMatch) {
+        const parts = [rgbMatch[1] ?? "", rgbMatch[2] ?? "", rgbMatch[3] ?? ""].map(normalizeByteColorValue);
+        return parts.every((value) => value !== null) ? `rgb(${parts.join(",")})` : null;
+    }
+    return null;
+}
+export function isTuiThemeName(value) {
+    return TUI_THEME_NAMES.includes(value);
+}
+export function normalizeTuiThemeName(value) {
+    const name = value?.trim();
+    return isTuiThemeName(name) ? name : null;
+}
+function normalizeByteColorValue(value) {
+    if (!/^\d+$/.test(value)) {
+        return null;
+    }
+    const number = Number(value);
+    return Number.isInteger(number) && number >= 0 && number <= 255 ? String(number) : null;
+}
+function normalizeTuiThemeOverrides(colors) {
+    const normalized = {};
+    if (!colors) {
+        return normalized;
+    }
+    for (const field of TUI_THEME_FIELDS) {
+        const value = normalizeTuiThemeColorValue(colors[field]);
+        if (value) {
+            normalized[field] = value;
+        }
+    }
+    return normalized;
+}
+function freezeTuiTheme(theme) {
+    return Object.freeze(theme);
+}

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.1.3";
+export const version = "0.1.4";

package/dist/workers/capabilities.js

@@ -0,0 +1,212 @@
+import { execFile } from "node:child_process";
+import { basename } from "node:path";
+export async function diagnoseAgentCapabilities(config, env, options) {
+    const targets = capabilityTargets(config, options);
+    const runner = options.runner ?? runCapabilityCommand;
+    const timeoutMs = options.timeoutMs ?? 3000;
+    const reports = await Promise.all(targets.map(async (target) => {
+        if (options.availableCommands && !options.availableCommands.has(target.command)) {
+            return null;
+        }
+        return diagnoseCapabilityTarget(target, config, env, runner, timeoutMs);
+    }));
+    const lines = reports.flatMap((report) => report?.lines ?? []);
+    const ok = reports.every((report) => report?.ok !== false);
+    if (targets.some((target) => target.surfaces.has("native"))) {
+        lines.push("native workspace trust: interactive (confirm only workspaces you trust when prompted)");
+    }
+    return { ok, lines };
+}
+function capabilityTargets(config, options) {
+    const targets = new Map();
+    const addTarget = (engine, command, capabilities, surface) => {
+        const key = `${engine}\0${command}\0${capabilities.profile}`;
+        const current = targets.get(key) ?? { engine, command, capabilities, surfaces: new Set() };
+        current.surfaces.add(surface);
+        targets.set(key, current);
+    };
+    if (options.includeRouter) {
+        addTarget("codex", config.router.codex.command, {
+            profile: "codex",
+            writableDirArgs: [],
+            freshSessionArgs: []
+        }, "automated");
+    }
+    for (const engine of [...new Set(options.workerEngines)]) {
+        const worker = config.workers[engine];
+        addTarget(engine, worker.command, worker.capabilities, "automated");
+        if (worker.nativeSession.enabled) {
+            addTarget(engine, worker.command, worker.capabilities, "resume");
+            addTarget(engine, worker.interactive.command, worker.capabilities, "native");
+        }
+    }
+    return [...targets.values()];
+}
+async function diagnoseCapabilityTarget(target, config, env, runner, timeoutMs) {
+    const configuredIssues = configuredCapabilityIssues(target, config);
+    if (configuredIssues.length > 0) {
+        return {
+            ok: false,
+            lines: [`${capabilityTargetLabel(target)}: incompatible (${configuredIssues.join("; ")})`]
+        };
+    }
+    if (target.capabilities.profile === "generic") {
+        return {
+            ok: true,
+            lines: [`${capabilityTargetLabel(target)}: declared (${genericCapabilitySummary(target)})`]
+        };
+    }
+    const specs = capabilityProbeSpecs(target);
+    const results = await Promise.all(specs.map(async (spec) => ({
+        spec,
+        result: await runner(target.command, spec.args, env, timeoutMs)
+    })));
+    const incompatible = [];
+    const unverified = [];
+    for (const { spec, result } of results) {
+        const output = stripTerminalControl(`${result.stdout}\n${result.stderr}`);
+        if (result.timedOut) {
+            unverified.push(`${spec.label} help timed out`);
+            continue;
+        }
+        if (result.exitCode !== 0 || !spec.usagePattern.test(output)) {
+            unverified.push(`${spec.label} help not recognized`);
+            continue;
+        }
+        const missing = spec.requiredOptions.filter((option) => !output.includes(option));
+        if (missing.length > 0) {
+            incompatible.push(`${spec.label} missing ${missing.join(", ")}`);
+        }
+    }
+    if (target.capabilities.profile === "codex" && target.surfaces.has("native")) {
+        const sandbox = configuredCodexSandbox(config.workers.codex.interactive.args);
+        if (sandbox === "read-only") {
+            incompatible.push("native resume uses read-only but feature attach requires writable --add-dir roots");
+        }
+    }
+    const label = capabilityTargetLabel(target);
+    if (incompatible.length > 0) {
+        return {
+            ok: false,
+            lines: [`${label}: incompatible (${incompatible.join("; ")})`]
+        };
+    }
+    if (unverified.length > 0) {
+        return {
+            ok: true,
+            lines: [`${label}: warning (${unverified.join("; ")}; compatibility unverified)`]
+        };
+    }
+    return {
+        ok: true,
+        lines: [`${label}: ok (${specs.map((spec) => spec.label).join(", ")})`]
+    };
+}
+function capabilityProbeSpecs(target) {
+    if (target.capabilities.profile === "claude") {
+        return [{
+                args: ["--help"],
+                label: "print/resume/permissions/add-dir",
+                requiredOptions: ["--print", "--resume", "--permission-mode", "--add-dir"],
+                usagePattern: /Usage:\s+claude\b/i
+            }];
+    }
+    const specs = [];
+    if (target.surfaces.has("automated")) {
+        specs.push({
+            args: ["exec", "--help"],
+            label: "exec sandbox/add-dir",
+            requiredOptions: ["--sandbox", "--add-dir", "--skip-git-repo-check"],
+            usagePattern: /Usage:\s+codex exec\b/i
+        });
+    }
+    if (target.surfaces.has("resume")) {
+        specs.push({
+            args: ["exec", "resume", "--help"],
+            label: "exec resume",
+            requiredOptions: ["--skip-git-repo-check"],
+            usagePattern: /Usage:\s+codex exec resume\b/i
+        });
+    }
+    if (target.surfaces.has("native")) {
+        specs.push({
+            args: ["resume", "--help"],
+            label: "native resume sandbox/add-dir",
+            requiredOptions: ["--sandbox", "--add-dir"],
+            usagePattern: /Usage:\s+codex resume\b/i
+        });
+    }
+    return specs;
+}
+function configuredCapabilityIssues(target, config) {
+    const worker = config.workers[target.engine];
+    const issues = [];
+    if (target.surfaces.has("resume")
+        && worker.nativeSession.enabled
+        && !worker.nativeSession.resumeArgs.some((arg) => arg.includes("{sessionId}"))) {
+        issues.push("nativeSession.resumeArgs missing {sessionId}");
+    }
+    if (target.surfaces.has("native")
+        && worker.nativeSession.enabled
+        && !worker.interactive.args.some((arg) => arg.includes("{sessionId}"))) {
+        issues.push("interactive.args missing {sessionId}");
+    }
+    return issues;
+}
+function genericCapabilitySummary(target) {
+    const writableDirs = target.capabilities.writableDirArgs.length > 0
+        ? "writable dirs via template"
+        : "process-managed writes";
+    const freshSession = target.capabilities.freshSessionArgs.length > 0
+        ? "client-assigned fresh session"
+        : "output-detected fresh session";
+    const nativeResume = target.surfaces.has("native") || target.surfaces.has("resume")
+        ? "native resume configured"
+        : "fresh runs";
+    return `generic CLI, ${writableDirs}, ${freshSession}, ${nativeResume}`;
+}
+function configuredCodexSandbox(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === "--sandbox" || arg === "-s") {
+            return args[index + 1]?.trim().toLowerCase() || null;
+        }
+        const match = arg.match(/^(?:--sandbox|-s)=(.+)$/);
+        if (match) {
+            return match[1]?.trim().toLowerCase() || null;
+        }
+        if (arg === "--dangerously-bypass-approvals-and-sandbox") {
+            return "danger-full-access";
+        }
+    }
+    return null;
+}
+function capabilityTargetLabel(target) {
+    const executable = basename(target.command);
+    return executable === target.engine
+        ? `${target.engine} capabilities`
+        : `${target.engine} capabilities (${executable})`;
+}
+function stripTerminalControl(value) {
+    return value
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ");
+}
+function runCapabilityCommand(command, args, env, timeoutMs) {
+    return new Promise((resolve) => {
+        execFile(command, args, {
+            env,
+            timeout: timeoutMs,
+            maxBuffer: 512 * 1024
+        }, (error, stdout, stderr) => {
+            const processError = error;
+            resolve({
+                exitCode: typeof processError?.code === "number" ? processError.code : processError ? null : 0,
+                stdout,
+                stderr,
+                timedOut: Boolean(processError?.killed)
+            });
+        });
+    });
+}