@livingdata/pipex 0.0.9 → 0.0.10

package/dist/cli/__tests__/step-runner.js

@@ -0,0 +1,116 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import test from 'ava';
+import { Workspace } from '../../engine/workspace.js';
+import { DockerCliExecutor } from '../../engine/docker-executor.js';
+import { ContainerCrashError } from '../../errors.js';
+import { StateManager } from '../state.js';
+import { StepRunner } from '../step-runner.js';
+import { createTmpDir, isDockerAvailable, noopReporter, recordingReporter } from '../../__tests__/helpers.js';
+const hasDocker = isDockerAvailable();
+const dockerTest = hasDocker ? test : test.skip;
+// -- helpers -----------------------------------------------------------------
+function makeStep(overrides) {
+    return {
+        image: 'alpine:3.20',
+        cmd: ['sh', '-c', 'echo hello'],
+        ...overrides
+    };
+}
+async function setupWorkspace() {
+    const tmpDir = await createTmpDir();
+    const workspace = await Workspace.create(tmpDir, 'test-ws');
+    const state = new StateManager(workspace.root);
+    await state.load();
+    return { workspace, state, tmpDir };
+}
+// -- minimal execution -------------------------------------------------------
+dockerTest('minimal step writes artifact and returns exitCode 0', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const runner = new StepRunner(new DockerCliExecutor(), noopReporter);
+    const step = makeStep({ id: 'greet', cmd: ['sh', '-c', 'echo hello > /output/greeting.txt'] });
+    const result = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' });
+    t.is(result.exitCode, 0);
+    t.truthy(result.runId);
+    // Artifact exists in committed run
+    const content = await readFile(join(workspace.runArtifactsPath(result.runId), 'greeting.txt'), 'utf8');
+    t.is(content.trim(), 'hello');
+});
+dockerTest('meta.json exists with correct fields', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const runner = new StepRunner(new DockerCliExecutor(), noopReporter);
+    const step = makeStep({ id: 'meta-test', cmd: ['sh', '-c', 'echo ok > /output/out.txt'] });
+    const result = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' });
+    const metaPath = join(workspace.runPath(result.runId), 'meta.json');
+    const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+    t.is(meta.runId, result.runId);
+    t.is(meta.exitCode, 0);
+    t.is(meta.image, 'alpine:3.20');
+    t.deepEqual(meta.cmd, ['sh', '-c', 'echo ok > /output/out.txt']);
+});
+// -- log capture -------------------------------------------------------------
+dockerTest('stdout and stderr are captured to log files', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const runner = new StepRunner(new DockerCliExecutor(), noopReporter);
+    const step = makeStep({ id: 'logs', cmd: ['sh', '-c', 'echo out-line && echo err-line >&2'] });
+    const result = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' });
+    const stdout = await readFile(join(workspace.runPath(result.runId), 'stdout.log'), 'utf8');
+    const stderr = await readFile(join(workspace.runPath(result.runId), 'stderr.log'), 'utf8');
+    t.true(stdout.includes('out-line'));
+    t.true(stderr.includes('err-line'));
+});
+// -- cache hit ---------------------------------------------------------------
+dockerTest('second run of same step is cached (STEP_SKIPPED)', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const { reporter, events } = recordingReporter();
+    const runner = new StepRunner(new DockerCliExecutor(), reporter);
+    const step = makeStep({ id: 'cached', cmd: ['sh', '-c', 'echo hi > /output/x.txt'] });
+    const first = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' });
+    const second = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' });
+    t.is(first.runId, second.runId);
+    const skipped = events.find(e => e.event === 'STEP_SKIPPED');
+    t.truthy(skipped);
+    t.is(skipped.reason, 'cached');
+});
+// -- force -------------------------------------------------------------------
+dockerTest('force: true produces new runId', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const runner = new StepRunner(new DockerCliExecutor(), noopReporter);
+    const step = makeStep({ id: 'force-test', cmd: ['sh', '-c', 'echo data > /output/f.txt'] });
+    const first = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' });
+    const second = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/', force: true });
+    t.not(first.runId, second.runId);
+    t.is(second.exitCode, 0);
+});
+// -- ephemeral ---------------------------------------------------------------
+dockerTest('ephemeral: true returns exitCode but no runId', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const runner = new StepRunner(new DockerCliExecutor(), noopReporter);
+    const step = makeStep({ id: 'ephemeral', cmd: ['sh', '-c', 'echo temp > /output/t.txt'] });
+    const result = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/', ephemeral: true });
+    t.is(result.exitCode, 0);
+    t.is(result.runId, undefined);
+    // No run committed
+    const runs = await workspace.listRuns();
+    t.is(runs.length, 0);
+});
+// -- failure -----------------------------------------------------------------
+dockerTest('non-zero exit throws ContainerCrashError', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const runner = new StepRunner(new DockerCliExecutor(), noopReporter);
+    const step = makeStep({ id: 'fail', cmd: ['sh', '-c', 'exit 1'] });
+    const error = await t.throwsAsync(async () => runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' }));
+    t.true(error instanceof ContainerCrashError);
+});
+// -- allowFailure ------------------------------------------------------------
+dockerTest('allowFailure: true commits run with non-zero exitCode', async (t) => {
+    const { workspace, state } = await setupWorkspace();
+    const runner = new StepRunner(new DockerCliExecutor(), noopReporter);
+    const step = makeStep({ id: 'allow-fail', cmd: ['sh', '-c', 'exit 1'], allowFailure: true });
+    const result = await runner.run({ workspace, state, step, inputs: new Map(), pipelineRoot: '/' });
+    t.truthy(result.runId);
+    t.is(result.exitCode, 1);
+    // Run was committed
+    const runs = await workspace.listRuns();
+    t.true(runs.includes(result.runId));
+});

package/dist/cli/commands/bundle.js

@@ -0,0 +1,35 @@
+import process from 'node:process';
+import { writeFile } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import chalk from 'chalk';
+import { buildBundle } from '../../core/bundle.js';
+import { PipelineLoader } from '../../core/pipeline-loader.js';
+import { formatSize } from '../../core/utils.js';
+export function registerBundleCommand(program) {
+    program
+        .command('bundle')
+        .description('Package a pipeline and its local dependencies into a tar.gz archive')
+        .argument('<pipeline>', 'Path to the pipeline file')
+        .option('-o, --output <path>', 'Output file path (default: <pipeline-id>.tar.gz)')
+        .action(async (pipelineFile, options) => {
+        try {
+            const pipelinePath = resolve(pipelineFile);
+            // Determine output path
+            let outputPath = options.output;
+            if (!outputPath) {
+                const loader = new PipelineLoader();
+                const pipeline = await loader.load(pipelinePath);
+                outputPath = `${pipeline.id}.tar.gz`;
+            }
+            outputPath = resolve(outputPath);
+            const archive = await buildBundle(pipelinePath);
+            await writeFile(outputPath, archive);
+            console.log(chalk.green(`Bundle created: ${basename(outputPath)} (${formatSize(archive.length)})`));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`Bundle failed: ${message}`));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/cat.js

@@ -0,0 +1,54 @@
+import process from 'node:process';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerCatCommand(program) {
+    program
+        .command('cat')
+        .description('Read artifact content from a step\'s latest run')
+        .argument('<workspace>', 'Workspace name')
+        .argument('<step>', 'Step ID')
+        .argument('[path]', 'Path within artifacts (omit to list)')
+        .action(async (workspaceName, stepId, artifactPath, _options, cmd) => {
+        const { workdir } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const stepState = state.getStep(stepId);
+        if (!stepState) {
+            console.error(chalk.red(`No run found for step: ${stepId}`));
+            process.exitCode = 1;
+            return;
+        }
+        const artifactsDir = workspace.runArtifactsPath(stepState.runId);
+        const targetPath = artifactPath ? join(artifactsDir, artifactPath) : artifactsDir;
+        // Prevent path traversal
+        if (!targetPath.startsWith(artifactsDir)) {
+            console.error(chalk.red('Invalid path: must be within artifacts directory'));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const info = await stat(targetPath);
+            if (info.isDirectory()) {
+                const entries = await readdir(targetPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const suffix = entry.isDirectory() ? '/' : '';
+                    console.log(entry.name + suffix);
+                }
+            }
+            else {
+                const content = await readFile(targetPath);
+                process.stdout.write(content);
+            }
+        }
+        catch {
+            console.error(chalk.red(`Not found: ${artifactPath ?? '(artifacts directory)'}`));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/exec.js

@@ -0,0 +1,89 @@
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+import { dirname, resolve } from 'node:path';
+import { DockerCliExecutor } from '../../engine/docker-executor.js';
+import { Workspace } from '../../engine/workspace.js';
+import { loadStepFile } from '../../core/step-loader.js';
+import { StepRunner } from '../../core/step-runner.js';
+import { StateManager } from '../../core/state.js';
+import { ConsoleReporter } from '../../core/reporter.js';
+import { InteractiveReporter } from '../interactive-reporter.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerExecCommand(program) {
+    program
+        .command('exec')
+        .description('Execute a single step in a workspace')
+        .argument('<workspace>', 'Workspace name')
+        .requiredOption('-f, --file <path>', 'Step definition file (YAML or JSON)')
+        .option('--step <id>', 'Step ID (overrides file\'s id)')
+        .option('--input <specs...>', 'Input steps (e.g. "extract" or "data=extract")')
+        .option('--ephemeral', 'Don\'t commit run, stream stdout to terminal')
+        .option('--force', 'Skip cache check')
+        .option('--verbose', 'Stream container logs in real-time')
+        .action(async (workspaceName, options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const runtime = new DockerCliExecutor();
+        const reporter = json ? new ConsoleReporter() : new InteractiveReporter({ verbose: options.verbose });
+        // Load step from file
+        const stepFilePath = resolve(options.file);
+        const step = await loadStepFile(stepFilePath, options.step);
+        const pipelineRoot = dirname(stepFilePath);
+        // Open or create workspace
+        let workspace;
+        try {
+            workspace = await Workspace.open(workdirRoot, workspaceName);
+        }
+        catch {
+            workspace = await Workspace.create(workdirRoot, workspaceName);
+        }
+        await workspace.cleanupStaging();
+        await runtime.check();
+        await runtime.cleanupContainers(workspace.id);
+        // Load state and resolve inputs
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const inputs = new Map();
+        if (options.input) {
+            for (const spec of options.input) {
+                const { alias, stepId } = parseInputSpec(spec);
+                const stepState = state.getStep(stepId);
+                if (!stepState) {
+                    console.error(`No run found for input step: ${stepId}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                inputs.set(alias, stepState.runId);
+            }
+        }
+        // Merge parsed inputs into step.inputs
+        if (inputs.size > 0 && !step.inputs) {
+            step.inputs = [];
+        }
+        for (const [alias, _runId] of inputs) {
+            // Only add if not already declared in step file
+            if (!step.inputs.some(i => i.step === alias)) {
+                step.inputs.push({ step: alias });
+            }
+        }
+        const job = { workspaceId: workspace.id, jobId: randomUUID() };
+        const runner = new StepRunner(runtime, reporter);
+        await runner.run({
+            workspace,
+            state,
+            step,
+            inputs,
+            pipelineRoot,
+            force: options.force,
+            ephemeral: options.ephemeral,
+            job
+        });
+    });
+}
+function parseInputSpec(spec) {
+    const eqIdx = spec.indexOf('=');
+    if (eqIdx > 0) {
+        return { alias: spec.slice(0, eqIdx), stepId: spec.slice(eqIdx + 1) };
+    }
+    return { alias: spec, stepId: spec };
+}

package/dist/cli/commands/export.js

@@ -3,7 +3,7 @@ import { cp } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import chalk from 'chalk';
 import { Workspace } from '../../engine/workspace.js';
-import { StateManager } from '../state.js';
+import { StateManager } from '../../core/state.js';
 import { getGlobalOptions } from '../utils.js';
 export function registerExportCommand(program) {
     program
@@ -12,7 +12,7 @@ export function registerExportCommand(program) {
         .argument('<workspace>', 'Workspace name')
         .argument('<step>', 'Step ID')
         .argument('<dest>', 'Destination directory')
-        .action(async (workspaceName, stepId, dest, cmd) => {
+        .action(async (workspaceName, stepId, dest, _options, cmd) => {
         const { workdir } = getGlobalOptions(cmd);
         const workdirRoot = resolve(workdir);
         const workspace = await Workspace.open(workdirRoot, workspaceName);

package/dist/cli/commands/inspect.js

@@ -3,7 +3,7 @@ import { readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import chalk from 'chalk';
 import { Workspace } from '../../engine/workspace.js';
-import { StateManager } from '../state.js';
+import { StateManager } from '../../core/state.js';
 import { getGlobalOptions } from '../utils.js';
 export function registerInspectCommand(program) {
     program

package/dist/cli/commands/list.js

@@ -1,7 +1,8 @@
 import { resolve } from 'node:path';
 import chalk from 'chalk';
 import { Workspace } from '../../engine/workspace.js';
-import { dirSize, formatSize, getGlobalOptions } from '../utils.js';
+import { dirSize, formatSize } from '../../core/utils.js';
+import { getGlobalOptions } from '../utils.js';
 export function registerListCommand(program) {
     program
         .command('list')

package/dist/cli/commands/logs.js

@@ -3,7 +3,7 @@ import { readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import chalk from 'chalk';
 import { Workspace } from '../../engine/workspace.js';
-import { StateManager } from '../state.js';
+import { StateManager } from '../../core/state.js';
 import { getGlobalOptions } from '../utils.js';
 export function registerLogsCommand(program) {
     program

package/dist/cli/commands/prune.js

@@ -1,7 +1,7 @@
 import { resolve } from 'node:path';
 import chalk from 'chalk';
 import { Workspace } from '../../engine/workspace.js';
-import { StateManager } from '../state.js';
+import { StateManager } from '../../core/state.js';
 import { getGlobalOptions } from '../utils.js';
 export function registerPruneCommand(program) {
     program

package/dist/cli/commands/rm-step.js

@@ -0,0 +1,41 @@
+import process from 'node:process';
+import { rm } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { dirSize, formatSize } from '../../core/utils.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerRmStepCommand(program) {
+    program
+        .command('rm-step')
+        .description('Remove a step\'s run and state entry')
+        .argument('<workspace>', 'Workspace name')
+        .argument('<step>', 'Step ID')
+        .action(async (workspaceName, stepId, _options, cmd) => {
+        const { workdir } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const stepState = state.getStep(stepId);
+        if (!stepState) {
+            console.error(chalk.red(`No run found for step: ${stepId}`));
+            process.exitCode = 1;
+            return;
+        }
+        const { runId } = stepState;
+        // Measure size before removal
+        const runDir = workspace.runPath(runId);
+        const size = await dirSize(runDir);
+        // Remove run directory
+        await rm(runDir, { recursive: true, force: true });
+        // Remove step-runs symlink
+        const linkPath = join(workspace.root, 'step-runs', stepId);
+        await rm(linkPath, { force: true });
+        // Remove from state
+        state.removeStep(stepId);
+        await state.save();
+        console.log(chalk.green(`Removed step ${chalk.bold(stepId)} (run ${runId}, freed ${formatSize(size)})`));
+    });
+}

package/dist/cli/commands/run-bundle.js

@@ -0,0 +1,59 @@
+import process from 'node:process';
+import { readFile, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { DockerCliExecutor } from '../../engine/docker-executor.js';
+import { extractBundle } from '../../core/bundle.js';
+import { PipelineLoader } from '../../core/pipeline-loader.js';
+import { PipelineRunner } from '../../core/pipeline-runner.js';
+import { ConsoleReporter } from '../../core/reporter.js';
+import { InteractiveReporter } from '../interactive-reporter.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerRunBundleCommand(program) {
+    program
+        .command('run-bundle')
+        .description('Execute a pipeline from a bundle archive')
+        .argument('<archive>', 'Bundle archive (.tar.gz)')
+        .option('-w, --workspace <name>', 'Workspace name (for caching)')
+        .option('-f, --force [steps]', 'Skip cache for all steps, or a comma-separated list')
+        .option('--dry-run', 'Validate pipeline and show what would run without executing')
+        .option('--verbose', 'Stream container logs in real-time (interactive mode)')
+        .option('-t, --target <steps>', 'Execute only these steps and their dependencies (comma-separated)')
+        .option('-c, --concurrency <number>', 'Max parallel step executions (default: CPU count)', Number)
+        .action(async (archivePath, options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const archive = await readFile(resolve(archivePath));
+        const extractDir = join(tmpdir(), `pipex-run-bundle-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        try {
+            const pipeline = await extractBundle(archive, extractDir);
+            // Write a pipeline.json so PipelineRunner can load it normally.
+            // The extract directory becomes the pipelineRoot — all relative
+            // host paths in mounts/sources resolve against it.
+            const pipelineFile = join(extractDir, 'pipeline.json');
+            await writeFile(pipelineFile, JSON.stringify(pipeline));
+            const loader = new PipelineLoader();
+            const runtime = new DockerCliExecutor();
+            const reporter = json ? new ConsoleReporter() : new InteractiveReporter({ verbose: options.verbose });
+            const runner = new PipelineRunner(loader, runtime, reporter, workdirRoot);
+            const force = options.force === true
+                ? true
+                : (typeof options.force === 'string' ? options.force.split(',') : undefined);
+            const target = options.target ? options.target.split(',') : undefined;
+            await runner.run(pipelineFile, { workspace: options.workspace, force, dryRun: options.dryRun, target, concurrency: options.concurrency });
+            if (json) {
+                console.log('Pipeline completed');
+            }
+        }
+        catch (error) {
+            if (json) {
+                console.error('Pipeline failed:', error instanceof Error ? error.message : error);
+            }
+            process.exitCode = 1;
+            throw error;
+        }
+        finally {
+            await rm(extractDir, { recursive: true, force: true });
+        }
+    });
+}

package/dist/cli/commands/run.js

@@ -1,8 +1,9 @@
 import { resolve } from 'node:path';
 import { DockerCliExecutor } from '../../engine/docker-executor.js';
-import { PipelineLoader } from '../pipeline-loader.js';
-import { PipelineRunner } from '../pipeline-runner.js';
-import { ConsoleReporter, InteractiveReporter } from '../reporter.js';
+import { PipelineLoader } from '../../core/pipeline-loader.js';
+import { PipelineRunner } from '../../core/pipeline-runner.js';
+import { ConsoleReporter } from '../../core/reporter.js';
+import { InteractiveReporter } from '../interactive-reporter.js';
 import { getGlobalOptions } from '../utils.js';
 export function registerRunCommand(program) {
     program
@@ -13,6 +14,9 @@ export function registerRunCommand(program) {
         .option('-f, --force [steps]', 'Skip cache for all steps, or a comma-separated list (e.g. --force step1,step2)')
         .option('--dry-run', 'Validate pipeline and show what would run without executing')
         .option('--verbose', 'Stream container logs in real-time (interactive mode)')
+        .option('-t, --target <steps>', 'Execute only these steps and their dependencies (comma-separated)')
+        .option('-c, --concurrency <number>', 'Max parallel step executions (default: CPU count)', Number)
+        .option('--env-file <path>', 'Load environment variables from a dotenv file for all steps')
         .action(async (pipelineFile, options, cmd) => {
         const { workdir, json } = getGlobalOptions(cmd);
         const workdirRoot = resolve(workdir);
@@ -24,7 +28,8 @@ export function registerRunCommand(program) {
             const force = options.force === true
                 ? true
                 : (typeof options.force === 'string' ? options.force.split(',') : undefined);
-            await runner.run(pipelineFile, { workspace: options.workspace, force, dryRun: options.dryRun });
+            const target = options.target ? options.target.split(',') : undefined;
+            await runner.run(pipelineFile, { workspace: options.workspace, force, dryRun: options.dryRun, target, concurrency: options.concurrency, envFile: options.envFile });
             if (json) {
                 console.log('Pipeline completed');
             }

package/dist/cli/commands/show.js

@@ -1,9 +1,20 @@
+import process from 'node:process';
 import { readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import chalk from 'chalk';
 import { Workspace } from '../../engine/workspace.js';
-import { StateManager } from '../state.js';
-import { dirSize, formatSize, getGlobalOptions } from '../utils.js';
+import { StateManager } from '../../core/state.js';
+import { dirSize, formatDuration, formatSize } from '../../core/utils.js';
+import { getGlobalOptions } from '../utils.js';
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function registerShowCommand(program) {
     program
         .command('show')
@@ -16,10 +27,7 @@ export function registerShowCommand(program) {
         const state = new StateManager(workspace.root);
         await state.load();
         const steps = state.listSteps();
-        if (steps.length === 0) {
-            console.log(chalk.gray('No runs found in this workspace.'));
-            return;
-        }
+        const runningSteps = await workspace.listRunningSteps();
         const rows = [];
         let totalSize = 0;
         for (const { stepId, runId } of steps) {
@@ -43,6 +51,30 @@ export function registerShowCommand(program) {
                 rows.push({ stepId, status: 'unknown', duration: '-', size: '-', date: '-', runId });
             }
         }
+        // Add running steps (not already in committed state)
+        const committedStepIds = new Set(rows.map(r => r.stepId));
+        for (const running of runningSteps) {
+            if (committedStepIds.has(running.stepId)) {
+                continue;
+            }
+            if (!isProcessAlive(running.pid)) {
+                continue;
+            }
+            const elapsedMs = Date.now() - new Date(running.startedAt).getTime();
+            rows.push({
+                stepId: running.stepId,
+                stepName: running.stepName,
+                status: 'running',
+                duration: formatDuration(elapsedMs),
+                size: '-',
+                date: '-',
+                runId: '-'
+            });
+        }
+        if (rows.length === 0) {
+            console.log(chalk.gray('No runs found in this workspace.'));
+            return;
+        }
         if (json) {
             console.log(JSON.stringify(rows, null, 2));
             return;
@@ -55,7 +87,10 @@ export function registerShowCommand(program) {
         console.log(chalk.bold(`${'STEP'.padEnd(stepWidth)}  ${'STATUS'.padEnd(statusWidth)}  ${'DURATION'.padStart(durationWidth)}  ${'SIZE'.padStart(sizeWidth)}  ${'FINISHED'.padEnd(dateWidth)}`));
         for (const row of rows) {
             const stepLabel = row.stepName ? `${row.stepId} (${row.stepName})` : row.stepId;
-            const statusText = row.status === 'success' ? chalk.green(row.status) : chalk.red(row.status);
+            const statusColor = row.status === 'success'
+                ? chalk.green
+                : (row.status === 'running' ? chalk.yellow : chalk.red);
+            const statusText = statusColor(row.status);
             const statusPad = statusWidth + (statusText.length - row.status.length);
             const cols = [
                 stepLabel.padEnd(stepWidth),

package/dist/cli/condition.js

@@ -0,0 +1,11 @@
+import jexlModule from 'jexl';
+const jexl = new jexlModule.Jexl();
+export async function evaluateCondition(expression, context) {
+    try {
+        const result = await jexl.eval(expression, context);
+        return Boolean(result);
+    }
+    catch {
+        return false;
+    }
+}