mustflow 2.18.2 → 2.18.7

package/dist/cli/commands/run.js

@@ -1,365 +1,20 @@
-import { spawn, spawnSync } from 'node:child_process';
 import { performance } from 'node:perf_hooks';
-import { canRunMustflowBuiltinInProcess, isMustflowBinName } from '../../core/command-classification.js';
 import { createCommandEnv } from '../../core/command-env.js';
-import { BoundedOutputBuffer } from '../../core/bounded-output.js';
 import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
 import { readCommandContract, readMustflowConfigIfExists } from '../../core/config-loading.js';
 import { resolveRunReceiptRetentionPolicy } from '../../core/retention-policy.js';
 import { t } from '../lib/i18n.js';
-import { getPackageVersion } from '../lib/package-info.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { createRunPlan, createRunPreview, isMustflowBuiltinIntent, renderRunPreviewText, } from '../lib/run-plan.js';
-import { createRunReceipt, createRunReceiptRelativePath, writeRunReceipt, } from '../../core/run-receipt.js';
+import { writeRunReceipt, } from '../../core/run-receipt.js';
 import { recordRunPerformanceHistory } from '../../core/run-performance-history.js';
 import { RunProfiler } from '../../core/run-profile.js';
 import { finishRunWriteTracking, startRunWriteTracking } from '../../core/run-write-drift.js';
-const OUTPUT_LIMIT_ERROR_CODE = 'ENOBUFS';
-const OUTPUT_LIMIT_ERROR_MESSAGE = /\bmaxBuffer\b.*\bexceeded\b/i;
-function emitOutput(reporter, output, stream) {
-    if (!output) {
-        return;
-    }
-    const text = (typeof output === 'object' && 'tail' in output ? output.tail : output.toString()).trimEnd();
-    if (text.length === 0) {
-        return;
-    }
-    reporter[stream](text);
-}
-function signalProcessTree(pid, signal) {
-    if (!pid || pid <= 0) {
-        return;
-    }
-    if (process.platform === 'win32') {
-        spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], {
-            stdio: 'ignore',
-            windowsHide: true,
-        });
-        if (signal === 'SIGKILL') {
-            try {
-                process.kill(pid, signal);
-            }
-            catch {
-                // taskkill may already have terminated the direct child.
-            }
-        }
-        return;
-    }
-    try {
-        process.kill(-pid, signal);
-    }
-    catch {
-        try {
-            process.kill(pid, signal);
-        }
-        catch {
-            // The child may already be gone after Node's spawn timeout handling.
-        }
-    }
-}
-function signalProcessTreeNonBlocking(pid, signal) {
-    if (!pid || pid <= 0) {
-        return;
-    }
-    if (process.platform === 'win32') {
-        const killer = spawn('taskkill', ['/PID', String(pid), '/T', '/F'], {
-            stdio: 'ignore',
-            windowsHide: true,
-            detached: true,
-        });
-        killer.unref();
-        if (signal === 'SIGKILL') {
-            try {
-                process.kill(pid, signal);
-            }
-            catch {
-                // taskkill may already have terminated the direct child.
-            }
-        }
-        return;
-    }
-    try {
-        process.kill(-pid, signal);
-    }
-    catch {
-        try {
-            process.kill(pid, signal);
-        }
-        catch {
-            // The child may already be gone after the timeout fired.
-        }
-    }
-}
-function terminateProcessTree(pid) {
-    signalProcessTree(pid, 'SIGTERM');
-}
-function forceTerminateProcessTree(pid) {
-    signalProcessTree(pid, 'SIGKILL');
-}
-function terminateProcessTreeNonBlocking(pid) {
-    signalProcessTreeNonBlocking(pid, 'SIGTERM');
-}
-function forceTerminateProcessTreeNonBlocking(pid) {
-    signalProcessTreeNonBlocking(pid, 'SIGKILL');
-}
-function getKillMethod() {
-    return process.platform === 'win32' ? 'taskkill_process_tree' : 'process_group_sigterm';
-}
-function createPendingTimeoutTermination(method) {
-    return {
-        reason: 'timeout',
-        method,
-        graceful_signal: 'SIGTERM',
-        forced_signal: 'SIGKILL',
-        forced_kill_attempted: true,
-        confirmed: false,
-        cleanup_pending: true,
-    };
-}
-function createBufferedReporter() {
-    const stdout = [];
-    const stderr = [];
-    return {
-        reporter: {
-            stdout(message) {
-                stdout.push(`${message}\n`);
-            },
-            stderr(message) {
-                stderr.push(`${message}\n`);
-            },
-        },
-        stdout() {
-            return stdout.join('');
-        },
-        stderr() {
-            return stderr.join('');
-        },
-    };
-}
-/**
- * mf:anchor cli.run.builtin-inprocess
- * purpose: Dispatch selected mustflow built-in commands without spawning a nested CLI process.
- * search: builtin intent, in-process command, nested mf run, run receipt
- * invariant: Only commands classified by command-classification can use this path.
- * risk: config, state
- */
-async function runKnownBuiltinCommand(args, reporter, lang) {
-    const [command, ...commandArgs] = args;
-    if ((command === '--version' || command === '-v' || command === 'version') && commandArgs.length === 0) {
-        reporter.stdout(getPackageVersion());
-        return 0;
-    }
-    if (!canRunMustflowBuiltinInProcess(command)) {
-        return undefined;
-    }
-    if (command === 'check') {
-        return (await import('./check.js')).runCheck(commandArgs, reporter, lang);
-    }
-    if (command === 'classify') {
-        return (await import('./classify.js')).runClassify(commandArgs, reporter, lang);
-    }
-    if (command === 'context') {
-        return (await import('./context.js')).runContext(commandArgs, reporter, lang);
-    }
-    if (command === 'doctor') {
-        return (await import('./doctor.js')).runDoctor(commandArgs, reporter, lang);
-    }
-    if (command === 'help') {
-        return (await import('./help.js')).runHelp(commandArgs, reporter, lang);
-    }
-    if (command === 'impact') {
-        return (await import('./impact.js')).runImpact(commandArgs, reporter, lang);
-    }
-    if (command === 'line-endings') {
-        return (await import('./line-endings.js')).runLineEndings(commandArgs, reporter, lang);
-    }
-    if (command === 'map') {
-        return (await import('./map.js')).runMap(commandArgs, reporter, lang);
-    }
-    if (command === 'status') {
-        return (await import('./status.js')).runStatus(commandArgs, reporter, lang);
-    }
-    if (command === 'update') {
-        return (await import('./update.js')).runUpdate(commandArgs, reporter, lang);
-    }
-    if (command === 'version-sources') {
-        return (await import('./version-sources.js')).runVersionSources(commandArgs, reporter, lang);
-    }
-    return undefined;
-}
-async function withWorkingDirectory(cwd, callback) {
-    const previousCwd = process.cwd();
-    process.chdir(cwd);
-    try {
-        return await callback();
-    }
-    finally {
-        process.chdir(previousCwd);
-    }
-}
-async function runBuiltinArgvInProcess(commandArgv, cwd, lang) {
-    const [command = '', ...builtinArgs] = commandArgv;
-    if (!isMustflowBinName(command)) {
-        return undefined;
-    }
-    const output = createBufferedReporter();
-    try {
-        const status = await withWorkingDirectory(cwd, () => runKnownBuiltinCommand(builtinArgs, output.reporter, lang));
-        if (status === undefined) {
-            return undefined;
-        }
-        return {
-            status,
-            signal: null,
-            stdout: output.stdout(),
-            stderr: output.stderr(),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            status: 1,
-            signal: null,
-            stdout: output.stdout(),
-            stderr: `${output.stderr()}${message}\n`,
-        };
-    }
-}
-function writeStreamChunk(reporter, stream, chunk) {
-    if (stream === 'stdout') {
-        if (reporter.writeStdout) {
-            reporter.writeStdout(chunk);
-            return;
-        }
-        reporter.stdout(chunk.toString());
-        return;
-    }
-    if (reporter.writeStderr) {
-        reporter.writeStderr(chunk);
-        return;
-    }
-    reporter.stderr(chunk.toString());
-}
-function createOutputLimitError(stream, maxOutputBytes) {
-    return Object.assign(new Error(`${stream} exceeded max_output_bytes (${maxOutputBytes})`), {
-        code: OUTPUT_LIMIT_ERROR_CODE,
-    });
-}
-function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
-    return new Promise((resolve) => {
-        const stdout = new BoundedOutputBuffer(stdoutTailBytes);
-        const stderr = new BoundedOutputBuffer(stderrTailBytes);
-        let settled = false;
-        let timedOut = false;
-        let childError;
-        let childPid;
-        let stdoutBytes = 0;
-        let stderrBytes = 0;
-        let timeout;
-        let termination = null;
-        const child = spawn(command.executable, command.args ?? [], {
-            cwd,
-            env,
-            shell: command.shell,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
-            detached: process.platform !== 'win32',
-        });
-        childPid = child.pid;
-        const finish = (status, signal) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            if (timeout) {
-                clearTimeout(timeout);
-            }
-            resolve({
-                status: timedOut ? null : status,
-                signal: timedOut ? null : signal,
-                error: timedOut ? Object.assign(new Error('Command timed out'), { code: 'ETIMEDOUT' }) : childError,
-                stdout: stdout.toSnapshot(),
-                stderr: stderr.toSnapshot(),
-                pid: childPid,
-                termination,
-            });
-        };
-        const stopForOutputLimit = (stream) => {
-            if (settled || childError) {
-                return;
-            }
-            childError = createOutputLimitError(stream, maxOutputBytes);
-            child.stdout?.destroy();
-            child.stderr?.destroy();
-            child.unref();
-            terminateProcessTreeNonBlocking(childPid);
-            forceTerminateProcessTreeNonBlocking(childPid);
-            finish(null, null);
-        };
-        child.stdout?.on('data', (chunk) => {
-            stdout.append(chunk);
-            stdoutBytes += chunk.byteLength;
-            if (streamOutput) {
-                writeStreamChunk(reporter, 'stdout', chunk);
-            }
-            if (enforceOutputLimit && stdoutBytes > maxOutputBytes) {
-                stopForOutputLimit('stdout');
-            }
-        });
-        child.stderr?.on('data', (chunk) => {
-            stderr.append(chunk);
-            stderrBytes += chunk.byteLength;
-            if (streamOutput) {
-                writeStreamChunk(reporter, 'stderr', chunk);
-            }
-            if (enforceOutputLimit && stderrBytes > maxOutputBytes) {
-                stopForOutputLimit('stderr');
-            }
-        });
-        child.once('error', (error) => {
-            childError = error;
-        });
-        child.once('close', (status, signal) => {
-            finish(status, signal);
-        });
-        timeout = setTimeout(() => {
-            timedOut = true;
-            child.stdout?.destroy();
-            child.stderr?.destroy();
-            child.unref();
-            termination = createPendingTimeoutTermination(getKillMethod());
-            terminateProcessTreeNonBlocking(childPid);
-            forceTerminateProcessTreeNonBlocking(childPid);
-            finish(null, null);
-        }, timeoutSeconds * 1000);
-    });
-}
-function runArgvCommandStreaming(command, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
-    return runSpawnedCommandStreaming({ executable: command?.executable ?? '', args: command?.args ?? [], shell: command?.shell ?? false }, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit);
-}
-function runShellCommandStreaming(command, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
-    return runSpawnedCommandStreaming({ executable: command ?? '', shell: true }, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit);
-}
-function getRunStatus(error, exitCode, successExitCodes) {
-    const errorWithCode = error;
-    if (errorWithCode?.code === 'ETIMEDOUT') {
-        return 'timed_out';
-    }
-    if (isOutputLimitExceededError(error)) {
-        return 'output_limit_exceeded';
-    }
-    if (error) {
-        return 'start_failed';
-    }
-    return exitCode !== null && successExitCodes.includes(exitCode) ? 'passed' : 'failed';
-}
-function isOutputLimitExceededError(error) {
-    if (!error) {
-        return false;
-    }
-    const errorWithCode = error;
-    return errorWithCode.code === OUTPUT_LIMIT_ERROR_CODE || OUTPUT_LIMIT_ERROR_MESSAGE.test(error.message);
-}
+import { runBuiltinArgvInProcess } from './run/builtin-dispatch.js';
+import { getRunStatus, runArgvCommandStreaming, runShellCommandStreaming } from './run/executor.js';
+import { emitOutput, isOutputLimitExceededError } from './run/output.js';
+import { createPendingTimeoutTermination, getKillMethod, terminateProcessTree } from './run/process-tree.js';
+import { assembleRunReceipt } from './run/receipt.js';
 function getRunPlanDetail(plan, lang, fallbackKey) {
     return plan.detail ?? t(lang, fallbackKey);
 }
@@ -517,8 +172,6 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
     }
     const runReceiptPolicy = profiler.measure('retention_policy', () => resolveRunReceiptRetentionPolicy(readMustflowConfigIfExists(projectRoot)));
     const env = profiler.measure('environment', () => createCommandEnv(projectRoot, { policy: plan.envPolicy, allowlist: plan.envAllowlist }));
-    const lifecycleValue = plan.lifecycle ?? 'oneshot';
-    const runPolicyValue = plan.runPolicy ?? 'agent_allowed';
     const writeTracker = profiler.measure('write_drift_before', () => startRunWriteTracking(projectRoot, contract, intentName));
     const stdoutTailBytes = Math.min(runReceiptPolicy.stdoutTailBytes, plan.maxOutputBytes);
     const stderrTailBytes = Math.min(runReceiptPolicy.stderrTailBytes, plan.maxOutputBytes);
@@ -534,10 +187,10 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
         }
         if (plan.commandArgv) {
             streamedOutput = !json;
-            return runArgvCommandStreaming(plan.argvCommand, plan.cwd, env, plan.timeoutSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, json);
+            return runArgvCommandStreaming(plan.argvCommand, plan.cwd, env, plan.timeoutSeconds, plan.killAfterSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, true);
         }
         streamedOutput = !json;
-        return runShellCommandStreaming(plan.shellCommand, plan.cwd, env, plan.timeoutSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, json);
+        return runShellCommandStreaming(plan.shellCommand, plan.cwd, env, plan.timeoutSeconds, plan.killAfterSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, true);
     });
     const childDurationMs = performance.now() - childStartedAtMs;
     const finishedAt = new Date();
@@ -553,44 +206,22 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
             terminateProcessTree(result.pid);
         }
     }
-    const receipt = profiler.measure('receipt_create', () => createRunReceipt({
-        intent: intentName,
-        status: runStatus,
-        timedOut: runStatus === 'timed_out',
+    const receipt = profiler.measure('receipt_create', () => assembleRunReceipt({
+        intentName,
+        runStatus,
         startedAt,
         finishedAt,
         projectRoot,
-        cwd: plan.cwd,
-        lifecycle: lifecycleValue,
-        runPolicy: runPolicyValue,
-        mode: plan.mode,
-        argv: plan.commandArgv,
-        cmd: plan.shellCommand,
-        envPolicy: plan.envPolicy,
-        envAllowlist: plan.envAllowlist,
-        timeoutSeconds: plan.timeoutSeconds,
-        maxOutputBytes: plan.maxOutputBytes,
-        successExitCodes: plan.successExitCodes,
+        plan,
+        result,
         exitCode,
-        signal: result.signal,
-        error: result.error?.message ?? null,
         killMethod,
         termination,
-        stdout: result.stdout,
-        stderr: result.stderr,
         writeDrift,
         executorOverheadMs: Math.max(0, Math.round((performance.now() - executorStartedAtMs - childDurationMs) * 1000) / 1000),
         phaseTimings: profiler.getReceiptPhases(),
-        selectionSummary: {
-            strategy: plan.testTargets.length > 0 ? 'project_test_selection' : 'direct_intent',
-            changed_file_count: 0,
-            changed_surface_counts: {},
-            selected_target_count: Math.max(1, plan.testTargets.length),
-            fallback_used: false,
-        },
         stdoutTailBytes: runReceiptPolicy.stdoutTailBytes,
         stderrTailBytes: runReceiptPolicy.stderrTailBytes,
-        receiptPath: createRunReceiptRelativePath(),
     }));
     if (options.writeLatestReceipt !== false) {
         profiler.measure('receipt_write', () => writeRunReceipt(projectRoot, receipt));
@@ -616,6 +247,10 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
             reporter.stderr(t(lang, 'run.error.timedOut', { intent: intentName, seconds: plan.timeoutSeconds }));
             return 1;
         }
+        if (isOutputLimitExceededError(result.error)) {
+            reporter.stderr(t(lang, 'run.error.outputLimitExceeded', { intent: intentName, message: result.error.message }));
+            return 1;
+        }
         reporter.stderr(t(lang, 'run.error.startFailed', { intent: intentName, message: result.error.message }));
         return 1;
     }