@wix/pathgrade 1.0.6 → 1.0.8

package/dist/agents/opencode.js

@@ -0,0 +1,508 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import fs from 'fs-extra';
+import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../types.js';
+import { buildSummary, enrichSkillEvents } from '../tool-events.js';
+import { readStagedMcpServers } from '../providers/mcp-config.js';
+import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode-contract.js';
+const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
+const FIXED_OPENCODE_ENV = {
+    OPENCODE_CLIENT: 'pathgrade',
+    OPENCODE_DISABLE_AUTOUPDATE: '1',
+    OPENCODE_DISABLE_PRUNE: '1',
+    OPENCODE_DISABLE_MODELS_FETCH: '1',
+    OPENCODE_DISABLE_DEFAULT_PLUGINS: '1',
+    OPENCODE_DISABLE_EXTERNAL_SKILLS: '1',
+    OPENCODE_DISABLE_LSP_DOWNLOAD: '1',
+    OPENCODE_DISABLE_SHARE: '1',
+    OPENCODE_PURE: '1',
+};
+const OPENCODE_PERMISSION = JSON.stringify({
+    read: 'allow',
+    edit: 'allow',
+    glob: 'allow',
+    grep: 'allow',
+    list: 'allow',
+    bash: 'allow',
+    todowrite: 'allow',
+    lsp: 'allow',
+    skill: 'allow',
+    task: 'deny',
+    question: 'deny',
+    plan_enter: 'deny',
+    plan_exit: 'deny',
+    external_directory: 'deny',
+    webfetch: 'deny',
+    websearch: 'deny',
+});
+const NATIVE_TOOL_ACTIONS = {
+    bash: 'run_shell',
+    read: 'read_file',
+    write: 'write_file',
+    edit: 'edit_file',
+    grep: 'search_code',
+    glob: 'list_files',
+    list: 'list_files',
+    skill: 'use_skill',
+    todowrite: 'update_todos',
+    lsp: 'search_code',
+};
+const ALLOWED_EVENT_TYPES = new Set([
+    'tool_use',
+    'step_start',
+    'step_finish',
+    'text',
+    'reasoning',
+    'error',
+]);
+export function spawnOpenCode(executable, args, options) {
+    return new Promise((resolve, reject) => {
+        const stdout = [];
+        const cap = options.outputCapBytes ?? OUTPUT_CAP_BYTES;
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let overflow = false;
+        let aborted = false;
+        let killTimer;
+        let settled = false;
+        const child = spawn(executable, args, {
+            cwd: options.cwd,
+            env: options.env,
+            shell: false,
+            detached: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const killGroup = (signal) => {
+            if (!child.pid)
+                return;
+            try {
+                process.kill(-child.pid, signal);
+            }
+            catch {
+                // The process may have exited between the state check and kill.
+            }
+        };
+        const terminate = () => {
+            killGroup('SIGTERM');
+            killTimer ??= setTimeout(() => killGroup('SIGKILL'), 250);
+            killTimer.unref();
+        };
+        const onAbort = () => {
+            aborted = true;
+            terminate();
+        };
+        const onOverflow = () => {
+            overflow = true;
+            terminate();
+        };
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
+        child.stdout.on('data', (chunk) => {
+            stdoutBytes += chunk.length;
+            if (stdoutBytes <= cap)
+                stdout.push(chunk);
+            else
+                onOverflow();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrBytes += chunk.length;
+            if (stderrBytes > cap)
+                onOverflow();
+        });
+        child.stdin.on('error', () => undefined);
+        if (!aborted)
+            child.stdin.end(options.stdin);
+        else
+            child.stdin.destroy();
+        child.once('error', (error) => finish(undefined, undefined, error));
+        child.once('close', (code, signal) => finish(code, signal));
+        function finish(code, signal, error) {
+            if (settled)
+                return;
+            settled = true;
+            options.signal?.removeEventListener('abort', onAbort);
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({
+                stdout: Buffer.concat(stdout).toString('utf8'),
+                exitCode: code ?? null,
+                signal: signal ?? null,
+                overflow,
+                aborted,
+            });
+        }
+    });
+}
+function record(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`OpenCode protocol error: ${label} must be an object`);
+    }
+    return value;
+}
+function finiteNumber(value, label) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new Error(`OpenCode protocol error: ${label} must be a nonnegative finite number`);
+    }
+    return value;
+}
+function requiredString(value, label) {
+    if (typeof value !== 'string' || !value) {
+        throw new Error(`OpenCode protocol error: ${label} must be a nonempty string`);
+    }
+    return value;
+}
+function sanitizedProviderError(event) {
+    const error = record(event.error, 'error');
+    const data = error.data && typeof error.data === 'object' && !Array.isArray(error.data)
+        ? error.data
+        : {};
+    const message = typeof data.message === 'string' && data.message.trim()
+        ? data.message.trim().slice(0, 1_000)
+        : 'OpenCode provider error';
+    const status = typeof data.statusCode === 'number' ? ` status=${data.statusCode}` : '';
+    const retryable = typeof data.isRetryable === 'boolean' ? ` retryable=${data.isRetryable}` : '';
+    return new Error(`${message}${status}${retryable}`);
+}
+export function parseOpenCodeOutput(stdout, processResult, mcpToolNames) {
+    if (processResult.overflow)
+        throw new Error('OpenCode output exceeded the 16 MiB limit');
+    if (processResult.aborted)
+        throw new Error('OpenCode turn aborted');
+    const textParts = [];
+    const toolEvents = [];
+    const sanitizedTrace = [];
+    const seenParts = new Map();
+    let sessionId;
+    let stepFinishCount = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheCreationInputTokens = 0;
+    let cacheReadInputTokens = 0;
+    let costUsd = 0;
+    let providerError;
+    for (const [index, line] of stdout.split('\n').entries()) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            throw new Error(`OpenCode protocol error: invalid JSON on line ${index + 1}`);
+        }
+        const event = record(parsed, `line ${index + 1}`);
+        const type = requiredString(event.type, `line ${index + 1} type`);
+        if (!ALLOWED_EVENT_TYPES.has(type)) {
+            throw new Error(`OpenCode protocol error: unsupported event type ${type}`);
+        }
+        const currentSessionId = requiredString(event.sessionID, `line ${index + 1} sessionID`);
+        if (sessionId && sessionId !== currentSessionId) {
+            throw new Error('OpenCode protocol error: mixed session IDs');
+        }
+        sessionId = currentSessionId;
+        if (type === 'error') {
+            providerError = sanitizedProviderError(event);
+            sanitizedTrace.push({ type: 'error', message: providerError.message });
+            continue;
+        }
+        const part = record(event.part, `${type} part`);
+        const partId = requiredString(part.id, `${type} part.id`);
+        const fingerprint = JSON.stringify({ type, part });
+        const prior = seenParts.get(partId);
+        if (prior !== undefined) {
+            if (prior !== fingerprint) {
+                throw new Error(`OpenCode protocol error: conflicting duplicate part ID ${partId}`);
+            }
+            continue;
+        }
+        seenParts.set(partId, fingerprint);
+        if (type === 'text') {
+            const text = typeof part.text === 'string' ? part.text : undefined;
+            const time = record(part.time, 'text part.time');
+            if (text === undefined || typeof time.end !== 'number') {
+                throw new Error('OpenCode protocol error: incomplete text part');
+            }
+            textParts.push(text);
+            sanitizedTrace.push({ type, text });
+            continue;
+        }
+        if (type === 'tool_use') {
+            const tool = requiredString(part.tool, 'tool_use part.tool');
+            const state = record(part.state, 'tool_use part.state');
+            if (state.status !== 'completed' && state.status !== 'error') {
+                throw new Error(`OpenCode protocol error: incomplete tool ${tool}`);
+            }
+            const input = state.input === undefined ? undefined : record(state.input, 'tool_use state.input');
+            const action = mcpToolNames.has(tool)
+                ? 'mcp_tool_call'
+                : NATIVE_TOOL_ACTIONS[tool] ?? 'unknown';
+            toolEvents.push({
+                action,
+                provider: 'opencode',
+                providerToolName: tool,
+                ...(input ? { arguments: input } : {}),
+                summary: buildSummary(action, tool, input),
+                confidence: action === 'unknown' ? 'low' : 'high',
+                rawSnippet: JSON.stringify({ tool, status: state.status, input }).slice(0, 2_000),
+            });
+            sanitizedTrace.push({ type, tool, status: state.status, input });
+            continue;
+        }
+        if (type === 'step_finish') {
+            const tokens = record(part.tokens, 'step_finish part.tokens');
+            const cache = record(tokens.cache, 'step_finish part.tokens.cache');
+            const input = finiteNumber(tokens.input, 'tokens.input');
+            const output = finiteNumber(tokens.output, 'tokens.output');
+            const reasoning = finiteNumber(tokens.reasoning, 'tokens.reasoning');
+            const cacheWrite = finiteNumber(cache.write, 'tokens.cache.write');
+            const cacheRead = finiteNumber(cache.read, 'tokens.cache.read');
+            const cost = finiteNumber(part.cost, 'step_finish part.cost');
+            inputTokens += input + cacheWrite + cacheRead;
+            outputTokens += output + reasoning;
+            cacheCreationInputTokens += cacheWrite;
+            cacheReadInputTokens += cacheRead;
+            costUsd += cost;
+            stepFinishCount++;
+            sanitizedTrace.push({
+                type,
+                tokens: { input, output, reasoning, cache: { write: cacheWrite, read: cacheRead } },
+                cost,
+            });
+            continue;
+        }
+        sanitizedTrace.push({ type });
+    }
+    if (providerError)
+        throw providerError;
+    if (processResult.exitCode !== 0) {
+        throw new Error(`OpenCode process exited with code ${processResult.exitCode ?? 'unknown'}`);
+    }
+    if (!sessionId)
+        throw new Error('OpenCode protocol error: no events');
+    if (stepFinishCount === 0)
+        throw new Error('OpenCode protocol error: missing step_finish');
+    const assistantMessage = textParts.join('');
+    const traceOutput = sanitizedTrace.map((event) => JSON.stringify(event)).join('\n');
+    return {
+        sessionId,
+        result: {
+            rawOutput: traceOutput,
+            traceOutput,
+            assistantMessage,
+            visibleAssistantMessage: assistantMessage,
+            visibleAssistantMessageSource: 'assistant_message',
+            exitCode: 0,
+            toolEvents: enrichSkillEvents(toolEvents),
+            inputTokens,
+            outputTokens,
+            cacheCreationInputTokens,
+            cacheReadInputTokens,
+            costUsd,
+        },
+    };
+}
+function sha256File(filename) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const stream = createReadStream(filename);
+        stream.on('error', reject);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+async function assertNoProjectConfig(workspacePath) {
+    for (const name of ['opencode.json', 'opencode.jsonc', '.opencode']) {
+        if (await fs.pathExists(path.join(workspacePath, name))) {
+            throw new Error(`OpenCode workspace configuration is not allowed: ${name}`);
+        }
+    }
+}
+export function managedOpenCodeConfigPaths(platform = process.platform, username = os.userInfo().username) {
+    return platform === 'linux'
+        ? ['/etc/opencode/opencode.json', '/etc/opencode/opencode.jsonc']
+        : [
+            '/Library/Application Support/opencode/opencode.json',
+            '/Library/Application Support/opencode/opencode.jsonc',
+            `/Library/Managed Preferences/${username}/ai.opencode.managed.plist`,
+            '/Library/Managed Preferences/ai.opencode.managed.plist',
+        ];
+}
+export async function assertCleanManagedOpenCodeHost(candidates = managedOpenCodeConfigPaths()) {
+    for (const candidate of candidates) {
+        if (await fs.pathExists(candidate)) {
+            throw new Error(`OpenCode managed host configuration is not supported: ${candidate}`);
+        }
+    }
+}
+async function projectMcpConfig(workspacePath, mcpConfigPath) {
+    if (!mcpConfigPath)
+        return {};
+    const servers = await readStagedMcpServers(workspacePath, mcpConfigPath);
+    const config = {};
+    for (const [name, entry] of Object.entries(servers ?? {})) {
+        if (!('command' in entry)) {
+            throw new Error(`OpenCode MCP server "${name}" must remain a stdio server`);
+        }
+        const stdio = entry;
+        config[name] = {
+            type: 'local',
+            command: [stdio.command, ...(stdio.args ?? [])],
+            ...(stdio.env ? { environment: stdio.env } : {}),
+            cwd: '.',
+            enabled: true,
+        };
+    }
+    return config;
+}
+class OpenCodeSession {
+    workspacePath;
+    runtimeEnv;
+    executable;
+    mcpConfigPath;
+    mcpToolNames;
+    getAbortSignal;
+    xdgDirs;
+    resolvedExecutable;
+    preflightDone = false;
+    running = false;
+    failed = false;
+    disposed = false;
+    sessionId;
+    inFlight;
+    constructor(runtime, options) {
+        this.workspacePath = getWorkspacePath(runtime);
+        this.runtimeEnv = getRuntimeEnv(runtime);
+        this.executable = options.opencodeExecutable;
+        this.mcpConfigPath = options.mcpConfigPath;
+        this.mcpToolNames = new Set(options.opencodeMcpToolNames ?? []);
+        this.getAbortSignal = options.getAbortSignal ?? (() => options.abortSignal);
+        const home = this.runtimeEnv.HOME;
+        if (!home)
+            throw new Error('OpenCode requires a managed HOME');
+        this.xdgDirs = [
+            path.join(home, '.local', 'share'),
+            path.join(home, '.config'),
+            path.join(home, '.local', 'state'),
+            path.join(home, '.cache'),
+        ];
+    }
+    start({ message }) {
+        if (this.sessionId)
+            throw new Error('OpenCode session has already started');
+        return this.execute(message);
+    }
+    reply({ message }) {
+        if (!this.sessionId)
+            throw new Error('OpenCode session has not started');
+        return this.execute(message);
+    }
+    execute(message) {
+        if (this.disposed)
+            return Promise.reject(new Error('OpenCode session is disposed'));
+        if (this.failed)
+            return Promise.reject(new Error('OpenCode session is unusable after a failed turn'));
+        if (this.running)
+            return Promise.reject(new Error('OpenCode does not allow concurrent turns'));
+        this.running = true;
+        const task = this.runTurn(message);
+        this.inFlight = task;
+        void task.finally(() => {
+            this.running = false;
+            if (this.inFlight === task)
+                this.inFlight = undefined;
+        }).catch(() => undefined);
+        return task;
+    }
+    async runTurn(message) {
+        try {
+            await this.ensurePreflight();
+            await assertNoProjectConfig(this.workspacePath);
+            const mcp = await projectMcpConfig(this.workspacePath, this.mcpConfigPath);
+            const env = this.buildEnvironment(mcp);
+            const args = [
+                'run', '--format', 'json', '--thinking', '--dir', this.workspacePath,
+                '--model', OPENCODE_MODEL, '--agent', 'build',
+                ...(this.sessionId ? ['--session', this.sessionId] : []),
+            ];
+            const processResult = await spawnOpenCode(this.resolvedExecutable, args, {
+                cwd: this.workspacePath,
+                env,
+                stdin: message,
+                signal: this.getAbortSignal(),
+            });
+            const parsed = parseOpenCodeOutput(processResult.stdout, processResult, this.mcpToolNames);
+            if (this.sessionId && parsed.sessionId !== this.sessionId) {
+                throw new Error('OpenCode protocol error: resumed session ID changed');
+            }
+            this.sessionId = parsed.sessionId;
+            return parsed.result;
+        }
+        catch (error) {
+            this.failed = true;
+            await this.cleanupState();
+            throw error;
+        }
+    }
+    async ensurePreflight() {
+        if (this.preflightDone)
+            return;
+        const platformKey = currentOpenCodePlatformKey();
+        if (!platformKey)
+            throw new Error(`OpenCode is not supported on ${process.platform}-${process.arch}`);
+        const resolved = await fs.realpath(this.executable);
+        const actualHash = await sha256File(resolved);
+        const expectedHash = OPENCODE_RUNTIME_LOCK[platformKey].executableSha256;
+        if (actualHash !== expectedHash) {
+            throw new Error(`OpenCode executable hash mismatch for ${platformKey}`);
+        }
+        await assertCleanManagedOpenCodeHost();
+        await assertNoProjectConfig(this.workspacePath);
+        await Promise.all(this.xdgDirs.map((directory) => fs.ensureDir(directory)));
+        this.resolvedExecutable = resolved;
+        this.preflightDone = true;
+    }
+    buildEnvironment(mcp) {
+        const [data, config, state, cache] = this.xdgDirs;
+        return {
+            ...this.runtimeEnv,
+            XDG_DATA_HOME: data,
+            XDG_CONFIG_HOME: config,
+            XDG_STATE_HOME: state,
+            XDG_CACHE_HOME: cache,
+            ...FIXED_OPENCODE_ENV,
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                share: 'disabled',
+                model: OPENCODE_MODEL,
+                skills: { paths: ['.agents/skills'], urls: [] },
+                mcp,
+            }),
+            OPENCODE_PERMISSION,
+        };
+    }
+    async cleanupState() {
+        await Promise.all(this.xdgDirs.map((directory) => fs.remove(directory)));
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        await this.inFlight?.catch(() => undefined);
+        await this.cleanupState();
+    }
+}
+export class OpenCodeAgent extends BaseAgent {
+    async createSession(runtime, _runCommand, options = {}) {
+        if (!options.opencodeExecutable) {
+            throw new Error('OpenCode requires opencodeExecutable');
+        }
+        return new OpenCodeSession(runtime, options);
+    }
+}

package/dist/agents/registry.js

@@ -2,11 +2,13 @@ import { ClaudeAgent } from './claude.js';
 import { CodexAgent } from './codex.js';
 import { CodexAppServerAgent } from './codex-app-server/agent.js';
 import { CursorAgent } from './cursor.js';
+import { OpenCodeAgent } from './opencode.js';
 /** Registry of available agent implementations. Codex routing is transport-aware. */
 const AGENT_REGISTRY = {
     claude: () => new ClaudeAgent(),
     codex: (transport) => transport === 'exec' ? new CodexAgent() : new CodexAppServerAgent(),
     cursor: () => new CursorAgent(),
+    opencode: () => new OpenCodeAgent(),
 };
 /** Get the list of supported agent names */
 export function getAgentNames() {

package/dist/commands/clean.d.ts

@@ -0,0 +1,8 @@
+import { type CleanDebugRunsResult } from '../providers/debug-runs.js';
+export interface CleanCommandOptions {
+    debug: boolean;
+    keep?: number;
+    dryRun?: boolean;
+}
+export declare function parseCleanArgs(args: string[]): CleanCommandOptions;
+export declare function runClean(cwd: string, options: CleanCommandOptions): Promise<CleanDebugRunsResult>;

package/dist/commands/clean.js

@@ -0,0 +1,94 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { cleanDebugRuns, DEBUG_ROOT_MARKER, } from '../providers/debug-runs.js';
+function parseKeep(value) {
+    if (value === undefined || !/^\d+$/.test(value)) {
+        throw new Error('pathgrade clean: --keep must be a non-negative integer');
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new Error('pathgrade clean: --keep must be a non-negative integer');
+    }
+    return parsed;
+}
+export function parseCleanArgs(args) {
+    let debug = false;
+    let dryRun = false;
+    let keep;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === '--debug') {
+            debug = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (arg === '--keep') {
+            keep = parseKeep(args[++index]);
+            continue;
+        }
+        if (arg.startsWith('--keep=')) {
+            keep = parseKeep(arg.slice('--keep='.length));
+            continue;
+        }
+        throw new Error(`pathgrade clean: unknown option ${arg}`);
+    }
+    return { debug, ...(keep === undefined ? {} : { keep }), dryRun };
+}
+const SKIPPED_DIRECTORY_NAMES = new Set(['.git', '.worktrees', 'node_modules']);
+async function findDebugRoots(cwd) {
+    const roots = [];
+    async function visit(dir) {
+        let stat;
+        try {
+            stat = await fs.lstat(dir);
+        }
+        catch {
+            return;
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        if (entries.some(entry => entry.isFile() && !entry.isSymbolicLink() && entry.name === DEBUG_ROOT_MARKER)) {
+            roots.push(dir);
+            return;
+        }
+        await Promise.all(entries.map(async (entry) => {
+            if (!entry.isDirectory() || entry.isSymbolicLink() || SKIPPED_DIRECTORY_NAMES.has(entry.name))
+                return;
+            await visit(path.join(dir, entry.name));
+        }));
+    }
+    await visit(path.resolve(cwd));
+    return roots;
+}
+export async function runClean(cwd, options) {
+    if (!options.debug) {
+        throw new Error('pathgrade clean requires --debug');
+    }
+    const roots = await findDebugRoots(cwd);
+    const results = await Promise.all(roots.map(rootDir => cleanDebugRuns({
+        rootDir,
+        keep: options.keep,
+        dryRun: options.dryRun,
+    })));
+    return results.reduce((total, result) => ({
+        removed: total.removed + result.removed,
+        retained: total.retained + result.retained,
+        active: total.active + result.active,
+        dryRun: total.dryRun,
+    }), {
+        removed: 0,
+        retained: 0,
+        active: 0,
+        dryRun: options.dryRun ?? false,
+    });
+}

package/dist/commands/run-changed.js

@@ -20,15 +20,13 @@ import { writeSidecar } from '../affected/sidecar.js';
 import { discoverPathgradeEvalFiles } from '../evals/discovery.js';
 import { resolvePathgradeConfig } from '../config/pathgrade.js';
 import { loadRunnerInvocationAdapter } from '../runners/adapter-loader.js';
+import { buildRunnerEnv } from './runner-env.js';
 export async function runChanged(opts) {
     const { cwd, parsed } = opts;
     const selectionInvocationId = randomUUID();
-    const runnerEnv = {
-        ...process.env,
-        ...(parsed.forceDiagnostics ? { PATHGRADE_DIAGNOSTICS: '1' } : {}),
-        ...(parsed.forceVerbose ? { PATHGRADE_VERBOSE: '1' } : {}),
+    const runnerEnv = buildRunnerEnv(parsed, {
         PATHGRADE_SELECTION_INVOCATION_ID: selectionInvocationId,
-    };
+    });
     const configPath = findVitestConfigArg(parsed.runnerArgs);
     let config;
     let runnerInvocation;

package/dist/commands/runner-env.d.ts

@@ -0,0 +1,2 @@
+import type { PathgradeRunArgs } from './run-args.js';
+export declare function buildRunnerEnv(parsed: Pick<PathgradeRunArgs, 'forceDiagnostics' | 'forceVerbose'>, additions?: Record<string, string>): NodeJS.ProcessEnv;

package/dist/commands/runner-env.js

@@ -0,0 +1,10 @@
+import { resolveDebugRunId } from '../providers/debug-runs.js';
+export function buildRunnerEnv(parsed, additions = {}) {
+    return {
+        ...process.env,
+        PATHGRADE_DEBUG_RUN_ID: resolveDebugRunId(),
+        ...(parsed.forceDiagnostics ? { PATHGRADE_DIAGNOSTICS: '1' } : {}),
+        ...(parsed.forceVerbose ? { PATHGRADE_VERBOSE: '1' } : {}),
+        ...additions,
+    };
+}