cli4ai 1.2.5 → 1.2.7

package/dist/dashboard/db/runs.js

@@ -0,0 +1,475 @@
+/**
+ * Run History Database Operations
+ *
+ * CRUD operations for runs, steps, and logs.
+ */
+import { randomUUID } from 'crypto';
+import { getDatabase } from './index.js';
+// ═══════════════════════════════════════════════════════════════════════════
+// RUN OPERATIONS
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Create a new run record
+ */
+export function createRun(input) {
+    try {
+        const db = getDatabase();
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const stmt = db.prepare(`
+      INSERT INTO runs (
+        id, routine_name, routine_path, started_at, status,
+        trigger_type, retry_attempt, vars_json, created_at
+      ) VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?)
+    `);
+        stmt.run(id, input.routineName, input.routinePath ?? null, now, input.triggerType, input.retryAttempt ?? 0, input.vars ? JSON.stringify(input.vars) : null, now);
+        return getRun(id);
+    }
+    catch (error) {
+        throw new Error(`Failed to create run: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get a run by ID
+ */
+export function getRun(id) {
+    const db = getDatabase();
+    const stmt = db.prepare('SELECT * FROM runs WHERE id = ?');
+    return stmt.get(id) ?? null;
+}
+/**
+ * Get a run with all its steps and logs
+ */
+export function getRunWithDetails(id) {
+    const run = getRun(id);
+    if (!run)
+        return null;
+    const steps = getRunSteps(id);
+    const logs = getRunLogs(id, { limit: 5000 }); // Include up to 5000 log lines
+    const logCount = logs.length;
+    return {
+        ...run,
+        steps,
+        logs,
+        logCount,
+    };
+}
+/**
+ * Update a run record
+ */
+export function updateRun(id, input) {
+    try {
+        const db = getDatabase();
+        const updates = [];
+        const values = [];
+        if (input.status !== undefined) {
+            updates.push('status = ?');
+            values.push(input.status);
+        }
+        if (input.exitCode !== undefined) {
+            updates.push('exit_code = ?');
+            values.push(input.exitCode);
+        }
+        if (input.finishedAt !== undefined) {
+            updates.push('finished_at = ?');
+            values.push(input.finishedAt);
+        }
+        if (input.durationMs !== undefined) {
+            updates.push('duration_ms = ?');
+            values.push(input.durationMs);
+        }
+        if (updates.length === 0) {
+            return getRun(id);
+        }
+        values.push(id);
+        const stmt = db.prepare(`UPDATE runs SET ${updates.join(', ')} WHERE id = ?`);
+        stmt.run(...values);
+        return getRun(id);
+    }
+    catch (error) {
+        throw new Error(`Failed to update run ${id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Finish a run (set status, exit code, timing)
+ */
+export function finishRun(id, status, exitCode) {
+    const run = getRun(id);
+    if (!run)
+        return null;
+    const finishedAt = new Date().toISOString();
+    const startedAt = new Date(run.started_at).getTime();
+    const durationMs = Date.now() - startedAt;
+    return updateRun(id, {
+        status,
+        exitCode,
+        finishedAt,
+        durationMs,
+    });
+}
+/**
+ * List runs with optional filters
+ */
+export function listRuns(filters = {}) {
+    const db = getDatabase();
+    const conditions = [];
+    const values = [];
+    if (filters.routineName) {
+        conditions.push('routine_name = ?');
+        values.push(filters.routineName);
+    }
+    if (filters.status) {
+        conditions.push('status = ?');
+        values.push(filters.status);
+    }
+    if (filters.triggerType) {
+        conditions.push('trigger_type = ?');
+        values.push(filters.triggerType);
+    }
+    if (filters.startedAfter) {
+        conditions.push('started_at >= ?');
+        values.push(filters.startedAfter);
+    }
+    if (filters.startedBefore) {
+        conditions.push('started_at <= ?');
+        values.push(filters.startedBefore);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = filters.limit ?? 50;
+    const offset = filters.offset ?? 0;
+    const stmt = db.prepare(`
+    SELECT * FROM runs
+    ${where}
+    ORDER BY started_at DESC
+    LIMIT ? OFFSET ?
+  `);
+    values.push(limit, offset);
+    return stmt.all(...values);
+}
+/**
+ * Count runs matching filters
+ */
+export function countRuns(filters = {}) {
+    const db = getDatabase();
+    const conditions = [];
+    const values = [];
+    if (filters.routineName) {
+        conditions.push('routine_name = ?');
+        values.push(filters.routineName);
+    }
+    if (filters.status) {
+        conditions.push('status = ?');
+        values.push(filters.status);
+    }
+    if (filters.triggerType) {
+        conditions.push('trigger_type = ?');
+        values.push(filters.triggerType);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const stmt = db.prepare(`SELECT COUNT(*) as count FROM runs ${where}`);
+    const result = stmt.get(...values);
+    return result.count;
+}
+/**
+ * Delete a run and all its associated data
+ */
+export function deleteRun(id) {
+    const db = getDatabase();
+    const stmt = db.prepare('DELETE FROM runs WHERE id = ?');
+    const result = stmt.run(id);
+    return result.changes > 0;
+}
+/**
+ * Delete old runs (for cleanup)
+ */
+export function deleteOldRuns(olderThanDays) {
+    const db = getDatabase();
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - olderThanDays);
+    const stmt = db.prepare('DELETE FROM runs WHERE started_at < ?');
+    const result = stmt.run(cutoff.toISOString());
+    return result.changes;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// STEP OPERATIONS
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Create a step record
+ */
+export function createStep(input) {
+    try {
+        const db = getDatabase();
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const stmt = db.prepare(`
+      INSERT INTO run_steps (
+        id, run_id, step_id, step_type, status, exit_code, duration_ms,
+        stdout, stderr, json_output, error_code, error_message, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, input.runId, input.stepId, input.stepType, input.status, input.exitCode ?? null, input.durationMs ?? null, input.stdout ?? null, input.stderr ?? null, input.jsonOutput ? JSON.stringify(input.jsonOutput) : null, input.errorCode ?? null, input.errorMessage ?? null, now);
+        return getStep(id);
+    }
+    catch (error) {
+        throw new Error(`Failed to create step ${input.stepId} for run ${input.runId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get a step by ID
+ */
+export function getStep(id) {
+    const db = getDatabase();
+    const stmt = db.prepare('SELECT * FROM run_steps WHERE id = ?');
+    return stmt.get(id) ?? null;
+}
+/**
+ * Get all steps for a run
+ */
+export function getRunSteps(runId) {
+    const db = getDatabase();
+    const stmt = db.prepare('SELECT * FROM run_steps WHERE run_id = ? ORDER BY created_at');
+    return stmt.all(runId);
+}
+/**
+ * Find a step by runId and stepId
+ */
+export function findStepByRunAndStepId(runId, stepId) {
+    const db = getDatabase();
+    const stmt = db.prepare('SELECT * FROM run_steps WHERE run_id = ? AND step_id = ?');
+    return stmt.get(runId, stepId) ?? null;
+}
+/**
+ * Upsert a step (create or update)
+ */
+export function upsertStep(input) {
+    const existing = findStepByRunAndStepId(input.runId, input.stepId);
+    if (existing) {
+        // Update existing step
+        return updateStep(existing.id, {
+            status: input.status,
+            exitCode: input.exitCode,
+            durationMs: input.durationMs,
+            stdout: input.stdout,
+            stderr: input.stderr,
+            jsonOutput: input.jsonOutput,
+            errorCode: input.errorCode,
+            errorMessage: input.errorMessage,
+        });
+    }
+    else {
+        // Create new step
+        return createStep(input);
+    }
+}
+/**
+ * Update a step
+ */
+export function updateStep(id, updates) {
+    const db = getDatabase();
+    const fields = [];
+    const values = [];
+    if (updates.status !== undefined) {
+        fields.push('status = ?');
+        values.push(updates.status);
+    }
+    if (updates.exitCode !== undefined) {
+        fields.push('exit_code = ?');
+        values.push(updates.exitCode);
+    }
+    if (updates.durationMs !== undefined) {
+        fields.push('duration_ms = ?');
+        values.push(updates.durationMs);
+    }
+    if (updates.stdout !== undefined) {
+        fields.push('stdout = ?');
+        values.push(updates.stdout);
+    }
+    if (updates.stderr !== undefined) {
+        fields.push('stderr = ?');
+        values.push(updates.stderr);
+    }
+    if (updates.jsonOutput !== undefined) {
+        fields.push('json_output = ?');
+        values.push(JSON.stringify(updates.jsonOutput));
+    }
+    if (updates.errorCode !== undefined) {
+        fields.push('error_code = ?');
+        values.push(updates.errorCode);
+    }
+    if (updates.errorMessage !== undefined) {
+        fields.push('error_message = ?');
+        values.push(updates.errorMessage);
+    }
+    if (fields.length === 0)
+        return getStep(id);
+    values.push(id);
+    const stmt = db.prepare(`UPDATE run_steps SET ${fields.join(', ')} WHERE id = ?`);
+    stmt.run(...values);
+    return getStep(id);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// LOG OPERATIONS
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Append a log line
+ */
+export function appendLog(input) {
+    const db = getDatabase();
+    const now = new Date().toISOString();
+    const stmt = db.prepare(`
+    INSERT INTO run_logs (run_id, timestamp, stream, line, step_id)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+    stmt.run(input.runId, now, input.stream, input.line, input.stepId ?? null);
+}
+/**
+ * Append multiple log lines efficiently
+ */
+export function appendLogs(logs) {
+    const db = getDatabase();
+    const now = new Date().toISOString();
+    const stmt = db.prepare(`
+    INSERT INTO run_logs (run_id, timestamp, stream, line, step_id)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+    const insertMany = db.transaction((logs) => {
+        for (const log of logs) {
+            stmt.run(log.runId, now, log.stream, log.line, log.stepId ?? null);
+        }
+    });
+    insertMany(logs);
+}
+/**
+ * Get logs for a run
+ */
+export function getRunLogs(runId, options = {}) {
+    const db = getDatabase();
+    const { limit = 1000, offset = 0, stream } = options;
+    const conditions = ['run_id = ?'];
+    const values = [runId];
+    if (stream) {
+        conditions.push('stream = ?');
+        values.push(stream);
+    }
+    values.push(limit, offset);
+    const stmt = db.prepare(`
+    SELECT * FROM run_logs
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY id ASC
+    LIMIT ? OFFSET ?
+  `);
+    return stmt.all(...values);
+}
+/**
+ * Get log count for a run
+ */
+export function getRunLogCount(runId) {
+    const db = getDatabase();
+    const stmt = db.prepare('SELECT COUNT(*) as count FROM run_logs WHERE run_id = ?');
+    const result = stmt.get(runId);
+    return result.count;
+}
+/**
+ * Get the last N logs for a run (for real-time tailing)
+ */
+export function getRecentLogs(runId, count = 100) {
+    const db = getDatabase();
+    const stmt = db.prepare(`
+    SELECT * FROM (
+      SELECT * FROM run_logs
+      WHERE run_id = ?
+      ORDER BY id DESC
+      LIMIT ?
+    ) ORDER BY id ASC
+  `);
+    return stmt.all(runId, count);
+}
+/**
+ * Get metrics for a routine
+ */
+export function getRoutineMetrics(routineName) {
+    const db = getDatabase();
+    const statsStmt = db.prepare(`
+    SELECT
+      COUNT(*) as total_runs,
+      SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successful_runs,
+      SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_runs,
+      AVG(duration_ms) as avg_duration_ms,
+      MIN(duration_ms) as min_duration_ms,
+      MAX(duration_ms) as max_duration_ms
+    FROM runs
+    WHERE routine_name = ? AND status != 'running'
+  `);
+    const stats = statsStmt.get(routineName);
+    const lastRunStmt = db.prepare(`
+    SELECT started_at, status FROM runs
+    WHERE routine_name = ?
+    ORDER BY started_at DESC
+    LIMIT 1
+  `);
+    const lastRun = lastRunStmt.get(routineName);
+    return {
+        routineName,
+        totalRuns: stats.total_runs,
+        successfulRuns: stats.successful_runs,
+        failedRuns: stats.failed_runs,
+        successRate: stats.total_runs > 0 ? stats.successful_runs / stats.total_runs : 0,
+        avgDurationMs: stats.avg_duration_ms,
+        minDurationMs: stats.min_duration_ms,
+        maxDurationMs: stats.max_duration_ms,
+        lastRunAt: lastRun?.started_at ?? null,
+        lastStatus: lastRun?.status ?? null,
+    };
+}
+/**
+ * Get metrics for all routines
+ */
+export function getAllRoutineMetrics() {
+    const db = getDatabase();
+    const routinesStmt = db.prepare(`
+    SELECT DISTINCT routine_name FROM runs ORDER BY routine_name
+  `);
+    const routines = routinesStmt.all();
+    return routines.map((r) => getRoutineMetrics(r.routine_name));
+}
+export function getDashboardStats() {
+    const db = getDatabase();
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const todayStr = today.toISOString();
+    const weekAgo = new Date();
+    weekAgo.setDate(weekAgo.getDate() - 7);
+    weekAgo.setHours(0, 0, 0, 0);
+    const weekAgoStr = weekAgo.toISOString();
+    const stats = db
+        .prepare(`
+    SELECT
+      COUNT(*) as total_runs,
+      SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END) as running_count,
+      SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success_count,
+      SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failure_count,
+      AVG(CASE WHEN duration_ms IS NOT NULL THEN duration_ms ELSE NULL END) as avg_duration_ms
+    FROM runs
+  `)
+        .get();
+    const todayStats = db
+        .prepare(`SELECT COUNT(*) as runs_today FROM runs WHERE started_at >= ?`)
+        .get(todayStr);
+    const weekStats = db
+        .prepare(`SELECT COUNT(*) as runs_this_week FROM runs WHERE started_at >= ?`)
+        .get(weekAgoStr);
+    const totalRuns = stats?.total_runs || 0;
+    const successCount = stats?.success_count || 0;
+    const failureCount = stats?.failure_count || 0;
+    const runningCount = stats?.running_count || 0;
+    return {
+        totalRuns,
+        successCount,
+        failureCount,
+        runningCount,
+        successRate: totalRuns > 0 ? (successCount / totalRuns) * 100 : 0,
+        avgDurationMs: stats?.avg_duration_ms || 0,
+        runsToday: todayStats?.runs_today || 0,
+        runsThisWeek: weekStats?.runs_this_week || 0,
+    };
+}

package/dist/dashboard/db/schema.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Dashboard Database Schema
+ *
+ * Defines all tables for storing run history, steps, logs, and metrics.
+ */
+import type Database from 'better-sqlite3';
+export type RunStatus = 'running' | 'success' | 'failed';
+export type StepStatus = 'success' | 'failed' | 'skipped' | 'caught' | 'running';
+export type TriggerType = 'scheduled' | 'manual' | 'api';
+export type LogStream = 'stdout' | 'stderr';
+export interface RunRecord {
+    id: string;
+    routine_name: string;
+    routine_path: string | null;
+    started_at: string;
+    finished_at: string | null;
+    status: RunStatus;
+    exit_code: number | null;
+    duration_ms: number | null;
+    trigger_type: TriggerType;
+    retry_attempt: number;
+    vars_json: string | null;
+    created_at: string;
+}
+export interface RunStepRecord {
+    id: string;
+    run_id: string;
+    step_id: string;
+    step_type: string;
+    status: StepStatus;
+    exit_code: number | null;
+    duration_ms: number | null;
+    stdout: string | null;
+    stderr: string | null;
+    json_output: string | null;
+    error_code: string | null;
+    error_message: string | null;
+    created_at: string;
+}
+export interface RunLogRecord {
+    id: number;
+    run_id: string;
+    timestamp: string;
+    stream: LogStream;
+    line: string;
+    step_id: string | null;
+}
+export interface MetricRecord {
+    id: number;
+    routine_name: string;
+    period: 'hour' | 'day' | 'week';
+    period_start: string;
+    total_runs: number;
+    successful_runs: number;
+    failed_runs: number;
+    avg_duration_ms: number | null;
+    min_duration_ms: number | null;
+    max_duration_ms: number | null;
+}
+/**
+ * Initialize the database schema.
+ * Creates all tables if they don't exist.
+ */
+export declare function initSchema(db: Database.Database): void;

package/dist/dashboard/db/schema.js

@@ -0,0 +1,157 @@
+/**
+ * Dashboard Database Schema
+ *
+ * Defines all tables for storing run history, steps, logs, and metrics.
+ */
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEMA VERSION
+// ═══════════════════════════════════════════════════════════════════════════
+const SCHEMA_VERSION = 1;
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEMA INITIALIZATION
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Initialize the database schema.
+ * Creates all tables if they don't exist.
+ */
+export function initSchema(db) {
+    // Check if we need to migrate
+    const version = getSchemaVersion(db);
+    if (version === 0) {
+        // Fresh install - create all tables
+        createTables(db);
+        setSchemaVersion(db, SCHEMA_VERSION);
+    }
+    else if (version < SCHEMA_VERSION) {
+        // Run migrations
+        migrate(db, version, SCHEMA_VERSION);
+        setSchemaVersion(db, SCHEMA_VERSION);
+    }
+}
+/**
+ * Get current schema version
+ */
+function getSchemaVersion(db) {
+    try {
+        const result = db.prepare('SELECT version FROM schema_version').get();
+        return result?.version ?? 0;
+    }
+    catch {
+        // Table doesn't exist
+        return 0;
+    }
+}
+/**
+ * Set schema version
+ */
+function setSchemaVersion(db, version) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER NOT NULL
+    );
+    DELETE FROM schema_version;
+  `);
+    db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(version);
+}
+/**
+ * Create all tables
+ */
+function createTables(db) {
+    db.exec(`
+    -- ═══════════════════════════════════════════════════════════════════════
+    -- RUNS TABLE
+    -- ═══════════════════════════════════════════════════════════════════════
+    CREATE TABLE IF NOT EXISTS runs (
+      id TEXT PRIMARY KEY,
+      routine_name TEXT NOT NULL,
+      routine_path TEXT,
+      started_at TEXT NOT NULL,
+      finished_at TEXT,
+      status TEXT NOT NULL CHECK (status IN ('running', 'success', 'failed')),
+      exit_code INTEGER,
+      duration_ms INTEGER,
+      trigger_type TEXT NOT NULL CHECK (trigger_type IN ('scheduled', 'manual', 'api')),
+      retry_attempt INTEGER DEFAULT 0,
+      vars_json TEXT,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_runs_routine_name ON runs(routine_name);
+    CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+    CREATE INDEX IF NOT EXISTS idx_runs_started_at ON runs(started_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_runs_trigger_type ON runs(trigger_type);
+    CREATE INDEX IF NOT EXISTS idx_runs_routine_status ON runs(routine_name, status);
+
+    -- ═══════════════════════════════════════════════════════════════════════
+    -- RUN STEPS TABLE
+    -- ═══════════════════════════════════════════════════════════════════════
+    CREATE TABLE IF NOT EXISTS run_steps (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+      step_id TEXT NOT NULL,
+      step_type TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('success', 'failed', 'skipped', 'caught', 'running')),
+      exit_code INTEGER,
+      duration_ms INTEGER,
+      stdout TEXT,
+      stderr TEXT,
+      json_output TEXT,
+      error_code TEXT,
+      error_message TEXT,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_run_steps_run_id ON run_steps(run_id);
+
+    -- ═══════════════════════════════════════════════════════════════════════
+    -- RUN LOGS TABLE (for streaming logs)
+    -- ═══════════════════════════════════════════════════════════════════════
+    CREATE TABLE IF NOT EXISTS run_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+      timestamp TEXT NOT NULL,
+      stream TEXT NOT NULL CHECK (stream IN ('stdout', 'stderr')),
+      line TEXT NOT NULL,
+      step_id TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_run_logs_run_id ON run_logs(run_id);
+    CREATE INDEX IF NOT EXISTS idx_run_logs_timestamp ON run_logs(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_run_logs_run_id_stream ON run_logs(run_id, stream);
+
+    -- ═══════════════════════════════════════════════════════════════════════
+    -- METRICS TABLE (aggregated stats)
+    -- ═══════════════════════════════════════════════════════════════════════
+    CREATE TABLE IF NOT EXISTS metrics (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      routine_name TEXT NOT NULL,
+      period TEXT NOT NULL CHECK (period IN ('hour', 'day', 'week')),
+      period_start TEXT NOT NULL,
+      total_runs INTEGER DEFAULT 0,
+      successful_runs INTEGER DEFAULT 0,
+      failed_runs INTEGER DEFAULT 0,
+      avg_duration_ms REAL,
+      min_duration_ms INTEGER,
+      max_duration_ms INTEGER,
+      UNIQUE(routine_name, period, period_start)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_metrics_routine ON metrics(routine_name);
+    CREATE INDEX IF NOT EXISTS idx_metrics_period ON metrics(period, period_start);
+  `);
+}
+/**
+ * Run migrations between versions
+ */
+function migrate(db, fromVersion, toVersion) {
+    // Future migrations go here
+    // Example:
+    // if (fromVersion < 2 && toVersion >= 2) {
+    //   db.exec('ALTER TABLE runs ADD COLUMN new_field TEXT');
+    // }
+    // For now, just recreate tables if version mismatch
+    // In production, this would be proper migrations
+    if (fromVersion < toVersion) {
+        createTables(db);
+    }
+}