minutework 0.1.0

package/dist/sandbox.js

@@ -0,0 +1,852 @@
+import * as childProcess from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { analyzeCompilerWorkspace, } from "@minutework/schema-compiler";
+import { collectLocalRuntimeStatus, createSha256Digest, loadLocalRuntimeStatusContext, } from "@minutework/workspace-mcp";
+import { formatJson as formatCompilerJson, writeCodegenArtifacts, writeCompileGraph } from "./compile.js";
+export async function runSandboxCommand(options) {
+    const [subcommand, ...rest] = options.args;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+        options.io.stdout(renderSandboxHelp());
+        return 0;
+    }
+    if (subcommand === "status") {
+        return runSandboxStatusCommand({
+            args: rest,
+            cwd: options.cwd,
+            env: options.env,
+            io: options.io,
+            platform: options.platform,
+        });
+    }
+    options.io.stderr(`Unknown "sandbox" subcommand: ${subcommand}`);
+    options.io.stderr("");
+    options.io.stderr(renderSandboxHelp());
+    return 1;
+}
+export async function runDevCommand(options) {
+    return runLocalRuntimeCommand("dev", options);
+}
+export async function runTestCommand(options) {
+    return runLocalRuntimeCommand("test", options);
+}
+async function runSandboxStatusCommand(options) {
+    const parsed = parseSandboxStatusArgs(options.args);
+    if (parsed.help) {
+        options.io.stdout(renderSandboxStatusHelp());
+        return 0;
+    }
+    const context = await loadLocalRuntimeStatusContext({
+        cwd: options.cwd,
+        env: options.env,
+        platform: options.platform,
+        workspacePath: parsed.workspacePath,
+    });
+    const status = collectLocalRuntimeStatus(context);
+    options.io.stdout(formatLocalRuntimeJson(status));
+    return status.status === "ready" ? 0 : 1;
+}
+async function runLocalRuntimeCommand(commandName, options) {
+    const parsed = parseLocalRuntimeCommandArgs(options.args, commandName);
+    if (parsed.help) {
+        options.io.stdout(commandName === "dev" ? renderDevHelp() : renderTestHelp());
+        return 0;
+    }
+    const initialContext = await loadLocalRuntimeStatusContext({
+        cwd: options.cwd,
+        env: options.env,
+        platform: options.platform,
+        workspacePath: parsed.workspacePath,
+    });
+    const initialStatus = collectLocalRuntimeStatus(initialContext);
+    const initialPlan = getLocalRuntimeCommandPlan(initialStatus, commandName);
+    const currentActivity = getLocalRuntimeActivitySummary(initialStatus, commandName);
+    const runtimeStatePath = getLocalRuntimeStatePath(initialStatus, commandName);
+    if (currentActivity.status === "running") {
+        options.io.stderr(currentActivity.detail);
+        options.io.stderr(`Recorded activity: ${currentActivity.filePath}`);
+        return 1;
+    }
+    const tracker = new LocalRuntimeActivityTracker(commandName, runtimeStatePath, options.dependencies?.controllerPid ?? process.pid);
+    const preflightState = {};
+    let currentStep = null;
+    try {
+        await tracker.initialize(initialPlan.steps.filter(isManagedPreflightStep));
+        for (const step of initialPlan.steps) {
+            if (!isManagedPreflightStep(step)) {
+                continue;
+            }
+            currentStep = step;
+            await tracker.markStepRunning(step);
+            const exitCode = await runManagedPreflightStep(step, initialContext.workspaceRoot, preflightState, options.io);
+            if (preflightState.analysis?.compileGraph && step.args[0] !== "validate") {
+                await tracker.setCompileGraphDigest(preflightState.analysis.compileGraph);
+            }
+            if (exitCode !== 0) {
+                await tracker.markStepFailed(step, {
+                    errorCode: null,
+                    exitCode,
+                    interrupted: false,
+                    signal: null,
+                });
+                await tracker.markPendingStepsSkipped();
+                await tracker.finalize("failed", {
+                    errorCode: null,
+                    exitCode,
+                    failedStepId: step.id,
+                    signal: null,
+                });
+                return exitCode;
+            }
+            await tracker.markStepCompleted(step, { code: 0, signal: null });
+            currentStep = null;
+        }
+        const refreshedContext = await loadLocalRuntimeStatusContext({
+            cwd: options.cwd,
+            env: options.env,
+            platform: options.platform,
+            workspacePath: parsed.workspacePath,
+        });
+        const refreshedStatus = collectLocalRuntimeStatus(refreshedContext);
+        const commandPlan = getLocalRuntimeCommandPlan(refreshedStatus, commandName);
+        await tracker.syncPlan(commandPlan.steps);
+        if (commandPlan.status !== "ready") {
+            await tracker.markPendingStepsSkipped();
+            await tracker.finalize("failed", {
+                errorCode: commandPlan.prerequisiteCodes[0] ?? null,
+                exitCode: 1,
+                failedStepId: null,
+                signal: null,
+            });
+            options.io.stderr(commandPlan.detail);
+            if (commandPlan.prerequisiteCodes.length > 0) {
+                options.io.stderr(`Blocked prerequisites: ${commandPlan.prerequisiteCodes.join(", ")}`);
+            }
+            return 1;
+        }
+        const starterSteps = commandPlan.steps.filter((step) => !isManagedPreflightStep(step));
+        if (starterSteps.length === 0) {
+            await tracker.finalize(getSuccessStatus(commandName), {
+                errorCode: null,
+                exitCode: 0,
+                failedStepId: null,
+                signal: null,
+            });
+            options.io.stdout(commandName === "test"
+                ? "No starter-local test steps are configured. Schema validation, compile, and codegen are current."
+                : "No local preview surfaces are configured for this workspace.");
+            return 0;
+        }
+        if (commandName === "dev") {
+            return runConcurrentLocalRuntimeSteps(starterSteps, options, tracker);
+        }
+        return runSequentialLocalRuntimeSteps(starterSteps, options, tracker);
+    }
+    catch (error) {
+        if (!tracker.isFinalized()) {
+            if (currentStep) {
+                await tracker.markStepFailed(currentStep, {
+                    errorCode: errorCodeFromUnknown(error),
+                    exitCode: 1,
+                    interrupted: false,
+                    signal: null,
+                });
+            }
+            await tracker.markPendingStepsSkipped();
+            await tracker.finalize("failed", {
+                errorCode: errorCodeFromUnknown(error),
+                exitCode: 1,
+                failedStepId: currentStep?.id ?? null,
+                signal: null,
+            });
+        }
+        throw error;
+    }
+}
+function parseSandboxStatusArgs(args) {
+    let workspacePath;
+    const setWorkspacePath = (value) => {
+        if (workspacePath) {
+            throw new Error('The "sandbox status" command accepts at most one workspace path.');
+        }
+        workspacePath = value;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h") {
+            return { help: true };
+        }
+        if (arg === "--workspace") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("--")) {
+                throw new Error('The "sandbox status" command requires a path after --workspace.');
+            }
+            setWorkspacePath(next);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--workspace=")) {
+            const value = arg.slice("--workspace=".length);
+            if (!value) {
+                throw new Error('The "sandbox status" command requires a path after --workspace.');
+            }
+            setWorkspacePath(value);
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown sandbox status option: ${arg}`);
+        }
+        setWorkspacePath(arg);
+    }
+    return {
+        help: false,
+        workspacePath,
+    };
+}
+function parseLocalRuntimeCommandArgs(args, commandName) {
+    let workspacePath;
+    const setWorkspacePath = (value) => {
+        if (workspacePath) {
+            throw new Error(`${commandName} accepts at most one workspace path.`);
+        }
+        workspacePath = value;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h") {
+            return { help: true };
+        }
+        if (arg === "--workspace") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("--")) {
+                throw new Error(`The "${commandName}" command requires a path after --workspace.`);
+            }
+            setWorkspacePath(next);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--workspace=")) {
+            const value = arg.slice("--workspace=".length);
+            if (!value) {
+                throw new Error(`The "${commandName}" command requires a path after --workspace.`);
+            }
+            setWorkspacePath(value);
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown ${commandName} option: ${arg}`);
+        }
+        setWorkspacePath(arg);
+    }
+    return {
+        help: false,
+        workspacePath,
+    };
+}
+function getLocalRuntimeCommandPlan(status, commandName) {
+    const command = status.commands.find((item) => item.name === commandName);
+    if (!command) {
+        throw new Error(`Local sandbox status did not define a "${commandName}" command plan.`);
+    }
+    return command;
+}
+function getLocalRuntimeActivitySummary(status, commandName) {
+    return commandName === "dev" ? status.activity.dev : status.activity.test;
+}
+function getLocalRuntimeStatePath(status, commandName) {
+    return commandName === "dev" ? status.topology.devSessionPath : status.topology.testRunPath;
+}
+function isManagedPreflightStep(step) {
+    return (step.program === "minutework" &&
+        step.args.length > 0 &&
+        (step.args[0] === "validate" || step.args[0] === "compile" || step.args[0] === "codegen"));
+}
+async function runManagedPreflightStep(step, workspaceRoot, state, io) {
+    io.stdout(renderStepBanner(step));
+    if (!state.analysis) {
+        state.analysis = await analyzeCompilerWorkspace(workspaceRoot);
+    }
+    const analysis = state.analysis;
+    if (analysis.validateReport.status !== "ok") {
+        io.stderr(formatCompilerJson(analysis.validateReport));
+        return 1;
+    }
+    if (step.args[0] === "validate") {
+        return 0;
+    }
+    if (!analysis.compileGraph) {
+        io.stderr(formatCompilerJson(analysis.validateReport));
+        return 1;
+    }
+    await writeCompileGraph(workspaceRoot, analysis.compileGraph);
+    if (step.args[0] === "compile") {
+        return 0;
+    }
+    if (!analysis.codegenArtifacts) {
+        io.stderr(formatCompilerJson(analysis.validateReport));
+        return 1;
+    }
+    await writeCodegenArtifacts(workspaceRoot, analysis.compileGraph.artifacts, analysis.codegenArtifacts);
+    return 0;
+}
+async function runSequentialLocalRuntimeSteps(steps, options, tracker) {
+    let activeChild = null;
+    const cleanupSignalForwarding = installSignalForwarding({
+        getChildren: () => (activeChild ? [activeChild] : []),
+        signalTarget: options.dependencies?.signalTarget,
+    });
+    try {
+        for (const step of steps) {
+            options.io.stdout(renderStepBanner(step));
+            let runningStep;
+            try {
+                runningStep = spawnLocalRuntimeStep(step, options.env, options.dependencies);
+            }
+            catch (error) {
+                const spawnError = error instanceof LocalRuntimeSpawnError ? error : createLocalRuntimeSpawnError(step, error);
+                await tracker.markStepFailed(step, {
+                    errorCode: spawnError.code,
+                    exitCode: 1,
+                    interrupted: false,
+                    signal: null,
+                });
+                await tracker.markPendingStepsSkipped();
+                await tracker.finalize("failed", {
+                    errorCode: spawnError.code,
+                    exitCode: 1,
+                    failedStepId: step.id,
+                    signal: null,
+                });
+                options.io.stderr(spawnError.message);
+                return 1;
+            }
+            activeChild = runningStep.child;
+            await tracker.markStepRunning(step, runningStep.child.pid ?? null);
+            const outcome = await waitForRunningStepOutcome(runningStep);
+            activeChild = null;
+            await applyRunningStepOutcomeToTracker(tracker, outcome);
+            if (outcome.type === "error") {
+                const errorCode = errorCodeFromUnknown(outcome.error);
+                options.io.stderr(outcome.error instanceof Error ? outcome.error.message : String(outcome.error));
+                await tracker.markPendingStepsSkipped();
+                await tracker.finalize("failed", {
+                    errorCode,
+                    exitCode: 1,
+                    failedStepId: step.id,
+                    signal: null,
+                });
+                return 1;
+            }
+            if (outcome.result.signal) {
+                await tracker.markPendingStepsSkipped();
+                await tracker.finalize("interrupted", {
+                    errorCode: null,
+                    exitCode: null,
+                    failedStepId: step.id,
+                    signal: outcome.result.signal,
+                });
+                return 1;
+            }
+            const exitCode = exitCodeFromChildResult(outcome.result);
+            if (exitCode !== 0) {
+                await tracker.markPendingStepsSkipped();
+                await tracker.finalize("failed", {
+                    errorCode: null,
+                    exitCode,
+                    failedStepId: step.id,
+                    signal: null,
+                });
+                return exitCode;
+            }
+        }
+        await tracker.finalize("passed", {
+            errorCode: null,
+            exitCode: 0,
+            failedStepId: null,
+            signal: null,
+        });
+        return 0;
+    }
+    finally {
+        cleanupSignalForwarding();
+    }
+}
+async function runConcurrentLocalRuntimeSteps(steps, options, tracker) {
+    const runningSteps = [];
+    const cleanupSignalForwarding = installSignalForwarding({
+        getChildren: () => runningSteps.map((runningStep) => runningStep.child),
+        signalTarget: options.dependencies?.signalTarget,
+    });
+    try {
+        for (const step of steps) {
+            options.io.stdout(renderStepBanner(step));
+            let runningStep;
+            try {
+                runningStep = spawnLocalRuntimeStep(step, options.env, options.dependencies);
+            }
+            catch (error) {
+                const spawnError = error instanceof LocalRuntimeSpawnError ? error : createLocalRuntimeSpawnError(step, error);
+                await tracker.markStepFailed(step, {
+                    errorCode: spawnError.code,
+                    exitCode: 1,
+                    interrupted: false,
+                    signal: null,
+                });
+                const siblingOutcomes = await terminateSiblingProcesses(runningSteps);
+                await applyRunningStepOutcomesToTracker(tracker, siblingOutcomes);
+                await tracker.markPendingStepsSkipped();
+                await tracker.finalize("failed", {
+                    errorCode: spawnError.code,
+                    exitCode: 1,
+                    failedStepId: step.id,
+                    signal: null,
+                });
+                options.io.stderr(spawnError.message);
+                return 1;
+            }
+            runningSteps.push(runningStep);
+            await tracker.markStepRunning(step, runningStep.child.pid ?? null);
+        }
+        const firstOutcome = await Promise.race(runningSteps.map((runningStep) => waitForRunningStepOutcome(runningStep)));
+        const siblingOutcomes = await terminateSiblingProcesses(runningSteps.filter((runningStep) => runningStep !== firstOutcome.runningStep));
+        await applyRunningStepOutcomeToTracker(tracker, firstOutcome);
+        await applyRunningStepOutcomesToTracker(tracker, siblingOutcomes);
+        if (firstOutcome.type === "error") {
+            const errorCode = errorCodeFromUnknown(firstOutcome.error);
+            options.io.stderr(firstOutcome.error instanceof Error ? firstOutcome.error.message : String(firstOutcome.error));
+            await tracker.finalize("failed", {
+                errorCode,
+                exitCode: 1,
+                failedStepId: firstOutcome.runningStep.step.id,
+                signal: null,
+            });
+            return 1;
+        }
+        if (firstOutcome.result.signal) {
+            await tracker.finalize("interrupted", {
+                errorCode: null,
+                exitCode: null,
+                failedStepId: firstOutcome.runningStep.step.id,
+                signal: firstOutcome.result.signal,
+            });
+            return 1;
+        }
+        const exitCode = exitCodeFromChildResult(firstOutcome.result);
+        if (exitCode !== 0) {
+            await tracker.finalize("failed", {
+                errorCode: null,
+                exitCode,
+                failedStepId: firstOutcome.runningStep.step.id,
+                signal: null,
+            });
+            return exitCode;
+        }
+        await tracker.finalize("exited", {
+            errorCode: null,
+            exitCode: 0,
+            failedStepId: null,
+            signal: null,
+        });
+        return 0;
+    }
+    finally {
+        cleanupSignalForwarding();
+    }
+}
+function spawnLocalRuntimeStep(step, env, dependencies) {
+    const spawnProcess = dependencies?.spawnProcess ?? childProcess.spawn;
+    try {
+        const child = spawnProcess(step.program, step.args, {
+            cwd: step.cwd,
+            env,
+            stdio: "inherit",
+        });
+        const completion = new Promise((resolve, reject) => {
+            child.once("error", (error) => {
+                reject(createLocalRuntimeSpawnError(step, error));
+            });
+            child.once("exit", (code, signal) => {
+                resolve({ code, signal });
+            });
+        });
+        return {
+            child,
+            completion,
+            step,
+        };
+    }
+    catch (error) {
+        throw createLocalRuntimeSpawnError(step, error);
+    }
+}
+function waitForRunningStepOutcome(runningStep) {
+    return runningStep.completion
+        .then((result) => ({
+        result,
+        runningStep,
+        type: "exit",
+    }))
+        .catch((error) => ({
+        error,
+        runningStep,
+        type: "error",
+    }));
+}
+async function terminateSiblingProcesses(runningSteps) {
+    for (const runningStep of runningSteps) {
+        if (runningStep.child.exitCode === null && runningStep.child.signalCode === null) {
+            runningStep.child.kill("SIGTERM");
+        }
+    }
+    return Promise.all(runningSteps.map((runningStep) => waitForRunningStepOutcome(runningStep)));
+}
+function installSignalForwarding(options) {
+    const signals = ["SIGINT", "SIGTERM"];
+    const handlers = new Map();
+    const signalTarget = options.signalTarget ?? process;
+    for (const signal of signals) {
+        const handler = () => {
+            for (const child of options.getChildren()) {
+                if (child.exitCode === null && child.signalCode === null) {
+                    child.kill(signal);
+                }
+            }
+        };
+        handlers.set(signal, handler);
+        signalTarget.on(signal, handler);
+    }
+    return () => {
+        for (const [signal, handler] of handlers) {
+            signalTarget.off(signal, handler);
+        }
+    };
+}
+async function applyRunningStepOutcomesToTracker(tracker, outcomes) {
+    for (const outcome of outcomes) {
+        await applyRunningStepOutcomeToTracker(tracker, outcome);
+    }
+}
+async function applyRunningStepOutcomeToTracker(tracker, outcome) {
+    if (outcome.type === "error") {
+        await tracker.markStepFailed(outcome.runningStep.step, {
+            errorCode: errorCodeFromUnknown(outcome.error),
+            exitCode: 1,
+            interrupted: false,
+            signal: null,
+        });
+        return;
+    }
+    if (outcome.result.signal) {
+        await tracker.markStepFailed(outcome.runningStep.step, {
+            errorCode: null,
+            exitCode: null,
+            interrupted: true,
+            signal: outcome.result.signal,
+        });
+        return;
+    }
+    const exitCode = exitCodeFromChildResult(outcome.result);
+    if (exitCode !== 0) {
+        await tracker.markStepFailed(outcome.runningStep.step, {
+            errorCode: null,
+            exitCode,
+            interrupted: false,
+            signal: null,
+        });
+        return;
+    }
+    await tracker.markStepCompleted(outcome.runningStep.step, outcome.result);
+}
+function createLocalRuntimeSpawnError(step, error) {
+    const errno = error;
+    if (errno.code === "ENOENT") {
+        return new LocalRuntimeSpawnError(step, `Unable to start local sandbox step "${step.id}": program "${step.program}" was not found in ${step.cwd}.`, errno.code);
+    }
+    return new LocalRuntimeSpawnError(step, `Unable to start local sandbox step "${step.id}" with "${step.program}" in ${step.cwd}: ${error instanceof Error ? error.message : String(error)}`, errno.code ?? null);
+}
+function createCompileGraphDigest(compileGraph) {
+    return createSha256Digest(formatCompilerJson(compileGraph));
+}
+function createPendingActivityStep(step) {
+    return {
+        args: [...step.args],
+        cwd: step.cwd,
+        endedAt: null,
+        exitCode: null,
+        id: step.id,
+        pid: null,
+        program: step.program,
+        signal: null,
+        startedAt: null,
+        status: "pending",
+    };
+}
+function createInitialActivityRecord(commandName, controllerPid, steps) {
+    const timestamp = createTimestamp();
+    const base = {
+        compileGraphDigest: null,
+        controllerPid,
+        endedAt: null,
+        outcome: createEmptyOutcome(),
+        startedAt: timestamp,
+        steps: steps.map(createPendingActivityStep),
+        updatedAt: timestamp,
+        version: "MinuteWorkLocalRuntimeActivityV1",
+    };
+    if (commandName === "dev") {
+        return {
+            ...base,
+            command: "dev",
+            status: "running",
+        };
+    }
+    return {
+        ...base,
+        command: "test",
+        status: "running",
+    };
+}
+function mergeActivitySteps(existingSteps, plannedSteps) {
+    const existingById = new Map(existingSteps.map((step) => [step.id, step]));
+    return plannedSteps.map((plannedStep) => {
+        const existingStep = existingById.get(plannedStep.id);
+        if (!existingStep) {
+            return createPendingActivityStep(plannedStep);
+        }
+        return {
+            ...existingStep,
+            args: [...plannedStep.args],
+            cwd: plannedStep.cwd,
+            program: plannedStep.program,
+        };
+    });
+}
+function createEmptyOutcome() {
+    return {
+        errorCode: null,
+        exitCode: null,
+        failedStepId: null,
+        signal: null,
+    };
+}
+function createTimestamp() {
+    return new Date().toISOString();
+}
+async function writeActivityRecord(filePath, record) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.tmp`;
+    await fs.writeFile(tempPath, JSON.stringify(record, null, 2) + "\n", "utf8");
+    await fs.rename(tempPath, filePath);
+}
+function errorCodeFromUnknown(error) {
+    if (error instanceof LocalRuntimeSpawnError) {
+        return error.code;
+    }
+    const errno = error;
+    return typeof errno.code === "string" ? errno.code : null;
+}
+function exitCodeFromChildResult(result) {
+    return result.code ?? (result.signal ? 1 : 0);
+}
+function renderStepBanner(step) {
+    return `==> ${step.detail}`;
+}
+function formatLocalRuntimeJson(payload) {
+    return `${JSON.stringify(payload, null, 2)}\n`;
+}
+function getSuccessStatus(commandName) {
+    return commandName === "dev" ? "exited" : "passed";
+}
+function renderSandboxHelp() {
+    return `Usage:
+  minutework sandbox status [workspace] [--workspace <path>]
+
+Inspect local sandbox topology and readiness for the current MinuteWork workspace.`;
+}
+function renderSandboxStatusHelp() {
+    return `Usage:
+  minutework sandbox status [workspace] [--workspace <path>]
+
+Print deterministic local sandbox status, compile-graph readiness, and planned dev/test steps derived from the current workspace.`;
+}
+function renderDevHelp() {
+    return `Usage:
+  minutework dev [workspace] [--workspace <path>]
+
+Refresh local schema artifacts, then start the enabled local preview surfaces defined by sandbox status.`;
+}
+function renderTestHelp() {
+    return `Usage:
+  minutework test [workspace] [--workspace <path>]
+
+Refresh local schema artifacts, then run the starter-local test steps defined by sandbox status.`;
+}
+class LocalRuntimeActivityTracker {
+    commandName;
+    filePath;
+    finalized = false;
+    record;
+    constructor(commandName, filePath, controllerPid) {
+        this.commandName = commandName;
+        this.filePath = filePath;
+        this.record = createInitialActivityRecord(commandName, controllerPid, []);
+    }
+    async initialize(steps) {
+        this.record = createInitialActivityRecord(this.commandName, this.record.controllerPid, steps);
+        await this.persist();
+    }
+    isFinalized() {
+        return this.finalized;
+    }
+    async syncPlan(steps) {
+        this.record = {
+            ...this.record,
+            steps: mergeActivitySteps(this.record.steps, steps),
+            updatedAt: createTimestamp(),
+        };
+        await this.persist();
+    }
+    async setCompileGraphDigest(compileGraph) {
+        this.record = {
+            ...this.record,
+            compileGraphDigest: createCompileGraphDigest(compileGraph),
+            updatedAt: createTimestamp(),
+        };
+        await this.persist();
+    }
+    async markStepRunning(step, pid = null) {
+        this.updateStep(step, (currentStep) => {
+            const startedAt = currentStep.startedAt ?? createTimestamp();
+            return {
+                ...currentStep,
+                args: [...step.args],
+                cwd: step.cwd,
+                endedAt: null,
+                exitCode: null,
+                pid: pid ?? currentStep.pid ?? null,
+                program: step.program,
+                signal: null,
+                startedAt,
+                status: "running",
+            };
+        });
+        await this.persist();
+    }
+    async markStepCompleted(step, result) {
+        this.updateStep(step, (currentStep) => ({
+            ...currentStep,
+            args: [...step.args],
+            cwd: step.cwd,
+            endedAt: createTimestamp(),
+            exitCode: result.code ?? 0,
+            program: step.program,
+            signal: result.signal,
+            startedAt: currentStep.startedAt ?? createTimestamp(),
+            status: "completed",
+        }));
+        await this.persist();
+    }
+    async markStepFailed(step, options) {
+        this.updateStep(step, (currentStep) => ({
+            ...currentStep,
+            args: [...step.args],
+            cwd: step.cwd,
+            endedAt: createTimestamp(),
+            exitCode: options.exitCode,
+            program: step.program,
+            signal: options.signal,
+            status: options.interrupted ? "interrupted" : "failed",
+        }));
+        if (!this.record.outcome.failedStepId) {
+            this.record = {
+                ...this.record,
+                outcome: {
+                    errorCode: options.errorCode,
+                    exitCode: options.exitCode,
+                    failedStepId: step.id,
+                    signal: options.signal,
+                },
+                updatedAt: createTimestamp(),
+            };
+        }
+        await this.persist();
+    }
+    async markPendingStepsSkipped() {
+        const timestamp = createTimestamp();
+        this.record = {
+            ...this.record,
+            steps: this.record.steps.map((step) => step.status === "pending"
+                ? {
+                    ...step,
+                    endedAt: timestamp,
+                    status: "skipped",
+                }
+                : step),
+            updatedAt: timestamp,
+        };
+        await this.persist();
+    }
+    async finalize(status, outcome) {
+        const timestamp = createTimestamp();
+        if (this.commandName === "dev") {
+            if (status === "passed") {
+                throw new Error('The dev runtime activity record cannot be finalized with "passed".');
+            }
+            this.record = {
+                ...this.record,
+                endedAt: timestamp,
+                outcome,
+                status,
+                updatedAt: timestamp,
+            };
+        }
+        else {
+            if (status === "exited") {
+                throw new Error('The test runtime activity record cannot be finalized with "exited".');
+            }
+            this.record = {
+                ...this.record,
+                endedAt: timestamp,
+                outcome,
+                status,
+                updatedAt: timestamp,
+            };
+        }
+        this.finalized = true;
+        await this.persist();
+    }
+    ensureStep(step) {
+        const existingIndex = this.record.steps.findIndex((currentStep) => currentStep.id === step.id);
+        if (existingIndex !== -1) {
+            return existingIndex;
+        }
+        this.record = {
+            ...this.record,
+            steps: [...this.record.steps, createPendingActivityStep(step)],
+        };
+        return this.record.steps.length - 1;
+    }
+    updateStep(step, updater) {
+        const index = this.ensureStep(step);
+        const nextSteps = [...this.record.steps];
+        nextSteps[index] = updater(nextSteps[index]);
+        this.record = {
+            ...this.record,
+            steps: nextSteps,
+            updatedAt: createTimestamp(),
+        };
+    }
+    async persist() {
+        await writeActivityRecord(this.filePath, this.record);
+    }
+}
+class LocalRuntimeSpawnError extends Error {
+    step;
+    code;
+    constructor(step, message, code) {
+        super(message);
+        this.step = step;
+        this.code = code;
+    }
+}
+//# sourceMappingURL=sandbox.js.map