@cloud-cli/on 1.2.2 → 1.2.4

package/dist/reporters/json-file.reporter.js

@@ -1,16 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-export class JsonFileReporter {
-    name = 'json-file-reporter';
-    outputDir;
-    constructor(options) {
-        this.outputDir = options.outputDir;
-    }
-    async report(execReport) {
-        fs.mkdirSync(this.outputDir, { recursive: true });
-        const filePath = path.join(this.outputDir, `run-${execReport.jobId}.json`);
-        // Save pretty-printed execution report
-        fs.writeFileSync(filePath, JSON.stringify(execReport, null, 2), 'utf-8');
-        console.log(`📊 Execution report saved to: ${filePath}`);
-    }
-}

package/dist/reporters/slack.reporter.js

@@ -1,25 +0,0 @@
-export class SlackReporter {
-    name = 'slack-reporter';
-    token;
-    channel;
-    notifyOn;
-    constructor(options) {
-        this.token = options.token;
-        this.channel = options.channel;
-        this.notifyOn = options.notifyOn || ['failed']; // Default: notify on failure only
-    }
-    async report(execReport) {
-        if (!this.notifyOn.includes(execReport.status))
-            return;
-        const emoji = execReport.status === 'success' ? '✅' : '❌';
-        const text = `${emoji} *Workflow ${execReport.workflowName} (#${execReport.jobId})* finished with status: *${execReport.status.toUpperCase()}* (${execReport.durationMs}ms)`;
-        await fetch('https://slack.com/api/chat.postMessage', {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this.token}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ channel: this.channel, text })
-        });
-    }
-}

package/dist/reporters/types.js

@@ -1 +0,0 @@
-export {};

package/dist/runner/step-runner.js

@@ -1,42 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { parseEnv } from 'node:util';
-export async function executeStepAndCollectState(stepCtx, driver, currentWorkflowEnv) {
-    // 1. Create temporary state files for this step
-    const envFilePath = path.join(stepCtx.workspacePath, `.step-${stepCtx.stepId}.env`);
-    const outputFilePath = path.join(stepCtx.workspacePath, `.step-${stepCtx.stepId}.out`);
-    fs.writeFileSync(envFilePath, '');
-    fs.writeFileSync(outputFilePath, '');
-    let newEnv = {};
-    let outputs = {};
-    try {
-        // 2. Inject environment file paths into step execution context
-        const stepEnv = {
-            ...currentWorkflowEnv,
-            ...stepCtx.env,
-            WORKFLOW_ENV: envFilePath,
-            WORKFLOW_OUTPUT: outputFilePath,
-        };
-        // 3. Execute step
-        const handle = await driver.execute({ ...stepCtx, env: stepEnv });
-        const result = await handle.done;
-        // 4. Parse step-exported environment variables using Node's built-in parseEnv
-        if (fs.existsSync(envFilePath)) {
-            newEnv = parseEnv(fs.readFileSync(envFilePath, 'utf-8'));
-        }
-        if (fs.existsSync(outputFilePath)) {
-            outputs = parseEnv(fs.readFileSync(outputFilePath, 'utf-8'));
-        }
-        if (result.exitCode !== 0) {
-            return { result, newEnv: {}, outputs: {} };
-        }
-        return { result, newEnv, outputs };
-    }
-    finally {
-        // ALWAYS cleans up temp state files, regardless of success or failure
-        if (fs.existsSync(envFilePath))
-            fs.unlinkSync(envFilePath);
-        if (fs.existsSync(outputFilePath))
-            fs.unlinkSync(outputFilePath);
-    }
-}

package/dist/secrets/store.js

@@ -1,40 +0,0 @@
-import dotenv from 'dotenv';
-import fs from 'node:fs';
-export class SecretStore {
-    envFilePath;
-    secrets = new Map();
-    /**
-     * Initialize secrets from host environment or a specified .env file
-     */
-    constructor(envFilePath) {
-        this.envFilePath = envFilePath;
-    }
-    reload() {
-        // 1. Load host process.env variables prefixed with SECRET_
-        for (const [key, val] of Object.entries(process.env)) {
-            if (key.startsWith('SECRET_') && val) {
-                // Strip prefix: SECRET_SLACK_TOKEN -> SLACK_TOKEN
-                this.secrets.set(key.replace('SECRET_', ''), val);
-            }
-        }
-        // 2. Override/add from .env file if present
-        if (this.envFilePath && fs.existsSync(this.envFilePath)) {
-            const parsed = dotenv.parse(fs.readFileSync(this.envFilePath));
-            for (const [key, val] of Object.entries(parsed)) {
-                this.secrets.set(key, val);
-            }
-        }
-    }
-    get(key) {
-        return this.secrets.get(key);
-    }
-    getAll() {
-        return Object.fromEntries(this.secrets);
-    }
-    /**
-     * Returns a list of secret values to be redacted from logs
-     */
-    getSecretValuesForRedaction() {
-        return Array.from(this.secrets.values()).filter((v) => v.length > 3); // Avoid masking tiny strings
-    }
-}

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/worker.js

@@ -1,249 +0,0 @@
-import { resolveDriver } from './drivers/index.js';
-import { SafeExpressionEvaluator } from './evaluator/safe-eval.js';
-export function startWorkers(count, queue, secrets, config) {
-    return Array.from({ length: count }, (_, i) => startWorkerLoop(`worker-${i + 1}`, queue, secrets, config));
-}
-/**
- * Main worker loop: continuously polls the SQLite queue for pending jobs.
- */
-export async function startWorkerLoop(workerId, queue, secrets, config) {
-    const driver = await resolveDriver();
-    console.log(`[${workerId}] 🚀 Worker started. Driver: ${driver.name}`);
-    while (true) {
-        try {
-            const job = await queue.claimNextJob();
-            if (!job) {
-                await new Promise((r) => setTimeout(r, 2000));
-                continue;
-            }
-            await processJob(workerId, job, queue, secrets, config, driver);
-        }
-        catch (error) {
-            console.error(`[${workerId}] ⚠️ Worker execution loop error:`, error);
-            await new Promise((r) => setTimeout(r, 5000));
-        }
-    }
-}
-/**
- * Orchestrates the complete execution lifecycle for a claimed job.
- */
-async function processJob(workerId, job, queue, secrets, config, driver) {
-    console.log(`\n[${workerId}] 📦 Claimed Job #${job.id} (Workflow: ${job.workflow_id})`);
-    const payload = typeof job.payload === 'string' ? JSON.parse(job.payload) : job.payload;
-    const steps = payload.steps || [];
-    const inputs = payload.inputs || {};
-    const jobStartTime = Date.now();
-    const executionContext = {
-        inputs,
-        env: { ...config.env },
-        secrets: secrets.getAll(),
-        steps: {},
-    };
-    const stepReports = [];
-    let jobFailed = false;
-    let isCancelled = false;
-    // Execute steps sequentially
-    for (let i = 0; i < steps.length; i++) {
-        const step = steps[i];
-        const stepResult = await executeSingleStep({
-            workerId,
-            jobId: job.id,
-            step,
-            stepIndex: i,
-            totalSteps: steps.length,
-            executionContext,
-            driver,
-            queue,
-            config,
-        });
-        stepReports.push(stepResult.report);
-        if (stepResult.isCancelled) {
-            isCancelled = true;
-            jobFailed = true;
-            break;
-        }
-        if (stepResult.failed) {
-            jobFailed = true;
-            break;
-        }
-    }
-    // Mark unexecuted steps as skipped if execution halted early
-    if (jobFailed && stepReports.length < steps.length) {
-        fillSkippedSteps(steps, stepReports.length, stepReports);
-    }
-    const finalStatus = isCancelled ? 'cancelled' : jobFailed ? 'failed' : 'success';
-    // Persist status and execution report to SQLite Queue
-    await queue.finishJob(job.id, finalStatus);
-    console.log(`[${workerId}] ✅ Job #${job.id} completed as: ${finalStatus}`);
-    const executionReport = buildExecutionReport(job, finalStatus, jobStartTime, inputs, executionContext.env, stepReports, payload);
-    await queue.saveReport(job.id, executionReport);
-    // Dispatch reports to all registered plugins/reporters
-    await dispatchReporters(workerId, config.reporters, executionReport);
-}
-/**
- * Routes step execution to either JS Eval or Process Driver handler.
- */
-async function executeSingleStep(params) {
-    const { workerId, step, stepIndex, totalSteps, executionContext } = params;
-    const stepId = step.id || `step-${stepIndex}`;
-    const stepName = step.name || stepId;
-    console.log(`[${workerId}] ▶️ Running step ${stepIndex + 1}/${totalSteps}: ${stepName}`);
-    if (step.eval) {
-        return executeEvalStep(stepId, stepName, step.eval, executionContext);
-    }
-    else {
-        return executeRunStep({ ...params, stepId, stepName });
-    }
-}
-/**
- * Executes an in-process JS 'eval:' step.
- */
-async function executeEvalStep(stepId, stepName, evalExpr, executionContext) {
-    const startTime = Date.now();
-    try {
-        const evalResult = await SafeExpressionEvaluator.evaluateExpression(evalExpr, executionContext);
-        executionContext.steps[stepId] = { status: 'success', outputs: evalResult };
-        console.log(`[${stepId}] ✅ JS Eval step complete.`);
-        return {
-            failed: false,
-            isCancelled: false,
-            report: {
-                id: stepId,
-                name: stepName,
-                status: 'success',
-                durationMs: Date.now() - startTime,
-                exitCode: 0,
-                outputs: evalResult || {},
-                logFilePath: '',
-            },
-        };
-    }
-    catch (err) {
-        console.error(`[${stepId}] ❌ JS Eval step failed:`, err.message);
-        executionContext.steps[stepId] = { status: 'failed', error: err.message };
-        return {
-            failed: true,
-            isCancelled: false,
-            report: {
-                id: stepId,
-                name: stepName,
-                status: 'failed',
-                durationMs: Date.now() - startTime,
-                exitCode: 1,
-                error: err.message,
-                outputs: {},
-                logFilePath: '',
-            },
-        };
-    }
-}
-/**
- * Executes an out-of-process 'run:' step via the system execution driver.
- */
-async function executeRunStep(params) {
-    const { workerId, jobId, step, stepId, stepName, executionContext, driver, queue, config } = params;
-    // Evaluate step environment variables using deterministic evaluateValue rule
-    const evaluatedStepEnv = {};
-    if (step.env) {
-        for (const [key, val] of Object.entries(step.env)) {
-            evaluatedStepEnv[key] = String(await SafeExpressionEvaluator.evaluateValue(val, executionContext));
-        }
-    }
-    const stepCtx = {
-        jobId: jobId.toString(),
-        stepId,
-        workspacePath: `${config.storagePath || '/tmp/workspaces'}/job-${jobId}`,
-        command: step.run,
-        image: step.image,
-        env: {
-            ...executionContext.env,
-            ...evaluatedStepEnv,
-        },
-        timeoutMs: step.timeoutMs,
-    };
-    const handle = await driver.execute(stepCtx);
-    let isCancelled = false;
-    // Periodically poll SQLite for mid-run job cancellation signals
-    const cancelCheckInterval = setInterval(async () => {
-        if (await queue.isCancelled(+jobId)) {
-            console.log(`[${workerId}] 🛑 Job #${jobId} was cancelled! Halting step execution.`);
-            isCancelled = true;
-            clearInterval(cancelCheckInterval);
-            await handle.cancel();
-        }
-    }, 3000);
-    const result = await handle.done;
-    clearInterval(cancelCheckInterval);
-    const failed = result.exitCode !== 0 || isCancelled;
-    const stepStatus = result.exitCode === 0 ? 'success' : isCancelled ? 'cancelled' : 'failed';
-    if (failed) {
-        console.error(`[${workerId}] ❌ Step [${stepId}] failed with status: ${stepStatus}`);
-    }
-    executionContext.steps[stepId] = { status: stepStatus, exitCode: result.exitCode };
-    return {
-        failed,
-        isCancelled,
-        report: {
-            id: stepId,
-            name: stepName,
-            status: stepStatus,
-            durationMs: result.durationMs,
-            exitCode: result.exitCode,
-            error: result.error?.message,
-            outputs: executionContext.steps[stepId]?.outputs || {},
-            logFilePath: handle.logFilePath,
-        },
-    };
-}
-/**
- * Fills skipped status for remaining unexecuted steps.
- */
-function fillSkippedSteps(steps, startIndex, stepReports) {
-    for (let j = startIndex; j < steps.length; j++) {
-        const skippedStep = steps[j];
-        const stepId = skippedStep.id || `step-${j}`;
-        stepReports.push({
-            id: stepId,
-            name: skippedStep.name || stepId,
-            status: 'skipped',
-            durationMs: 0,
-            exitCode: 0,
-            outputs: {},
-            logFilePath: '',
-        });
-    }
-}
-/**
- * Assembles the frozen WorkflowExecutionReport JSON payload.
- */
-function buildExecutionReport(job, status, startTime, inputs, environment, stepReports, payload) {
-    return {
-        jobId: job.id.toString(),
-        workflowName: job.workflow_id,
-        status: status,
-        durationMs: Date.now() - startTime,
-        startedAt: new Date(startTime).toISOString(),
-        finishedAt: new Date().toISOString(),
-        inputs,
-        environment,
-        steps: stepReports,
-        artifacts: [],
-        rerunToken: JSON.stringify({ jobId: job.id, payload }),
-    };
-}
-/**
- * Dispatches the execution report concurrently to all registered reporters.
- */
-async function dispatchReporters(workerId, reporters = [], report) {
-    if (!Array.isArray(reporters) || reporters.length === 0)
-        return;
-    console.log(`[${workerId}] 📢 Dispatching execution report to ${reporters.length} reporter(s)...`);
-    await Promise.allSettled(reporters.map(async (reporter) => {
-        try {
-            await reporter.report(report);
-        }
-        catch (err) {
-            console.error(`[${workerId}] ⚠️ Reporter '${reporter.name || 'unknown'}' failed:`, err.message);
-        }
-    }));
-}