@cloud-cli/on 1.2.2 → 1.2.3

package/dist/ingress/server.js

@@ -1,241 +0,0 @@
-import http from 'node:http';
-import { URL } from 'node:url';
-import { SafeExpressionEvaluator } from '../evaluator/safe-eval.js';
-import { GitHubPreprocessor } from './preprocessors/github.js';
-import { HtmlReporter } from '../reporters/html.reporter.js';
-export class WebhookServer {
-    server;
-    preprocessors = new Map();
-    workflows = [];
-    queue;
-    secrets;
-    adminToken;
-    static withPort(options) {
-        const { port, ...o } = options;
-        return new WebhookServer(o).listen(port);
-    }
-    constructor(options) {
-        this.queue = options.queue;
-        this.secrets = options.secrets;
-        this.adminToken = options.adminToken;
-        this.workflows = options.workflows;
-        // Register built-in preprocessors
-        this.registerPreprocessor(new GitHubPreprocessor());
-        this.server = http.createServer((req, res) => this.handleRequest(req, res));
-    }
-    registerPreprocessor(preprocessor) {
-        this.preprocessors.set(preprocessor.name, preprocessor);
-    }
-    async handleRequest(req, res) {
-        const url = new URL(req.url || '/', `${req.headers['x-forwarded-proto'] || 'http'}://${req.headers['x-forwarded-host'] || req.headers.host}`);
-        if (req.method === 'GET' && (url.pathname === '/runs' || url.pathname === '/')) {
-            return this.renderDashboard(res);
-        }
-        if (req.method === 'GET' && url.pathname.startsWith('/runs/')) {
-            const jobId = url.pathname.replace('/runs/', '');
-            return this.renderRunDetails(jobId, res);
-        }
-        if (req.method === 'POST' && url.pathname === '/admin/reload-secrets') {
-            return this.handleSecretReload(req, res);
-        }
-        if (req.method === 'POST' && url.pathname.startsWith('/webhooks/')) {
-            const provider = url.pathname.replace('/webhooks/', '');
-            return this.handleWebhook(provider, req, res);
-        }
-        // Fallback 404
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Endpoint not found' }));
-    }
-    /**
-     * Processes incoming HTTP webhooks
-     */
-    async handleWebhook(provider, req, res) {
-        try {
-            // 5MB
-            const MAX_PAYLOAD_SIZE = 5 * 1024 * 1024;
-            const chunks = [];
-            let receivedBytes = 0;
-            for await (const chunk of req) {
-                receivedBytes += chunk.length;
-                if (receivedBytes > MAX_PAYLOAD_SIZE) {
-                    res.writeHead(413, { 'Content-Type': 'application/json' });
-                    return res.end(JSON.stringify({ error: 'Payload size exceeds limit' }));
-                }
-                chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
-            }
-            const rawBuffer = Buffer.concat(chunks);
-            let body = {};
-            try {
-                body = JSON.parse(rawBuffer.toString('utf-8'));
-            }
-            catch { }
-            const headers = Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k.toLowerCase(), Array.isArray(v) ? v[0] : v || '']));
-            const preprocessor = this.preprocessors.get(provider);
-            const secret = this.secrets.get(`${provider.toUpperCase()}_WEBHOOK_SECRET`);
-            let isValid = true;
-            let inputs = { ...body };
-            if (preprocessor) {
-                const result = preprocessor.parse(headers, body, rawBuffer, secret);
-                isValid = result.isValid;
-                inputs = result.inputs;
-            }
-            // Reject unauthorized requests immediately
-            if (!isValid) {
-                res.writeHead(401, { 'Content-Type': 'application/json' });
-                return res.end(JSON.stringify({ error: 'Invalid HMAC signature or authentication failed' }));
-            }
-            // 3. Match Incoming Webhook to Registered Workflows
-            const triggeredJobs = [];
-            for (const workflow of this.workflows) {
-                // Match provider (e.g. 'github')
-                if (workflow.on.provider !== provider)
-                    continue;
-                // Evaluate workflow trigger condition if defined (e.g. `if: inputs.event == 'push'`)
-                if (workflow.on.if) {
-                    try {
-                        const shouldRun = SafeExpressionEvaluator.evaluateCondition(workflow.on.if, { inputs });
-                        if (!shouldRun)
-                            continue;
-                    }
-                    catch (evalErr) {
-                        console.error(`⚠️ Condition evaluation error in workflow [${workflow.id}]:`, evalErr.message);
-                        continue; // Skip this workflow without crashing server
-                    }
-                }
-                // 4. Resolve Concurrency Key (if specified)
-                let concurrencyKey;
-                if (workflow.concurrency?.group) {
-                    concurrencyKey = await SafeExpressionEvaluator.evaluateValue(workflow.concurrency.group, { inputs });
-                }
-                // 5. Enqueue Job to SQLite
-                const jobPayload = {
-                    workflowId: workflow.id,
-                    steps: workflow.steps,
-                    inputs,
-                };
-                await this.queue.enqueue(workflow.id, jobPayload, concurrencyKey);
-                triggeredJobs.push(workflow.id);
-            }
-            // 6. Respond Fast (202 Accepted)
-            res.writeHead(202, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                message: 'Webhook processed',
-                triggeredWorkflows: triggeredJobs,
-            }));
-        }
-        catch (err) {
-            console.error('❌ Webhook Ingress Error:', err);
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Internal Ingress Error', details: err.message }));
-        }
-    }
-    /**
-     * Handles Zero-Downtime Secret Reload
-     */
-    async handleSecretReload(req, res) {
-        const authHeader = req.headers['authorization'];
-        if (authHeader !== `Bearer ${this.adminToken}`) {
-            res.writeHead(403, { 'Content-Type': 'application/json' });
-            return res.end(JSON.stringify({ error: 'Unauthorized' }));
-        }
-        // Trigger in-memory secret reload
-        this.secrets.reload();
-        console.log('🔄 SecretStore reloaded successfully without downtime!');
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ message: 'Secrets reloaded successfully' }));
-    }
-    /**
-     * Serves the Server Health & Jobs Dashboard
-     */
-    async renderDashboard(res) {
-        const jobs = await this.queue.listJobs(50);
-        const rows = jobs
-            .map((j) => {
-            const badge = j.status === 'success'
-                ? 'bg-emerald-500/10 text-emerald-400'
-                : j.status === 'failed'
-                    ? 'bg-rose-500/10 text-rose-400'
-                    : j.status === 'running'
-                        ? 'bg-indigo-500/10 text-indigo-400 animate-pulse'
-                        : 'bg-gray-500/10 text-gray-400';
-            return `
-      <tr class="border-b border-gray-800 hover:bg-gray-900/50 transition">
-        <td class="py-3 px-4 font-mono text-indigo-400"><a href="/runs/${j.id}" class="hover:underline">#${j.id}</a></td>
-        <td class="py-3 px-4 font-medium text-white">${j.workflow_id}</td>
-        <td class="py-3 px-4">
-          <span class="px-2.5 py-0.5 rounded-full text-xs font-semibold ${badge}">${j.status.toUpperCase()}</span>
-        </td>
-        <td class="py-3 px-4 text-xs font-mono text-gray-400">${j.worker_id || '-'}</td>
-        <td class="py-3 px-4 text-xs text-gray-400">${j.created_at}</td>
-        <td class="py-3 px-4 text-right">
-          <a href="/runs/${j.id}" class="text-xs bg-gray-800 hover:bg-gray-700 text-gray-200 px-3 py-1 rounded border border-gray-700">View Trace →</a>
-        </td>
-      </tr>
-    `;
-        })
-            .join('');
-        const html = `<!DOCTYPE html>
-<html lang="en" class="dark">
-<head>
-  <meta charset="UTF-8">
-  <meta http-equiv="refresh" content="10"> <!-- Auto-refreshes every 10s -->
-  <title>Workflow Engine Dashboard</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-6xl mx-auto space-y-6">
-    <div class="flex items-center justify-between border-b border-gray-800 pb-4">
-      <div>
-        <h1 class="text-2xl font-bold text-white">⚙️ Runner Engine Status</h1>
-        <p class="text-xs text-gray-400">Live SQLite Job Queue & Execution Traces</p>
-      </div>
-      <span class="text-xs font-mono bg-emerald-500/10 text-emerald-400 px-3 py-1 rounded-full border border-emerald-500/20">
-        ● System Operational
-      </span>
-    </div>
-
-    <div class="bg-gray-900 border border-gray-800 rounded-xl overflow-hidden">
-      <table class="w-full text-left text-sm">
-        <thead class="bg-gray-800/50 text-gray-400 text-xs uppercase font-mono border-b border-gray-800">
-          <tr>
-            <th class="py-3 px-4">Job ID</th>
-            <th class="py-3 px-4">Workflow</th>
-            <th class="py-3 px-4">Status</th>
-            <th class="py-3 px-4">Worker</th>
-            <th class="py-3 px-4">Created At</th>
-            <th class="py-3 px-4 text-right">Action</th>
-          </tr>
-        </thead>
-        <tbody>${rows.length ? rows : '<tr><td colspan="6" class="p-6 text-center text-gray-500">No jobs recorded yet.</td></tr>'}</tbody>
-      </table>
-    </div>
-  </div>
-</body>
-</html>`;
-        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-        res.end(html);
-    }
-    /**
-     * Serves single job HTML report
-     */
-    async renderRunDetails(jobId, res) {
-        const job = await this.queue.getJob(jobId);
-        if (!job || !job.report) {
-            res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
-            return res.end('<h1>404 - Report Not Found</h1><p>Job is still running or does not exist.</p><a href="/runs">← Back to Dashboard</a>');
-        }
-        const reportData = JSON.parse(job.report);
-        const htmlReporter = new HtmlReporter({ outputDir: '' });
-        const htmlContent = htmlReporter.generateHtml(reportData);
-        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-        res.end(htmlContent);
-    }
-    listen(port) {
-        return new Promise((resolve) => {
-            this.server.listen(port, () => {
-                console.log(`🌐 Webhook Ingress Server running on port ${port}`);
-                resolve();
-            });
-        });
-    }
-}

package/dist/logging/redactor.js

@@ -1,20 +0,0 @@
-import { Transform } from 'node:stream';
-export class SecretRedactorStream extends Transform {
-    secretValues;
-    constructor(secretValues) {
-        super();
-        // Sort longest secrets first to prevent partial replacements
-        this.secretValues = secretValues.sort((a, b) => b.length - a.length);
-    }
-    _transform(chunk, encoding, callback) {
-        let logString = chunk.toString('utf-8');
-        // Replace all known secret values with ***
-        for (const secret of this.secretValues) {
-            if (secret) {
-                logString = logString.replaceAll(secret, '***');
-            }
-        }
-        this.push(Buffer.from(logString));
-        callback();
-    }
-}

package/dist/parser/include-resolver.js

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

@@ -1,43 +0,0 @@
-/**
- * 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

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

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

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

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

package/dist/queue/dispatcher.js

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

@@ -1,108 +0,0 @@
-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>`;
-    }
-}