@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/rg-wrapper/options.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBrgFormatOptions = resolveBrgFormatOptions;
+const session_workspace_1 = require("../commands/session-workspace");
+const path_display_1 = require("../config/path-display");
+const workspace_root_1 = require("../config/workspace-root");
+const core_1 = require("./core");
+const RG_ALIASES_CONFIG_KEY = "rg.aliases";
+const RG_TRIM_SPACES_CONFIG_KEY = "rg.trimSpaces";
+const RG_OUTPUT_CAP_KB_CONFIG_KEY = "rg.outputCapKb";
+const GLOBAL_OUTPUT_CAP_ENV = "AIB_OUTPUT_CAP";
+const RG_ALIASES_ENV = "AIB_RG_ALIASES";
+const RG_TRIM_SPACES_ENV = "AIB_RG_TRIM_SPACES";
+const RG_OUTPUT_CAP_KB_ENV = "AIB_RG_OUTPUT_CAP_KB";
+const DEFAULT_RG_OUTPUT_CAP_KB = 32;
+function resolveBrgFormatOptions(cwd, args, env = process.env) {
+    const options = {
+        omitSingleFileHeader: searchScopeLooksLikeSingleFile(args),
+        showColumn: argsInclude(args, "--column"),
+        trimLineStart: readBooleanEnvOverride(env[RG_TRIM_SPACES_ENV]) ?? (0, workspace_root_1.readWorkspaceBooleanConfig)(cwd, RG_TRIM_SPACES_CONFIG_KEY, false),
+        outputCapBytes: readOutputCapBytes(cwd, env)
+    };
+    const aliasesEnabled = readBooleanEnvOverride(env[RG_ALIASES_ENV]) ?? (0, workspace_root_1.readWorkspaceBooleanConfig)(cwd, RG_ALIASES_CONFIG_KEY, true);
+    if (aliasesEnabled) {
+        const aliases = (0, path_display_1.buildDisplayPathAliases)(cwd, (0, session_workspace_1.readEffectiveSessionPathAliases)(cwd));
+        if (aliases.length > 0) {
+            options.formatPath = (filePath) => (0, path_display_1.compactDisplayPath)(cwd, filePath, aliases);
+        }
+    }
+    return options;
+}
+function searchScopeLooksLikeSingleFile(args) {
+    const paths = estimateSearchPaths(args);
+    return paths.length === 1 && looksLikeFilePath(paths[0]);
+}
+function estimateSearchPaths(args) {
+    const positionals = (0, core_1.classifyRgArgs)(args).features.positionals;
+    if (positionals.length === 0) {
+        return [];
+    }
+    if (argsInclude(args, "-e") || argsInclude(args, "--regexp")) {
+        return positionals;
+    }
+    return positionals.slice(1);
+}
+function argsInclude(args, flag) {
+    return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+function looksLikeFilePath(value) {
+    return typeof value === "string" && /\.[A-Za-z0-9]+$/.test(value);
+}
+function readOutputCapBytes(cwd, env) {
+    if (isOutputCapDisabled(env[GLOBAL_OUTPUT_CAP_ENV])) {
+        return null;
+    }
+    const envValue = readOutputCapKbEnvOverride(env[RG_OUTPUT_CAP_KB_ENV]);
+    if (envValue !== undefined) {
+        return capKbToBytes(envValue);
+    }
+    const configValue = readWorkspaceOutputCapKb(cwd);
+    if (configValue !== undefined) {
+        return capKbToBytes(configValue);
+    }
+    return capKbToBytes(DEFAULT_RG_OUTPUT_CAP_KB);
+}
+function readOutputCapKbEnvOverride(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (isDisabledOutputCapToken(normalized)) {
+        return null;
+    }
+    const parsed = Number(normalized);
+    if (!Number.isFinite(parsed)) {
+        return undefined;
+    }
+    return normalizeOutputCapKb(parsed);
+}
+function readWorkspaceOutputCapKb(cwd) {
+    const resolved = (0, workspace_root_1.resolveWorkspaceRoot)(cwd);
+    if (!resolved || !Object.prototype.hasOwnProperty.call(resolved.config, RG_OUTPUT_CAP_KB_CONFIG_KEY)) {
+        return undefined;
+    }
+    return readOutputCapKbConfigValue(resolved.config[RG_OUTPUT_CAP_KB_CONFIG_KEY]);
+}
+function readOutputCapKbConfigValue(value) {
+    if (typeof value === "boolean") {
+        return value ? DEFAULT_RG_OUTPUT_CAP_KB : null;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (isDisabledOutputCapToken(normalized)) {
+            return null;
+        }
+        const parsed = Number(normalized);
+        return normalizeOutputCapKb(parsed);
+    }
+    return typeof value === "number" ? normalizeOutputCapKb(value) : null;
+}
+function isOutputCapDisabled(value) {
+    return value !== undefined && isDisabledOutputCapToken(value.trim().toLowerCase());
+}
+function isDisabledOutputCapToken(value) {
+    return value === "" || value === "off" || value === "disabled" || value === "false" || value === "0";
+}
+function normalizeOutputCapKb(value) {
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+function capKbToBytes(value) {
+    return typeof value === "number" ? Math.round(value * 1024) : null;
+}
+function readBooleanEnvOverride(value) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+        return true;
+    }
+    if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+        return false;
+    }
+    return null;
+}

package/dist/rtk-wrapper/core.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTK_PASSTHROUGH_COMMANDS = void 0;
+exports.isRtkPassthroughCommand = isRtkPassthroughCommand;
+exports.runRtkPassthrough = runRtkPassthrough;
+exports.runRtkPassthroughAsync = runRtkPassthroughAsync;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const runtime_tools_1 = require("../tool-runtime/runtime-tools");
+const workspace_root_1 = require("../config/workspace-root");
+const output_adapter_1 = require("./output-adapter");
+const buffered_process_1 = require("../runtime/buffered-process");
+const git_safety_1 = require("./git-safety");
+exports.RTK_PASSTHROUGH_COMMANDS = [
+    "git",
+    "gh",
+    "docker",
+    "kubectl",
+    "jest",
+    "vitest",
+    "playwright",
+    "pytest",
+    "go",
+    "cargo",
+    "rake",
+    "lint",
+    "biome",
+    "next",
+    "prettier",
+    "ruff",
+    "golangci-lint",
+    "rubocop"
+];
+const RTK_PASSTHROUGH_COMMAND_SET = new Set(exports.RTK_PASSTHROUGH_COMMANDS);
+function isRtkPassthroughCommand(command) {
+    return RTK_PASSTHROUGH_COMMAND_SET.has(command);
+}
+function runRtkPassthrough(input) {
+    const workspace = (0, workspace_root_1.resolveWorkspaceRoot)(input.cwd);
+    const workspaceRoot = workspace && node_fs_1.default.existsSync(workspace.configPath) ? workspace.root : null;
+    const env = {
+        ...process.env,
+        ...input.env,
+        RTK_TEE_DIR: input.env?.RTK_TEE_DIR ?? process.env.RTK_TEE_DIR ?? (0, output_adapter_1.defaultRtkTeeDir)(input.cwd, workspaceRoot)
+    };
+    const runtime = (0, runtime_tools_1.resolveToolRuntime)({
+        tool: "rtk",
+        envVar: (0, runtime_tools_1.toolRuntimeEnvVar)("rtk"),
+        env
+    });
+    const toolArgs = input.tool === "git" ? (0, git_safety_1.prepareGitArgs)(input.args, input.cwd, env).args : input.args;
+    const gitStatusFailure = input.tool === "git" && (0, git_safety_1.isGitStatusInvocation)(toolArgs)
+        ? (0, git_safety_1.verifyGitStatusSync)(toolArgs, input.cwd, env)
+        : null;
+    if (gitStatusFailure)
+        return failedGitStatusResult(gitStatusFailure);
+    const result = (0, node_child_process_1.spawnSync)(runtime.executable, [input.tool, ...toolArgs], {
+        cwd: input.cwd,
+        input: input.stdinText,
+        encoding: "utf8",
+        windowsHide: true,
+        env,
+        shell: (0, runtime_tools_1.shouldUseShellForTool)(runtime.executable),
+        maxBuffer: 64 * 1024 * 1024
+    });
+    const exitCode = typeof result.status === "number" ? result.status : result.error ? 127 : 1;
+    const output = (0, output_adapter_1.adaptRtkOutputForAib)({
+        tool: input.tool,
+        args: input.args,
+        cwd: input.cwd,
+        displayRoot: workspaceRoot ?? input.cwd,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? (result.error ? `${result.error.message}\n` : "")
+    });
+    return {
+        ok: exitCode === 0,
+        command: "rtk",
+        tool: input.tool,
+        exitCode,
+        stdout: output.stdout,
+        stderr: output.stderr,
+        signal: result.signal ?? null,
+        spawnError: result.error ? result.error.message : null
+    };
+}
+async function runRtkPassthroughAsync(input, signal) {
+    const workspace = (0, workspace_root_1.resolveWorkspaceRoot)(input.cwd);
+    const workspaceRoot = workspace && node_fs_1.default.existsSync(workspace.configPath) ? workspace.root : null;
+    const env = {
+        ...process.env,
+        ...input.env,
+        RTK_TEE_DIR: input.env?.RTK_TEE_DIR ?? process.env.RTK_TEE_DIR ?? (0, output_adapter_1.defaultRtkTeeDir)(input.cwd, workspaceRoot)
+    };
+    const runtime = (0, runtime_tools_1.resolveToolRuntime)({ tool: "rtk", envVar: (0, runtime_tools_1.toolRuntimeEnvVar)("rtk"), env });
+    const toolArgs = input.tool === "git" ? (0, git_safety_1.prepareGitArgs)(input.args, input.cwd, env).args : input.args;
+    const gitStatusFailure = input.tool === "git" && (0, git_safety_1.isGitStatusInvocation)(toolArgs)
+        ? await (0, git_safety_1.verifyGitStatusAsync)(toolArgs, input.cwd, env, signal)
+        : null;
+    if (gitStatusFailure)
+        return failedGitStatusResult(gitStatusFailure);
+    const result = await (0, buffered_process_1.runBufferedProcess)({
+        command: runtime.executable,
+        args: [input.tool, ...toolArgs],
+        cwd: input.cwd,
+        env,
+        shell: (0, runtime_tools_1.shouldUseShellForTool)(runtime.executable),
+        ...(input.stdinText !== undefined ? { input: input.stdinText } : {}),
+        ...(signal ? { signal } : {})
+    });
+    const exitCode = typeof result.status === "number" ? result.status : result.error ? 127 : 1;
+    const output = (0, output_adapter_1.adaptRtkOutputForAib)({
+        tool: input.tool,
+        args: input.args,
+        cwd: input.cwd,
+        displayRoot: workspaceRoot ?? input.cwd,
+        stdout: result.stdout,
+        stderr: result.stderr || (result.error ? `${result.error.message}\n` : "")
+    });
+    return {
+        ok: exitCode === 0,
+        command: "rtk",
+        tool: input.tool,
+        exitCode,
+        stdout: output.stdout,
+        stderr: output.stderr,
+        signal: result.signal,
+        spawnError: result.error?.message ?? null
+    };
+}
+function failedGitStatusResult(result) {
+    return {
+        ok: false,
+        command: "rtk",
+        tool: "git",
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        signal: result.signal,
+        spawnError: null
+    };
+}

package/dist/rtk-wrapper/git-safety.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareGitArgs = prepareGitArgs;
+exports.isGitStatusInvocation = isGitStatusInvocation;
+exports.verifyGitStatusSync = verifyGitStatusSync;
+exports.verifyGitStatusAsync = verifyGitStatusAsync;
+exports.resolveRecognizedCodexWorktreeGitRoot = resolveRecognizedCodexWorktreeGitRoot;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const buffered_process_1 = require("../runtime/buffered-process");
+function prepareGitArgs(args, cwd, env) {
+    if (hasExplicitSafeDirectory(args)) {
+        return { args: [...args], safeDirectory: null };
+    }
+    const gitRoot = resolveRecognizedCodexWorktreeGitRoot(cwd, env);
+    if (!gitRoot) {
+        return { args: [...args], safeDirectory: null };
+    }
+    const safeDirectory = normalizeSlashes(gitRoot);
+    return {
+        args: ["-c", `safe.directory=${safeDirectory}`, ...args],
+        safeDirectory
+    };
+}
+function isGitStatusInvocation(args) {
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index] ?? "";
+        if (arg === "--")
+            return false;
+        if (GIT_GLOBAL_OPTIONS_WITH_VALUE.has(arg)) {
+            index++;
+            continue;
+        }
+        if (isAttachedGitGlobalOption(arg) || GIT_GLOBAL_FLAGS.has(arg)) {
+            continue;
+        }
+        return arg === "status";
+    }
+    return false;
+}
+function verifyGitStatusSync(args, cwd, env) {
+    const result = (0, node_child_process_1.spawnSync)("git", args, {
+        cwd,
+        encoding: "utf8",
+        windowsHide: true,
+        env,
+        maxBuffer: 64 * 1024 * 1024
+    });
+    if (result.status === 0)
+        return null;
+    return {
+        exitCode: typeof result.status === "number" ? result.status : result.error ? 127 : 1,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr || (result.error ? `${result.error.message}\n` : ""),
+        signal: result.signal ?? null
+    };
+}
+async function verifyGitStatusAsync(args, cwd, env, signal) {
+    const result = await (0, buffered_process_1.runBufferedProcess)({
+        command: "git",
+        args,
+        cwd,
+        env,
+        ...(signal ? { signal } : {})
+    });
+    if (result.status === 0)
+        return null;
+    return {
+        exitCode: typeof result.status === "number" ? result.status : result.error ? 127 : 1,
+        stdout: result.stdout,
+        stderr: result.stderr || (result.error ? `${result.error.message}\n` : ""),
+        signal: result.signal
+    };
+}
+function resolveRecognizedCodexWorktreeGitRoot(cwd, env) {
+    const gitRoot = findGitRoot(cwd);
+    if (!gitRoot)
+        return null;
+    const explicitWorktree = env.CODEX_WORKTREE_PATH?.trim();
+    if (explicitWorktree && isPathInsideOrEqual(node_path_1.default.resolve(explicitWorktree), gitRoot)) {
+        return gitRoot;
+    }
+    const explicitHome = env.CODEX_HOME?.trim();
+    if (explicitHome && isCodexWorktreePath(gitRoot, node_path_1.default.join(node_path_1.default.resolve(explicitHome), "worktrees"))) {
+        return gitRoot;
+    }
+    const defaultHome = node_path_1.default.join(node_os_1.default.homedir(), ".codex", "worktrees");
+    if (isCodexWorktreePath(gitRoot, defaultHome)) {
+        return gitRoot;
+    }
+    const isCodexInvocation = env.CODEX_SHELL === "1" || Boolean(env.CODEX_THREAD_ID?.trim());
+    return isCodexInvocation && hasCodexWorktreePathShape(gitRoot) ? gitRoot : null;
+}
+function findGitRoot(cwd) {
+    let current = node_path_1.default.resolve(cwd);
+    const filesystemRoot = node_path_1.default.parse(current).root;
+    while (true) {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(current, ".git"))) {
+            return canonicalPath(current);
+        }
+        if (samePath(current, filesystemRoot))
+            return null;
+        const parent = node_path_1.default.dirname(current);
+        if (samePath(parent, current))
+            return null;
+        current = parent;
+    }
+}
+function hasExplicitSafeDirectory(args) {
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index] ?? "";
+        if (arg === "-c") {
+            if (isSafeDirectoryAssignment(args[index + 1] ?? ""))
+                return true;
+            index++;
+            continue;
+        }
+        if (arg.startsWith("-c") && isSafeDirectoryAssignment(arg.slice(2))) {
+            return true;
+        }
+    }
+    return false;
+}
+function isSafeDirectoryAssignment(value) {
+    return value.toLowerCase().startsWith("safe.directory=");
+}
+function isCodexWorktreePath(gitRoot, worktreesRoot) {
+    const relative = node_path_1.default.relative(node_path_1.default.resolve(worktreesRoot), gitRoot);
+    if (!relative || relative === ".." || relative.startsWith(`..${node_path_1.default.sep}`) || node_path_1.default.isAbsolute(relative)) {
+        return false;
+    }
+    return relative.split(node_path_1.default.sep).filter(Boolean).length >= 2;
+}
+function hasCodexWorktreePathShape(gitRoot) {
+    let current = node_path_1.default.resolve(gitRoot);
+    while (true) {
+        const parent = node_path_1.default.dirname(current);
+        if (node_path_1.default.basename(parent).toLowerCase() === "worktrees" && node_path_1.default.basename(node_path_1.default.dirname(parent)).toLowerCase() === ".codex") {
+            const relative = node_path_1.default.relative(parent, gitRoot);
+            return relative.split(node_path_1.default.sep).filter(Boolean).length >= 2;
+        }
+        if (samePath(parent, current))
+            return false;
+        current = parent;
+    }
+}
+function isPathInsideOrEqual(parent, child) {
+    const relative = node_path_1.default.relative(parent, child);
+    return relative === "" || (relative !== ".." && !relative.startsWith(`..${node_path_1.default.sep}`) && !node_path_1.default.isAbsolute(relative));
+}
+function canonicalPath(value) {
+    try {
+        return node_fs_1.default.realpathSync.native(value);
+    }
+    catch {
+        return node_path_1.default.resolve(value);
+    }
+}
+function samePath(left, right) {
+    if (process.platform === "win32") {
+        return node_path_1.default.resolve(left).toLowerCase() === node_path_1.default.resolve(right).toLowerCase();
+    }
+    return node_path_1.default.resolve(left) === node_path_1.default.resolve(right);
+}
+function normalizeSlashes(value) {
+    return value.replace(/\\/g, "/");
+}
+const GIT_GLOBAL_OPTIONS_WITH_VALUE = new Set([
+    "-c",
+    "-C",
+    "--config-env",
+    "--exec-path",
+    "--git-dir",
+    "--work-tree",
+    "--namespace",
+    "--super-prefix"
+]);
+const GIT_GLOBAL_FLAGS = new Set([
+    "--bare",
+    "--no-pager",
+    "--paginate",
+    "--literal-pathspecs",
+    "--glob-pathspecs",
+    "--noglob-pathspecs",
+    "--icase-pathspecs",
+    "--no-optional-locks",
+    "--no-replace-objects"
+]);
+function isAttachedGitGlobalOption(arg) {
+    return arg.startsWith("-c") ||
+        arg.startsWith("-C") ||
+        arg.startsWith("--config-env=") ||
+        arg.startsWith("--exec-path=") ||
+        arg.startsWith("--git-dir=") ||
+        arg.startsWith("--work-tree=") ||
+        arg.startsWith("--namespace=") ||
+        arg.startsWith("--super-prefix=");
+}

package/dist/rtk-wrapper/output-adapter.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptRtkOutputForAib = adaptRtkOutputForAib;
+exports.defaultRtkTeeDir = defaultRtkTeeDir;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const RTK_FULL_DIFF_HINT = "[full diff: rtk git diff --no-compact]";
+const RTK_FULL_OUTPUT_HINT_RE = /^(\s*)\[full output: (.+)\]\s*$/;
+const RTK_REMAINING_OUTPUT_HINT_RE = /^(\s*)\[see remaining: tail -n \+(\d+) (.+)\]\s*$/;
+function adaptRtkOutputForAib(input) {
+    return {
+        stdout: adaptHintLines(input.stdout, input),
+        stderr: adaptHintLines(input.stderr, input)
+    };
+}
+function defaultRtkTeeDir(cwd, workspaceRoot) {
+    const root = workspaceRoot ?? node_os_1.default.tmpdir();
+    return node_path_1.default.join(root, ".tmp", "aib", "rtk");
+}
+function adaptHintLines(output, input) {
+    if (!output.includes("[") || !output.includes("]")) {
+        return output;
+    }
+    return output
+        .split(/\r?\n/)
+        .map((line) => adaptHintLine(line, input))
+        .join("\n");
+}
+function adaptHintLine(line, input) {
+    const leadingWhitespace = line.match(/^\s*/)?.[0] ?? "";
+    if (line.trim() === RTK_FULL_DIFF_HINT) {
+        const hint = aibFullDiffHint(input.tool, input.args);
+        return hint ? `${leadingWhitespace}${hint}` : line;
+    }
+    const fullOutputMatch = RTK_FULL_OUTPUT_HINT_RE.exec(line);
+    if (fullOutputMatch) {
+        return `${fullOutputMatch[1] ?? ""}${formatArtifactHint("full output", fullOutputMatch[2] ?? "", input)}`;
+    }
+    const remainingMatch = RTK_REMAINING_OUTPUT_HINT_RE.exec(line);
+    if (remainingMatch) {
+        return `${remainingMatch[1] ?? ""}${formatArtifactHint("remaining output", remainingMatch[3] ?? "", input, remainingMatch[2] ?? "")}`;
+    }
+    return line;
+}
+function aibFullDiffHint(tool, args) {
+    if (tool !== "git" || args[0] !== "diff") {
+        return null;
+    }
+    const commandArgs = [...args];
+    if (!commandArgs.includes("--no-compact")) {
+        commandArgs.splice(1, 0, "--no-compact");
+    }
+    return `[full diff: aib git -- ${commandArgs.map(shellArg).join(" ")}]`;
+}
+function formatArtifactHint(kind, rawPath, input, startLine) {
+    const resolved = resolveHintPath(rawPath, input.cwd);
+    const displayPath = compactPath(input.displayRoot, resolved);
+    const size = fileSizeKb(resolved);
+    if (kind === "remaining output") {
+        const sizeText = typeof size === "number" ? `; file ${size} KB` : "; file size unknown";
+        const lineText = startLine ? ` from line ${startLine}` : "";
+        return `${kind}: ${displayPath}${lineText}${sizeText}`;
+    }
+    const sizeText = typeof size === "number" ? ` ${size} KB` : " size unknown";
+    return `${kind}: ${displayPath}${sizeText}`;
+}
+function resolveHintPath(rawPath, cwd) {
+    const normalized = rawPath.trim();
+    if (normalized.startsWith("~/") || normalized.startsWith("~\\")) {
+        return node_path_1.default.join(node_os_1.default.homedir(), normalized.slice(2));
+    }
+    if (node_path_1.default.isAbsolute(normalized)) {
+        return normalized;
+    }
+    return node_path_1.default.resolve(cwd, normalized);
+}
+function compactPath(root, target) {
+    const resolvedRoot = node_path_1.default.resolve(root);
+    const resolvedTarget = node_path_1.default.resolve(target);
+    const relative = node_path_1.default.relative(resolvedRoot, resolvedTarget);
+    if (relative && !relative.startsWith("..") && !node_path_1.default.isAbsolute(relative)) {
+        return normalizeSlashes(relative);
+    }
+    return normalizeSlashes(resolvedTarget);
+}
+function fileSizeKb(filePath) {
+    try {
+        return Math.ceil(node_fs_1.default.statSync(filePath).size / 1024);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeSlashes(value) {
+    return value.replace(/\\/g, "/");
+}
+function shellArg(value) {
+    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}

package/dist/runtime/buffered-process.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBufferedProcess = runBufferedProcess;
+const node_child_process_1 = require("node:child_process");
+const DEFAULT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+function runBufferedProcess(options) {
+    return new Promise((resolve) => {
+        const stdout = [];
+        const stderr = [];
+        const maxBufferBytes = options.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let settled = false;
+        let processError = null;
+        let overflowError = null;
+        let terminating = null;
+        const child = (0, node_child_process_1.spawn)(options.command, [...options.args], {
+            cwd: options.cwd,
+            env: options.env,
+            shell: options.shell === true,
+            windowsHide: true,
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        const terminate = () => {
+            terminating ??= terminateProcessTree(child);
+            return terminating;
+        };
+        const append = (target, stream, chunk) => {
+            const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            if (stream === "stdout")
+                stdoutBytes += value.byteLength;
+            else
+                stderrBytes += value.byteLength;
+            if ((stdoutBytes > maxBufferBytes || stderrBytes > maxBufferBytes) && !overflowError) {
+                overflowError = Object.assign(new Error(`${stream} exceeded maxBuffer length of ${maxBufferBytes} bytes`), {
+                    code: "ENOBUFS"
+                });
+                void terminate();
+                return;
+            }
+            if (!overflowError)
+                target.push(value);
+        };
+        child.stdout?.on("data", (chunk) => append(stdout, "stdout", chunk));
+        child.stderr?.on("data", (chunk) => append(stderr, "stderr", chunk));
+        child.stdin?.on("error", () => undefined);
+        child.once("error", (error) => {
+            processError = error;
+        });
+        child.once("close", (status, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            options.signal?.removeEventListener("abort", onAbort);
+            resolve({
+                status,
+                signal,
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                error: overflowError ?? processError
+            });
+        });
+        const onAbort = () => {
+            void terminate();
+        };
+        if (options.signal?.aborted)
+            onAbort();
+        else
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (options.input !== undefined)
+            child.stdin?.end(options.input);
+        else
+            child.stdin?.end();
+    });
+}
+async function terminateProcessTree(child) {
+    const pid = child.pid;
+    if (!pid || child.exitCode !== null || child.signalCode !== null)
+        return;
+    if (process.platform === "win32") {
+        const killer = (0, node_child_process_1.spawn)("taskkill.exe", ["/pid", String(pid), "/t", "/f"], {
+            windowsHide: true,
+            stdio: "ignore"
+        });
+        await Promise.race([new Promise((resolve) => {
+                killer.once("error", () => resolve());
+                killer.once("close", () => resolve());
+            }), delay(1_000)]);
+        if (killer.exitCode === null && killer.signalCode === null)
+            killer.kill();
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill();
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        child.kill("SIGTERM");
+    }
+    await delay(250);
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        child.kill("SIGKILL");
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}