@omnitron-dev/omnitron 0.3.0 → 0.3.2

package/dist/services/pipeline.service.js

@@ -1,392 +1,461 @@
-/**
- * PipelineService — CI/CD Pipeline execution via @xec-sh/ops Pipeline
- *
- * Manages DAG-based pipeline definitions and their execution runs.
- * Pipeline definitions and run history are persisted in omnitron-pg.
- *
- * Uses dynamic import for @xec-sh/ops. Falls back to basic sequential
- * shell execution when the package is not installed.
- */
-import { randomUUID } from 'node:crypto';
-// =============================================================================
-// @xec-sh/ops Pipeline — loaded dynamically
-// =============================================================================
-import { loadXecOps } from '../shared/xec-loader.js';
-// =============================================================================
-// Service
-// =============================================================================
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { RecoveryMutation } from '../daemon/recovery-state.js';
+/** Durable control-plane state over Xec's execution, graph and cancellation contracts. */
+import { randomUUID, createHash } from 'node:crypto';
+import { redactDiagnosticText } from '@omnitron-dev/titan/diagnostics';
+import { sshConfig } from '../execution/execution.service.js';
+import { PIPELINE_LIMITS, pipelineCondition, stepEnvironment, validatePipeline, validatePipelineParams, } from './pipeline-definition.js';
+const live = ['pending', 'running', 'cancelling'];
+const secretKey = /password|passphrase|secret|token|credential|private.?key|api.?key/i;
+/** Incomplete known secrets are withheld across stream chunk boundaries. */
+export class PipelineOutput {
+    secrets;
+    text = '';
+    privateKeyOpen = false;
+    privateKeyTail = '';
+    received = false;
+    truncated = false;
+    constructor(secrets) {
+        this.secrets = secrets;
+    }
+    append(text) {
+        this.received = true;
+        if (this.privateKeyOpen) {
+            const pending = this.privateKeyTail + text;
+            const end = /-----END [^-]*PRIVATE KEY-----/.exec(pending);
+            if (!end) {
+                this.privateKeyTail = pending.slice(-100);
+                return;
+            }
+            this.privateKeyOpen = false;
+            this.privateKeyTail = '';
+            text = pending.slice(end.index + end[0].length);
+        }
+        this.text += text;
+        this.text = this.text.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, (key) => {
+            if (!/-----END [^-]*PRIVATE KEY-----$/.test(key)) {
+                this.privateKeyOpen = true;
+                this.privateKeyTail = key.slice(-100);
+            }
+            return '[redacted private key]';
+        });
+        for (const secret of this.secrets)
+            this.text = this.text.split(secret).join('***');
+        const bound = PIPELINE_LIMITS.outputBytes + Math.max(0, ...this.secrets.map((value) => Buffer.byteLength(value)));
+        if (Buffer.byteLength(this.text) > bound) {
+            this.text = Buffer.from(this.text)
+                .subarray(-bound)
+                .toString('utf8')
+                .replace(/^\uFFFD/, '');
+            this.truncated = true;
+        }
+    }
+    snapshot(final = false) {
+        let value = this.text;
+        for (const secret of this.secrets)
+            value = value.split(secret).join('***');
+        value = value.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, '[redacted private key]');
+        if (!final) {
+            const hold = Math.max(0, ...this.secrets.map((secret) => secret.length - 1));
+            value = value.slice(0, Math.max(0, value.length - hold));
+            value = value.slice(0, value.lastIndexOf('\n') + 1);
+        }
+        const lines = value.split('\n');
+        if (lines.some((line) => line.length > 2048))
+            this.truncated = true;
+        const encoded = Buffer.from(lines.map((line) => redactDiagnosticText(line)).join('\n'));
+        if (encoded.length > PIPELINE_LIMITS.outputBytes)
+            this.truncated = true;
+        return encoded
+            .subarray(-PIPELINE_LIMITS.outputBytes)
+            .toString('utf8')
+            .replace(/^\uFFFD/, '');
+    }
+}
 export class PipelineService {
     db;
     logger;
+    activeRunCount() { return this.activeRuns.size; }
     activeRuns = new Map();
+    initialization;
+    stopped = false;
+    nodes;
+    observe;
     constructor(db, logger) {
         this.db = db;
         this.logger = logger;
     }
-    // ===========================================================================
-    // Pipeline CRUD
-    // ===========================================================================
+    configure(nodes, observe) {
+        this.nodes = nodes;
+        this.observe = observe;
+    }
+    async initialize() {
+        this.initialization ??= this.db
+            .updateTable('pipeline_runs')
+            .set({ status: 'interrupted', completedAt: new Date() })
+            .where('status', 'in', live)
+            .execute()
+            .then(() => undefined);
+        return this.initialization;
+    }
+    async dispose() {
+        this.stopped = true;
+        for (const run of this.activeRuns.values())
+            run.abort.abort(new Error('Daemon is stopping'));
+        while (this.activeRuns.size)
+            await Promise.allSettled([...this.activeRuns.values()].map((run) => run.done));
+    }
+    async validate(def) {
+        validatePipeline(def);
+        const { Pipeline: XecPipeline } = await import('@xec-sh/ops');
+        const graph = XecPipeline.create(def.name);
+        for (const step of def.steps)
+            graph.step(step.name, { run: step.run, ...(step.dependsOn ? { dependsOn: step.dependsOn } : {}) });
+        graph.validate();
+    }
     async createPipeline(def) {
-        const now = new Date();
+        await this.validate(def);
         const row = await this.db
             .insertInto('pipelines')
             .values({
             id: randomUUID(),
-            name: def.name,
+            name: def.name.trim(),
             description: def.description ?? null,
             steps: JSON.stringify(def.steps),
             triggers: JSON.stringify(def.triggers ?? []),
-            createdAt: now,
-            updatedAt: now,
+            createdAt: new Date(),
+            updatedAt: new Date(),
         })
             .returningAll()
             .executeTakeFirstOrThrow();
-        this.logger.info({ id: row.id, name: def.name }, 'Pipeline created');
         return this.mapPipeline(row);
     }
+    async updatePipeline(id, def, expectedRevision) {
+        if (!/^[a-f0-9]{64}$/.test(expectedRevision ?? ''))
+            throw new Error('Review the current definition before updating it');
+        await this.validate(def);
+        return this.db.transaction().execute(async (trx) => {
+            const current = await trx.selectFrom('pipelines').selectAll().where('id', '=', id)
+                .forUpdate().executeTakeFirst();
+            if (!current)
+                throw new Error(`Pipeline '${id}' not found`);
+            if (this.mapPipeline(current).revision !== expectedRevision)
+                throw new Error('Pipeline changed after review. Reload and review the current definition');
+            const row = await trx.updateTable('pipelines').set({
+                name: def.name.trim(),
+                description: def.description ?? null,
+                steps: JSON.stringify(def.steps),
+                triggers: JSON.stringify(def.triggers ?? []),
+                updatedAt: new Date(Math.max(Date.now(), new Date(current.updatedAt).getTime() + 1)),
+            }).where('id', '=', id).returningAll().executeTakeFirstOrThrow();
+            return this.mapPipeline(row);
+        });
+    }
     async getPipeline(id) {
-        const row = await this.db
-            .selectFrom('pipelines')
-            .selectAll()
-            .where('id', '=', id)
-            .executeTakeFirst();
+        const row = await this.db.selectFrom('pipelines').selectAll().where('id', '=', id).executeTakeFirst();
         return row ? this.mapPipeline(row) : null;
     }
     async listPipelines() {
-        const rows = await this.db
-            .selectFrom('pipelines')
-            .selectAll()
-            .orderBy('createdAt', 'desc')
-            .execute();
-        return rows.map((r) => this.mapPipeline(r));
+        return (await this.db.selectFrom('pipelines').selectAll().orderBy('createdAt', 'desc').execute()).map((row) => this.mapPipeline(row));
     }
     async deletePipeline(id) {
-        await this.db.deleteFrom('pipeline_runs').where('pipelineId', '=', id).execute();
-        await this.db.deleteFrom('pipelines').where('id', '=', id).execute();
-        this.logger.info({ id }, 'Pipeline deleted');
+        if ([...this.activeRuns.values()].some((run) => run.pipelineId === id))
+            throw new Error('Stop active runs before deleting a pipeline');
+        await this.db.transaction().execute(async (trx) => {
+            await trx.deleteFrom('pipeline_runs').where('pipelineId', '=', id).execute();
+            await trx.deleteFrom('pipelines').where('id', '=', id).execute();
+        });
     }
-    // ===========================================================================
-    // Execution
-    // ===========================================================================
-    async executePipeline(id, params, triggeredBy = 'manual') {
-        const pipeline = await this.getPipeline(id);
-        if (!pipeline)
-            throw new Error(`Pipeline '${id}' not found`);
+    async executePipeline(id, params = {}, triggeredBy = 'system', expectedRevision) {
+        await this.initialize();
+        if (this.stopped)
+            throw new Error('Pipeline executor is stopping');
+        if (this.activeRuns.size >= PIPELINE_LIMITS.activeRuns)
+            throw new Error('Pipeline execution capacity reached');
+        validatePipelineParams(params);
         const runId = randomUUID();
-        const now = new Date();
-        // Insert pending run
-        await this.db
-            .insertInto('pipeline_runs')
-            .values({
-            id: runId,
-            pipelineId: id,
-            status: 'running',
-            steps: JSON.stringify([]),
-            startedAt: now,
-            completedAt: null,
-            triggeredBy,
-            params: params ? JSON.stringify(params) : null,
-        })
-            .execute();
-        this.logger.info({ runId, pipelineId: id, triggeredBy }, 'Pipeline execution started');
-        // Execute asynchronously
-        const abortController = new AbortController();
-        this.activeRuns.set(runId, { cancel: () => abortController.abort() });
-        this.executeSteps(runId, pipeline.steps, params, abortController.signal).catch((err) => {
-            this.logger.error({ runId, error: err.message }, 'Pipeline execution error');
+        const abort = new AbortController();
+        let finishAdmission;
+        const admission = new Promise((resolve) => {
+            finishAdmission = resolve;
         });
-        return this.getRunStatus(runId);
-    }
-    async cancelRun(runId) {
-        const handle = this.activeRuns.get(runId);
-        if (handle) {
-            handle.cancel();
-            this.activeRuns.delete(runId);
-        }
-        await this.db
-            .updateTable('pipeline_runs')
-            .set({ status: 'cancelled', completedAt: new Date() })
-            .where('id', '=', runId)
-            .execute();
-        this.logger.info({ runId }, 'Pipeline run cancelled');
-    }
-    async getRunStatus(runId) {
-        const row = await this.db
-            .selectFrom('pipeline_runs')
-            .selectAll()
-            .where('id', '=', runId)
-            .executeTakeFirst();
-        return row ? this.mapRun(row) : null;
-    }
-    async listRuns(pipelineId, limit = 50) {
-        let query = this.db
-            .selectFrom('pipeline_runs')
-            .selectAll()
-            .orderBy('startedAt', 'desc')
-            .limit(limit);
-        if (pipelineId) {
-            query = query.where('pipelineId', '=', pipelineId);
-        }
-        const rows = await query.execute();
-        return rows.map((r) => this.mapRun(r));
-    }
-    // ===========================================================================
-    // Private — Step execution
-    // ===========================================================================
-    async executeSteps(runId, steps, params, signal) {
-        const xec = await loadXecOps();
-        const stepResults = [];
-        let overallStatus = 'success';
-        // Build dependency graph — execute steps whose dependencies are met
-        const completed = new Set();
-        const remaining = [...steps];
-        while (remaining.length > 0) {
-            if (signal.aborted) {
-                overallStatus = 'failed';
-                break;
-            }
-            // Find steps whose dependencies are all completed
-            const ready = remaining.filter((s) => !s.dependsOn?.length || s.dependsOn.every((dep) => completed.has(dep)));
-            if (ready.length === 0) {
-                // Circular dependency or unresolvable — fail remaining
-                for (const s of remaining) {
-                    stepResults.push({ name: s.name, status: 'skipped', duration: 0, error: 'Unresolvable dependency' });
-                }
-                overallStatus = 'failed';
-                break;
-            }
-            // Execute ready steps in parallel
-            const results = await Promise.allSettled(ready.map((step) => this.executeStep(step, params, xec, signal)));
-            for (let i = 0; i < ready.length; i++) {
-                const step = ready[i];
-                const result = results[i];
-                if (result.status === 'fulfilled') {
-                    stepResults.push(result.value);
-                    if (result.value.status === 'failed')
-                        overallStatus = 'failed';
+        const handle = { pipelineId: id, abort, done: admission };
+        this.activeRuns.set(runId, handle);
+        const prepared = [];
+        try {
+            const definition = await this.getPipeline(id);
+            if (!definition)
+                throw new Error(`Pipeline '${id}' not found`);
+            if (expectedRevision !== undefined && expectedRevision !== definition.revision)
+                throw new Error('Pipeline changed after review. Reload and review the current definition');
+            await this.validate({ ...definition, description: definition.description ?? '' });
+            const { Pipeline: XecPipeline, prepareScript } = await import('@xec-sh/ops');
+            const graph = XecPipeline.create(definition.name);
+            for (const step of definition.steps) {
+                abort.signal.throwIfAborted();
+                const env = stepEnvironment(step, params);
+                let target;
+                if (step.nodeId && step.nodeId !== 'local') {
+                    const node = this.nodes?.getNode(step.nodeId);
+                    if (!node || node.isLocal)
+                        throw new Error(`Unknown remote node: ${step.nodeId}`);
+                    const ssh = await this.nodes.nodeToSshTarget(node);
+                    target = { type: 'ssh', ...sshConfig(ssh) };
                 }
-                else {
-                    stepResults.push({
-                        name: step.name,
-                        status: 'failed',
-                        duration: 0,
-                        error: result.reason?.message ?? 'Unknown error',
+                let command;
+                if (step.kind === 'xec') {
+                    const script = await prepareScript(step.run, {
+                        ...(step.cwd ? { cwd: step.cwd } : {}),
+                        env,
+                        params,
+                        ...(target ? { target } : {}),
                     });
-                    overallStatus = 'failed';
+                    prepared.push(script);
+                    command = script.command;
                 }
-                completed.add(step.name);
-                remaining.splice(remaining.indexOf(step), 1);
+                else
+                    command = {
+                        command: step.run,
+                        shell: true,
+                        ...(step.cwd ? { cwd: step.cwd } : {}),
+                        env,
+                        ...(target ? { adapter: 'ssh', adapterOptions: target } : {}),
+                    };
+                graph.step(step.name, {
+                    run: command,
+                    ...(step.dependsOn ? { dependsOn: step.dependsOn } : {}),
+                    timeout: step.timeout ?? 300_000,
+                    retry: { maxAttempts: (step.retries ?? 0) + 1 },
+                    ...(step.condition ? { condition: () => pipelineCondition(step.condition, params) } : {}),
+                });
             }
-            // Update run in DB with current progress
+            abort.signal.throwIfAborted();
+            const startedAt = new Date().toISOString();
+            const steps = definition.steps.map((step) => ({
+                name: step.name,
+                status: 'pending',
+                duration: 0,
+                kind: step.kind ?? 'shell',
+                nodeId: step.nodeId ?? 'local',
+                sourceHash: createHash('sha256').update(JSON.stringify(step)).digest('hex'),
+            }));
+            const run = {
+                id: runId,
+                pipelineId: id,
+                status: 'running',
+                steps,
+                startedAt,
+                completedAt: null,
+                triggeredBy,
+                params: Object.fromEntries(Object.keys(params).map((key) => [key, '[provided]'])),
+            };
             await this.db
-                .updateTable('pipeline_runs')
-                .set({ steps: JSON.stringify(stepResults) })
-                .where('id', '=', runId)
+                .insertInto('pipeline_runs')
+                .values({
+                ...run,
+                startedAt: new Date(startedAt),
+                steps: JSON.stringify(steps),
+                params: JSON.stringify(run.params),
+            })
                 .execute();
-            // If any step failed and we don't have a condition, stop
-            if (overallStatus === 'failed') {
-                // Mark remaining as skipped
-                for (const s of remaining) {
-                    stepResults.push({ name: s.name, status: 'skipped', duration: 0 });
-                }
-                break;
+            const secrets = [
+                ...new Set([
+                    ...Object.values(params).filter((value) => typeof value === 'string' && value.length > 0),
+                    ...Object.entries({ ...process.env, ...Object.assign({}, ...definition.steps.map((step) => step.env)) })
+                        .filter(([key, value]) => secretKey.test(key) && typeof value === 'string' && value.length > 0)
+                        .map(([, value]) => value),
+                ]),
+            ].sort((a, b) => b.length - a.length);
+            handle.done = this.executeRun(run, graph, abort.signal, secrets, prepared).finally(() => this.activeRuns.delete(runId));
+            finishAdmission();
+            void handle.done.catch((error) => this.logger.error({ runId, error: redactDiagnosticText(String(error)) }, 'Pipeline journal failed'));
+            return structuredClone(run);
+        }
+        catch (error) {
+            this.activeRuns.delete(runId);
+            try {
+                await Promise.all(prepared.map((script) => script.dispose()));
+            }
+            finally {
+                finishAdmission();
             }
+            throw error;
         }
-        // Finalize run
-        await this.db
-            .updateTable('pipeline_runs')
-            .set({
-            status: overallStatus,
-            steps: JSON.stringify(stepResults),
-            completedAt: new Date(),
-        })
-            .where('id', '=', runId)
-            .execute();
-        this.activeRuns.delete(runId);
-        this.logger.info({ runId, status: overallStatus }, 'Pipeline execution completed');
     }
-    async executeStep(step, params, _xec, signal) {
-        const start = Date.now();
-        // Evaluate step condition before running — skip if condition is false
-        if (step.condition) {
-            const conditionMet = this.evaluateCondition(step.condition, params ?? {});
-            if (!conditionMet) {
-                this.logger.debug({ step: step.name, condition: step.condition }, 'Step skipped — condition not met');
-                return { name: step.name, status: 'skipped', duration: 0 };
+    async executeRun(run, graph, signal, secrets, prepared) {
+        const safeError = (error) => {
+            const text = new PipelineOutput(secrets);
+            text.append(String(error));
+            return text.snapshot(true);
+        };
+        const output = new Map(run.steps.map((step) => [step.name, { stdout: new PipelineOutput(secrets), stderr: new PipelineOutput(secrets) }]));
+        let lastWrite = 0;
+        let writes = Promise.resolve();
+        const save = () => {
+            const snapshot = JSON.stringify(run.steps);
+            writes = writes
+                .then(() => this.db.updateTable('pipeline_runs').set({ steps: snapshot }).where('id', '=', run.id).execute())
+                .then(() => undefined);
+            return writes;
+        };
+        const onEvent = async (event) => {
+            const step = run.steps.find((item) => item.name === event.step);
+            const journal = output.get(event.step);
+            if (event.type === 'step-start') {
+                step.status = 'running';
+                step.startedAt ??= new Date(event.at).toISOString();
+                step.attempts = event.attempt;
+            }
+            else if (event.type === 'step-output') {
+                journal[event.stream].append(event.text);
+                if (Date.now() - lastWrite < 250)
+                    return;
+                lastWrite = Date.now();
+                step.output = journal.stdout.snapshot();
+                step.stderr = journal.stderr.snapshot();
             }
+            else {
+                const result = event.result;
+                if (!journal.stdout.received && result.stdout)
+                    journal.stdout.append(result.stdout);
+                if (!journal.stderr.received && result.stderr)
+                    journal.stderr.append(result.stderr);
+                step.status = result.cancelled
+                    ? 'cancelled'
+                    : result.skipped
+                        ? 'skipped'
+                        : result.success
+                            ? 'success'
+                            : 'failed';
+                step.completedAt = new Date(event.at).toISOString();
+                step.duration = result.duration;
+                step.exitCode = result.exitCode;
+                if (result.error) {
+                    const failure = new PipelineOutput(secrets);
+                    failure.append(result.error);
+                    step.error = failure.snapshot(true);
+                }
+                step.output = journal.stdout.snapshot(true);
+                step.stderr = journal.stderr.snapshot(true);
+                step.outputTruncated = journal.stdout.truncated || journal.stderr.truncated || result.outputTruncated === true;
+            }
+            await save();
+        };
+        try {
+            const result = await graph.run({}, { signal, concurrency: PIPELINE_LIMITS.concurrency, outputLimit: PIPELINE_LIMITS.outputBytes, onEvent });
+            run.status = result.status;
         }
-        const timeout = step.timeout ?? 300_000; // 5 min default
-        const maxRetries = step.retries ?? 0;
-        // Interpolate {{param}} placeholders in the command and env values
-        const command = this.interpolateParams(step.run, params ?? {});
-        const env = step.env
-            ? Object.fromEntries(Object.entries(step.env).map(([k, v]) => [k, this.interpolateParams(v, params ?? {})]))
-            : undefined;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        catch (error) {
+            run.status = signal.aborted ? 'cancelled' : 'failed';
+            this.logger.error({ runId: run.id, error: safeError(error) }, 'Pipeline execution failed');
+            for (const step of run.steps)
+                if (step.status === 'pending' || step.status === 'running') {
+                    step.status = run.status;
+                    step.error = safeError(error);
+                }
+        }
+        finally {
             try {
-                const output = await this.runShellCommand(command, env, timeout, signal);
-                return {
-                    name: step.name,
-                    status: 'success',
-                    duration: Date.now() - start,
-                    output: output.slice(0, 10_000), // Limit stored output
-                };
+                await Promise.all(prepared.map((script) => script.dispose()));
             }
-            catch (err) {
-                if (attempt === maxRetries || signal.aborted) {
-                    return {
-                        name: step.name,
-                        status: 'failed',
-                        duration: Date.now() - start,
-                        error: err.message,
-                    };
-                }
-                this.logger.warn({ step: step.name, attempt, maxRetries }, 'Step failed, retrying');
+            catch (error) {
+                run.status = 'failed';
+                this.logger.error({ runId: run.id, error: safeError(error) }, 'Pipeline temporary script cleanup failed');
             }
+            await writes.catch(() => undefined);
+            run.completedAt = new Date().toISOString();
+            await this.db
+                .updateTable('pipeline_runs')
+                .set({ status: run.status, steps: JSON.stringify(run.steps), completedAt: new Date(run.completedAt) })
+                .where('id', '=', run.id)
+                .execute();
+            const duration = Date.parse(run.completedAt) - Date.parse(run.startedAt);
+            this.observe?.(run.status, duration);
+            this.logger.info({ runId: run.id, pipelineId: run.pipelineId, status: run.status, duration }, 'Pipeline execution completed');
         }
-        // Should not reach here
-        return { name: step.name, status: 'failed', duration: Date.now() - start, error: 'Exhausted retries' };
     }
-    /**
-     * Substitute {{paramName}} placeholders in a string with values from params.
-     * Unknown placeholders are left as-is so they surface clearly in output.
-     */
-    interpolateParams(template, params) {
-        return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-            const val = params[key];
-            if (val === undefined || val === null)
-                return match;
-            return String(val);
-        });
+    async cancelRun(runId) {
+        const handle = this.activeRuns.get(runId);
+        if (!handle) {
+            const run = await this.getRunStatus(runId);
+            if (!run)
+                throw new Error(`Run '${runId}' not found`);
+            if (live.includes(run.status))
+                throw new Error('Executor is unavailable; reconcile the daemon before retrying');
+            return;
+        }
+        await this.db
+            .updateTable('pipeline_runs')
+            .set({ status: 'cancelling' })
+            .where('id', '=', runId)
+            .where('status', 'in', live)
+            .execute();
+        handle.abort.abort(new Error('Cancelled by operator'));
+        await handle.done;
     }
-    /**
-     * Evaluate a simple step condition expression against pipeline params.
-     *
-     * Supported forms:
-     *   params.key == 'value'   → string equality
-     *   params.key != 'value'   → string inequality
-     *   params.key              → truthy check
-     *   !params.key             → falsy check
-     */
-    evaluateCondition(condition, params) {
-        const eqMatch = condition.match(/^params\.(\w+)\s*==\s*['"]([^'"]*)['"]\s*$/);
-        if (eqMatch)
-            return String(params[eqMatch[1]] ?? '') === eqMatch[2];
-        const neqMatch = condition.match(/^params\.(\w+)\s*!=\s*['"]([^'"]*)['"]\s*$/);
-        if (neqMatch)
-            return String(params[neqMatch[1]] ?? '') !== neqMatch[2];
-        const notMatch = condition.match(/^!\s*params\.(\w+)\s*$/);
-        if (notMatch)
-            return !params[notMatch[1]];
-        const keyMatch = condition.match(/^params\.(\w+)\s*$/);
-        if (keyMatch)
-            return Boolean(params[keyMatch[1]]);
-        // Unknown syntax — log and allow step to run (fail-open for forward compatibility)
-        this.logger.warn({ condition }, 'Pipeline: unrecognized condition syntax — step will run');
-        return true;
+    async getRunStatus(runId) {
+        const row = await this.db.selectFrom('pipeline_runs').selectAll().where('id', '=', runId).executeTakeFirst();
+        return row ? this.mapRun(row) : null;
     }
-    /** @internal exported for tests via `__test__` below. */
-    async runShellCommand(command, env, timeout = 300_000, signal) {
-        const { spawn } = await import('node:child_process');
-        const shell = process.platform === 'win32' ? 'cmd' : '/bin/sh';
-        const shellArgs = process.platform === 'win32' ? ['/c', command] : ['-c', command];
-        // Streamed rather than buffered.
-        //
-        // `execFile` with `maxBuffer: 10MB` failed the STEP when a command that
-        // exited 0 simply printed more than that — "stdout maxBuffer length
-        // exceeded", reported as a failed build. A verbose build is not a broken
-        // build, and a pipeline that says otherwise sends someone looking for a
-        // fault that is not there.
-        //
-        // Output is capped for RETENTION instead: the head is kept, because the
-        // start of a build log is where the useful part is, and the caller
-        // truncates further before storing.
-        const RETAIN_BYTES = 1024 * 1024;
-        return await new Promise((resolve, reject) => {
-            const child = spawn(shell, shellArgs, {
-                env: { ...process.env, ...env },
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let stderr = '';
-            let truncated = false;
-            child.stdout.on('data', (chunk) => {
-                if (stdout.length < RETAIN_BYTES)
-                    stdout += String(chunk);
-                else
-                    truncated = true;
-            });
-            // stderr is kept too: a step used to discard it on success, so warnings
-            // a build printed were lost, and on failure only the truncated copy
-            // inside the Error message survived.
-            child.stderr.on('data', (chunk) => {
-                if (stderr.length < RETAIN_BYTES)
-                    stderr += String(chunk);
-            });
-            const timer = setTimeout(() => {
-                child.kill('SIGKILL');
-                reject(new Error(`Step timed out after ${timeout}ms`));
-            }, timeout);
-            const onAbort = () => {
-                child.kill('SIGKILL');
-                reject(new Error('Step aborted'));
-            };
-            signal?.addEventListener('abort', onAbort, { once: true });
-            const finish = () => {
-                clearTimeout(timer);
-                signal?.removeEventListener('abort', onAbort);
-            };
-            child.once('error', (err) => {
-                finish();
-                reject(err);
-            });
-            child.once('close', (code) => {
-                finish();
-                if (code === 0) {
-                    resolve(stdout + (truncated ? '\n… output truncated …' : '') + (stderr ? `\n${stderr}` : ''));
-                }
-                else {
-                    reject(new Error(`Command exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`));
-                }
-            });
-        });
+    async listRuns(pipelineId, limit = 50) {
+        if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+            throw new Error('Run limit must be between 1 and 200');
+        let query = this.db
+            .selectFrom('pipeline_runs')
+            .select(['id', 'pipelineId', 'status', 'startedAt', 'completedAt', 'triggeredBy'])
+            .orderBy('startedAt', 'desc')
+            .limit(limit);
+        if (pipelineId)
+            query = query.where('pipelineId', '=', pipelineId);
+        return (await query.execute()).map((row) => ({
+            ...row,
+            status: row.status,
+            startedAt: new Date(row.startedAt).toISOString(),
+            completedAt: row.completedAt ? new Date(row.completedAt).toISOString() : null,
+        }));
     }
-    // ===========================================================================
-    // Mappers
-    // ===========================================================================
     mapPipeline(row) {
-        return {
-            id: row.id,
-            name: row.name,
-            description: row.description ?? null,
-            steps: typeof row.steps === 'string' ? JSON.parse(row.steps) : row.steps ?? [],
-            triggers: typeof row.triggers === 'string' ? JSON.parse(row.triggers) : row.triggers ?? [],
-            createdAt: row.createdAt instanceof Date ? row.createdAt.toISOString() : String(row.createdAt),
-            updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : String(row.updatedAt),
+        const definition = {
+            ...row,
+            steps: (typeof row.steps === 'string' ? JSON.parse(row.steps) : row.steps),
+            triggers: (typeof row.triggers === 'string'
+                ? JSON.parse(row.triggers)
+                : row.triggers),
+            createdAt: new Date(row.createdAt).toISOString(),
+            updatedAt: new Date(row.updatedAt).toISOString(),
         };
+        return { ...definition, revision: createHash('sha256').update(JSON.stringify(definition)).digest('hex'), conditionalUpdates: true };
     }
     mapRun(row) {
+        const steps = (typeof row.steps === 'string'
+            ? JSON.parse(row.steps)
+            : row.steps);
+        if (row.status === 'interrupted')
+            for (const step of steps)
+                if (live.includes(step.status))
+                    step.status = 'interrupted';
         return {
-            id: row.id,
-            pipelineId: row.pipelineId,
+            ...row,
             status: row.status,
-            steps: typeof row.steps === 'string' ? JSON.parse(row.steps) : row.steps ?? [],
-            startedAt: row.startedAt instanceof Date ? row.startedAt.toISOString() : String(row.startedAt),
-            completedAt: row.completedAt ? (row.completedAt instanceof Date ? row.completedAt.toISOString() : String(row.completedAt)) : null,
-            triggeredBy: row.triggeredBy ?? 'unknown',
-            params: typeof row.params === 'string' ? JSON.parse(row.params) : row.params ?? null,
+            steps,
+            params: typeof row.params === 'string' ? JSON.parse(row.params) : row.params,
+            startedAt: new Date(row.startedAt).toISOString(),
+            completedAt: row.completedAt ? new Date(row.completedAt).toISOString() : null,
         };
     }
 }
-/**
- * Exported for tests only.
- *
- * `runShellCommand` is the piece with behaviour worth pinning — exit codes,
- * timeouts, output retention — and the shapes that matter (a command that
- * succeeds while printing megabytes) are awkward to reach through the full
- * service, which wants a database and a scheduler.
- */
-export const __test__ = {
-    runShellCommand: (service, command, env, timeout, signal) => service.runShellCommand(command, env, timeout, signal),
-};
+__decorate([
+    RecoveryMutation(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, String]),
+    __metadata("design:returntype", Promise)
+], PipelineService.prototype, "executePipeline", null);
 //# sourceMappingURL=pipeline.service.js.map