@cloud-cli/on 0.1.7 → 1.2.2

package/dist/parser/include-resolver.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+export class WorkflowIncludeResolver {
+    baseDir;
+    maxDepth;
+    constructor(baseDir, maxDepth = 5) {
+        this.baseDir = path.resolve(baseDir);
+        this.maxDepth = maxDepth;
+    }
+    /**
+     * Recursively loads and merges YAML workflows while guarding against cycles.
+     */
+    resolve(filePath, visited = new Set(), depth = 0) {
+        if (depth > this.maxDepth) {
+            throw new Error(`Max include depth of ${this.maxDepth} exceeded at ${filePath}`);
+        }
+        const absolutePath = path.resolve(this.baseDir, filePath);
+        // 1. Security Check: Prevent Directory Traversal outside workspace
+        if (!absolutePath.startsWith(this.baseDir)) {
+            throw new Error(`Security Violation: Include path '${filePath}' is outside workspace directory.`);
+        }
+        // 2. Cycle Detection
+        if (visited.has(absolutePath)) {
+            const cycleTrail = Array.from(visited).concat(absolutePath).join(' -> ');
+            throw new Error(`Circular 'includes' dependency detected: ${cycleTrail}`);
+        }
+        visited.add(absolutePath);
+        if (!fs.existsSync(absolutePath)) {
+            throw new Error(`Included workflow partial not found: ${filePath}`);
+        }
+        // 3. Parse File
+        const content = fs.readFileSync(absolutePath, 'utf-8');
+        const parsed = YAML.parse(content);
+        // 4. Handle Nested Includes (Depth First)
+        if (Array.isArray(parsed.includes)) {
+            for (const subInclude of parsed.includes) {
+                const partialData = this.resolve(subInclude, new Set(visited), depth + 1);
+                // Merge strategy: Append steps, deep-merge env and trigger properties
+                parsed.steps = [...(partialData.steps || []), ...(parsed.steps || [])];
+                parsed.env = { ...partialData.env, ...parsed.env };
+            }
+            delete parsed.includes; // Clean up top-level key after merging
+        }
+        return parsed;
+    }
+}

package/dist/parser/matrix-expander.js

@@ -0,0 +1,43 @@
+/**
+ * Expands a workflow definition containing a `strategy.matrix` into dynamic single-instance workflow jobs.
+ */
+export function expandMatrix(workflow) {
+    // If no matrix strategy is defined, return workflow as a single-element array
+    if (!workflow.strategy?.matrix || Object.keys(workflow.strategy.matrix).length === 0) {
+        return [workflow];
+    }
+    const matrix = workflow.strategy.matrix;
+    const keys = Object.keys(matrix);
+    // Calculate Cartesian Product across all matrix keys
+    const combinations = keys.reduce((acc, key) => {
+        const values = Array.isArray(matrix[key]) ? matrix[key] : [matrix[key]];
+        return acc.flatMap((combination) => values.map((val) => ({
+            ...combination,
+            [key]: val,
+        })));
+    }, [{}]);
+    // Clone workflow instance for each Cartesian matrix combination
+    return combinations.map((combination, index) => {
+        const clone = JSON.parse(JSON.stringify(workflow));
+        // Remove top-level strategy key after expansion
+        delete clone.strategy;
+        // Create matrix identity label: "node=20, os=ubuntu"
+        const matrixLabel = Object.entries(combination)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(', ');
+        // Append matrix label to workflow name & generate unique workflow ID
+        clone.name = `${workflow.name} (${matrixLabel})`;
+        clone.matrixContext = combination;
+        // Convert matrix values to environment variables (e.g., MATRIX_NODE_VERSION="20")
+        const matrixEnv = {};
+        for (const [k, v] of Object.entries(combination)) {
+            const envKey = `MATRIX_${k.toUpperCase().replace(/[^A-Z0-9_]/g, '_')}`;
+            matrixEnv[envKey] = String(v);
+        }
+        clone.env = {
+            ...(clone.env || {}),
+            ...matrixEnv,
+        };
+        return clone;
+    });
+}

package/dist/parser/yaml-loader.js

@@ -0,0 +1,45 @@
+import { readdir } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { WorkflowIncludeResolver } from './include-resolver.js';
+import { expandMatrix } from './matrix-expander.js';
+export class YamlLoader {
+    static async from(path) {
+        const absolutePath = isAbsolute(path) ? resolve('/', path) : join(process.cwd(), resolve('/', path));
+        const list = await readdir(absolutePath, { withFileTypes: true });
+        const files = list
+            .filter((f) => f.isFile() && (f.name.endsWith('.yml') || f.name.endsWith('.yaml')))
+            .map((f) => join(absolutePath, f.name));
+        const workflows = [];
+        const resolver = new WorkflowIncludeResolver(path);
+        for (const file of files) {
+            workflows.push(...(await YamlLoader.loadFile(file, resolver)));
+        }
+        return workflows;
+    }
+    static loadFile(path, resolver) {
+        const workflows = [];
+        try {
+            // Resolve includes & partials
+            const resolved = resolver.resolve(path);
+            // Expand matrix strategy into concrete job specs
+            const expandedWorkflows = expandMatrix(resolved);
+            for (const wf of expandedWorkflows) {
+                workflows.push({
+                    id: wf.id || wf.name.toLowerCase().replace(/[^a-z0-9]/g, '-'),
+                    name: wf.name,
+                    on: {
+                        provider: Object.keys(wf.on || {})[0] || 'generic',
+                        if: wf.on?.[Object.keys(wf.on || {})[0]]?.if,
+                    },
+                    concurrency: wf.concurrency,
+                    steps: wf.steps,
+                });
+            }
+        }
+        catch (err) {
+            console.error(`❌ Error parsing workflow '${path}':`, err.message);
+            return [];
+        }
+        return workflows;
+    }
+}

package/dist/plugins/github-status.plugin.js

@@ -0,0 +1,19 @@
+export class GitHubStatusPlugin {
+    name = 'github-commit-status';
+    async onWorkflowStart(wf) {
+        if (!wf.inputs.commit_sha || !wf.inputs.clone_url)
+            return;
+        await this.updateStatus(wf, 'pending', 'Workflow build has started.');
+    }
+    async onWorkflowFinish(wf, status) {
+        if (!wf.inputs.commit_sha || !wf.inputs.clone_url)
+            return;
+        const state = status === 'success' ? 'success' : 'failure';
+        const description = status === 'success' ? 'All workflow steps passed!' : 'Workflow failed.';
+        await this.updateStatus(wf, state, description);
+    }
+    async updateStatus(wf, state, description) {
+        // Calls GitHub REST API using inputs.commit_sha
+        console.log(`[GitHub Plugin] Setting commit status for ${wf.inputs.commit_sha} -> ${state}: ${description}`);
+    }
+}

package/dist/plugins/manager.js

@@ -0,0 +1,21 @@
+export class PluginManager {
+    plugins = [];
+    register(plugin) {
+        console.log(`🔌 Registered Plugin: ${plugin.name}`);
+        this.plugins.push(plugin);
+    }
+    async triggerWorkflowStart(wf) {
+        for (const plugin of this.plugins) {
+            if (plugin.onWorkflowStart) {
+                await plugin.onWorkflowStart(wf).catch(err => console.error(`[Plugin Error] ${plugin.name}.onWorkflowStart:`, err));
+            }
+        }
+    }
+    async triggerWorkflowFinish(wf, status) {
+        for (const plugin of this.plugins) {
+            if (plugin.onWorkflowFinish) {
+                await plugin.onWorkflowFinish(wf, status).catch(err => console.error(`[Plugin Error] ${plugin.name}.onWorkflowFinish:`, err));
+            }
+        }
+    }
+}

package/dist/plugins/types.js

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

package/dist/queue/dispatcher.js

@@ -0,0 +1,112 @@
+import db from '../db-client.js';
+export class QueueManager {
+    workerId;
+    constructor(workerId) {
+        this.workerId = workerId;
+    }
+    /**
+     * Initializes the database schema.
+     */
+    async init() {
+        await db.run(`
+      CREATE TABLE IF NOT EXISTS jobs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        workflow_id TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        concurrency_key TEXT,
+        worker_id TEXT,
+        report TEXT, -- Stores WorkflowExecutionReport JSON
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        await this.clearStaleJobs();
+    }
+    /**
+     * Enqueues a new job into the database.
+     * Includes simple GitHub-style concurrency cancellation.
+     */
+    async enqueue(workflowId, payload, concurrencyKey) {
+        // If a concurrency key is provided, cancel existing pending/running jobs in that group
+        if (concurrencyKey) {
+            await db.run(`
+        UPDATE jobs
+        SET status = 'cancelling'
+        WHERE concurrency_key = ? AND status IN ('pending', 'running');
+      `, [concurrencyKey]);
+        }
+        const res = await db.run(`
+      INSERT INTO jobs (workflow_id, concurrency_key, payload)
+      VALUES (?, ?, ?);
+    `, [workflowId, concurrencyKey || '', JSON.stringify(payload)]);
+        return res;
+    }
+    /**
+     * ATOMICALY claims the oldest pending job.
+     * Requires SQLite >= 3.35 for the RETURNING clause.
+     */
+    async claimNextJob() {
+        // This query is completely immune to HTTP/Network race conditions.
+        // It locks the row, updates it, and returns the data in one transaction.
+        const result = await db.get(`
+      UPDATE jobs
+      SET
+        status = 'running',
+        worker_id = ?,
+        started_at = CURRENT_TIMESTAMP
+      WHERE id = (
+        SELECT id FROM jobs
+        WHERE status = 'pending'
+        ORDER BY created_at ASC
+        LIMIT 1
+      )
+      RETURNING *;
+    `, [this.workerId]);
+        return result ? result : null;
+    }
+    /**
+     * Marks a job as completed or failed
+     */
+    async finishJob(jobId, status) {
+        await db.run(`
+      UPDATE jobs
+      SET status = ?, finished_at = CURRENT_TIMESTAMP
+      WHERE id = ?;
+    `, [status, jobId]);
+    }
+    /**
+     * Checks if the current job has been marked for cancellation by another event
+     */
+    async isCancelled(jobId) {
+        const job = await db.get(`SELECT status FROM jobs WHERE id = ?;`, [jobId]);
+        return job?.status === 'cancelling';
+    }
+    async clearStaleJobs() {
+        return await db.run(`UPDATE jobs SET status = 'pending', worker_id = NULL WHERE status = 'running' AND started_at < datetime('now', '-1 hour');`);
+    }
+    /**
+     * Save complete execution report JSON to DB
+     */
+    async saveReport(jobId, report) {
+        await db.run(`UPDATE jobs SET report = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`, [
+            JSON.stringify(report),
+            jobId,
+        ]);
+    }
+    /**
+     * Fetch job details + report by ID
+     */
+    async getJob(jobId) {
+        return db.get(`SELECT * FROM jobs WHERE id = ?`, [jobId]);
+    }
+    /**
+     * List recent jobs for dashboard status monitoring
+     */
+    async listJobs(limit = 50) {
+        return db.all(`SELECT id, workflow_id, status, concurrency_key, worker_id, created_at, updated_at, report
+       FROM jobs
+       ORDER BY id DESC
+       LIMIT ?`, [limit]);
+    }
+}

package/dist/reporters/html.reporter.js

@@ -0,0 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { AnsiUp } from 'ansi_up';
+export class HtmlReporter {
+    name = 'html-reporter';
+    outputDir;
+    ansiUp;
+    constructor(options) {
+        this.outputDir = options.outputDir;
+        this.ansiUp = new AnsiUp();
+        this.ansiUp.use_classes = false; // Inline CSS styling for portability
+    }
+    async report(execReport) {
+        fs.mkdirSync(this.outputDir, { recursive: true });
+        const htmlContent = this.generateHtml(execReport);
+        const filePath = path.join(this.outputDir, `run-${execReport.jobId}.html`);
+        fs.writeFileSync(filePath, htmlContent, 'utf-8');
+        console.log(`📊 HTML Execution Report generated: ${filePath}`);
+    }
+    /**
+     * Render standalone HTML template using Tailwind CSS via CDN
+     */
+    generateHtml(execReport) {
+        const statusColor = execReport.status === 'success'
+            ? 'bg-emerald-500/10 text-emerald-400 border-emerald-500/20'
+            : execReport.status === 'failed'
+                ? 'bg-rose-500/10 text-rose-400 border-rose-500/20'
+                : 'bg-amber-500/10 text-amber-400 border-amber-500/20';
+        // Render Steps & Logs
+        const stepRows = execReport.steps
+            .map((step, idx) => {
+            let rawLog = '';
+            if (step.logFilePath && fs.existsSync(step.logFilePath)) {
+                try {
+                    rawLog = fs.readFileSync(step.logFilePath, 'utf-8');
+                }
+                catch { }
+            }
+            const htmlLog = rawLog
+                ? this.ansiUp.ansi_to_html(rawLog)
+                : '<span class="text-gray-500">(No terminal log output recorded for this step)</span>';
+            const stepBadge = step.status === 'success'
+                ? 'text-emerald-400 bg-emerald-500/10'
+                : step.status === 'failed'
+                    ? 'text-rose-400 bg-rose-500/10'
+                    : 'text-gray-400 bg-gray-500/10';
+            return `
+        <div class="border border-gray-800 rounded-xl overflow-hidden bg-gray-900/50 mb-4">
+          <div class="flex items-center justify-between p-4 bg-gray-800/40 border-b border-gray-800">
+            <div class="flex items-center gap-3">
+              <span class="text-xs font-mono text-gray-500">#${idx + 1}</span>
+              <h3 class="font-semibold text-gray-200">${step.name}</h3>
+              <span class="px-2.5 py-0.5 rounded-full text-xs font-medium ${stepBadge}">
+                ${step.status.toUpperCase()}
+              </span>
+            </div>
+            <div class="text-sm font-mono text-gray-400">${step.durationMs}ms</div>
+          </div>
+          <div class="p-4 bg-gray-950 font-mono text-xs overflow-x-auto text-gray-300 leading-relaxed max-h-96">
+            <pre class="whitespace-pre-wrap">${htmlLog}</pre>
+          </div>
+        </div>
+      `;
+        })
+            .join('');
+        return `<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Run #${execReport.jobId} - ${execReport.workflowName}</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="bg-gray-950 text-gray-100 min-h-screen p-6 font-sans">
+  <div class="max-w-5xl mx-auto space-y-6">
+
+    <!-- Top Header -->
+    <div class="flex items-center justify-between border-b border-gray-800 pb-6">
+      <div>
+        <a href="/runs" class="text-xs text-indigo-400 hover:underline mb-1 inline-block">← Back to Dashboard</a>
+        <h1 class="text-2xl font-bold text-white flex items-center gap-3">
+          ${execReport.workflowName}
+          <span class="text-sm font-mono text-gray-500">#${execReport.jobId}</span>
+        </h1>
+        <p class="text-xs text-gray-400 mt-1">Started ${execReport.startedAt} • Finished in ${execReport.durationMs}ms</p>
+      </div>
+      <span class="px-4 py-1.5 rounded-full text-sm font-semibold border ${statusColor}">
+        ${execReport.status.toUpperCase()}
+      </span>
+    </div>
+
+    <!-- Inputs Overview -->
+    <div class="bg-gray-900 border border-gray-800 rounded-xl p-4">
+      <h2 class="text-xs font-semibold text-gray-400 uppercase tracking-wider mb-2">Trigger Inputs</h2>
+      <pre class="font-mono text-xs text-indigo-300 bg-gray-950 p-3 rounded-lg overflow-x-auto">${JSON.stringify(execReport.inputs, null, 2)}</pre>
+    </div>
+
+    <!-- Steps Timeline -->
+    <div>
+      <h2 class="text-lg font-semibold text-white mb-4">Execution Steps</h2>
+      ${stepRows}
+    </div>
+
+  </div>
+</body>
+</html>`;
+    }
+}

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,25 @@
+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

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

package/dist/runner/step-runner.js

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,40 @@
+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

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