@matthesketh/fleet 1.1.0 → 1.6.0

package/dist/core/routines/cost-queries.js

@@ -0,0 +1,65 @@
+function isoDaysAgo(n) {
+    return new Date(Date.now() - n * 86_400_000).toISOString();
+}
+export function costRollup(db) {
+    const windows = {
+        day: isoDaysAgo(1),
+        week: isoDaysAgo(7),
+        month: isoDaysAgo(30),
+    };
+    const stmt = db.prepare(`
+    SELECT COALESCE(SUM(c.usd), 0) AS usd, COUNT(DISTINCT r.run_id) AS runs
+    FROM routine_runs r
+    LEFT JOIN routine_cost c ON c.run_id = r.run_id
+    WHERE r.started_at >= ?
+  `);
+    const dayRow = stmt.get(windows.day);
+    const weekRow = stmt.get(windows.week);
+    const monthRow = stmt.get(windows.month);
+    return {
+        usdToday: dayRow.usd,
+        usdWeek: weekRow.usd,
+        usdMonth: monthRow.usd,
+        runsToday: dayRow.runs,
+        runsWeek: weekRow.runs,
+        runsMonth: monthRow.runs,
+    };
+}
+export function costByRoutine(db, days = 30, limit = 20) {
+    const since = isoDaysAgo(days);
+    const rows = db.prepare(`
+    SELECT r.routine_id AS routineId,
+           COUNT(DISTINCT r.run_id) AS runs,
+           COALESCE(SUM(c.usd), 0) AS usd,
+           COALESCE(SUM(c.input_tokens), 0) AS inputTokens,
+           COALESCE(SUM(c.output_tokens), 0) AS outputTokens
+    FROM routine_runs r
+    LEFT JOIN routine_cost c ON c.run_id = r.run_id
+    WHERE r.started_at >= ?
+    GROUP BY r.routine_id
+    ORDER BY usd DESC
+    LIMIT ?
+  `).all(since, limit);
+    return rows;
+}
+export function dailyCostSeries(db, days = 14) {
+    const buckets = [];
+    const now = new Date();
+    for (let i = days - 1; i >= 0; i--) {
+        const day = new Date(now.getFullYear(), now.getMonth(), now.getDate() - i);
+        const start = day.toISOString();
+        const end = new Date(day.getTime() + 86_400_000).toISOString();
+        const row = db.prepare(`
+      SELECT COALESCE(SUM(c.usd), 0) AS usd, COUNT(DISTINCT r.run_id) AS runs
+      FROM routine_runs r
+      LEFT JOIN routine_cost c ON c.run_id = r.run_id
+      WHERE r.started_at >= ? AND r.started_at < ?
+    `).get(start, end);
+        buckets.push({
+            date: day.toISOString().slice(0, 10),
+            usd: row.usd,
+            runs: row.runs,
+        });
+    }
+    return buckets;
+}

package/dist/core/routines/db.d.ts

@@ -0,0 +1,9 @@
+import Database from 'better-sqlite3';
+export interface OpenOptions {
+    path?: string;
+    readonly?: boolean;
+}
+export declare function openDb(opts?: OpenOptions): Database.Database;
+export declare function closeDb(): void;
+export declare function dbPath(): string;
+export declare function currentSchemaVersion(): number;

package/dist/core/routines/db.js

@@ -0,0 +1,126 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Database from 'better-sqlite3';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_DB_PATH = join(__dirname, '..', '..', '..', 'data', 'fleet.db');
+let _db = null;
+let _currentPath = null;
+const SCHEMA = Object.freeze([
+    `CREATE TABLE IF NOT EXISTS schema_version (
+     version INTEGER PRIMARY KEY
+   )`,
+    `CREATE TABLE IF NOT EXISTS routine_runs (
+     run_id          TEXT PRIMARY KEY,
+     routine_id      TEXT NOT NULL,
+     target          TEXT,
+     started_at      TEXT NOT NULL,
+     ended_at        TEXT,
+     status          TEXT NOT NULL,
+     exit_code       INTEGER,
+     duration_ms     INTEGER,
+     error           TEXT,
+     runner_kind     TEXT NOT NULL,
+     scheduler_kind  TEXT NOT NULL,
+     triggered_by    TEXT NOT NULL
+   )`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_routine_started
+     ON routine_runs(routine_id, started_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_runs_status
+     ON routine_runs(status, started_at DESC)`,
+    `CREATE TABLE IF NOT EXISTS routine_run_events (
+     run_id          TEXT NOT NULL,
+     seq             INTEGER NOT NULL,
+     at              TEXT NOT NULL,
+     kind            TEXT NOT NULL,
+     payload         TEXT NOT NULL,
+     PRIMARY KEY (run_id, seq),
+     FOREIGN KEY (run_id) REFERENCES routine_runs(run_id) ON DELETE CASCADE
+   )`,
+    `CREATE TABLE IF NOT EXISTS routine_cost (
+     run_id               TEXT PRIMARY KEY,
+     input_tokens         INTEGER NOT NULL DEFAULT 0,
+     output_tokens        INTEGER NOT NULL DEFAULT 0,
+     cache_create_tokens  INTEGER NOT NULL DEFAULT 0,
+     cache_read_tokens    INTEGER NOT NULL DEFAULT 0,
+     usd                  REAL NOT NULL DEFAULT 0,
+     FOREIGN KEY (run_id) REFERENCES routine_runs(run_id) ON DELETE CASCADE
+   )`,
+    `CREATE TABLE IF NOT EXISTS signal_cache (
+     repo            TEXT NOT NULL,
+     kind            TEXT NOT NULL,
+     state           TEXT NOT NULL,
+     value           TEXT,
+     detail          TEXT NOT NULL DEFAULT '',
+     collected_at    TEXT NOT NULL,
+     ttl_ms          INTEGER NOT NULL,
+     PRIMARY KEY (repo, kind)
+   )`,
+    `CREATE TABLE IF NOT EXISTS signal_history (
+     repo            TEXT NOT NULL,
+     kind            TEXT NOT NULL,
+     state           TEXT NOT NULL,
+     value           TEXT,
+     detail          TEXT NOT NULL DEFAULT '',
+     collected_at    TEXT NOT NULL
+   )`,
+    `CREATE INDEX IF NOT EXISTS idx_signal_history
+     ON signal_history(repo, kind, collected_at DESC)`,
+]);
+const CURRENT_VERSION = 1;
+function ensureDirFor(path) {
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+function runMigrations(db) {
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    db.pragma('synchronous = NORMAL');
+    db.exec('BEGIN');
+    try {
+        for (const stmt of SCHEMA)
+            db.exec(stmt);
+        const row = db.prepare('SELECT version FROM schema_version LIMIT 1').get();
+        if (!row) {
+            db.prepare('INSERT INTO schema_version(version) VALUES (?)').run(CURRENT_VERSION);
+        }
+        else if (row.version !== CURRENT_VERSION) {
+            db.prepare('UPDATE schema_version SET version = ?').run(CURRENT_VERSION);
+        }
+        db.exec('COMMIT');
+    }
+    catch (err) {
+        db.exec('ROLLBACK');
+        throw err;
+    }
+}
+export function openDb(opts = {}) {
+    const path = opts.path ?? DEFAULT_DB_PATH;
+    if (_db && _currentPath === path)
+        return _db;
+    if (_db) {
+        _db.close();
+        _db = null;
+    }
+    ensureDirFor(path);
+    const db = new Database(path, { readonly: opts.readonly ?? false });
+    if (!opts.readonly)
+        runMigrations(db);
+    _db = db;
+    _currentPath = path;
+    return db;
+}
+export function closeDb() {
+    if (_db) {
+        _db.close();
+        _db = null;
+        _currentPath = null;
+    }
+}
+export function dbPath() {
+    return _currentPath ?? DEFAULT_DB_PATH;
+}
+export function currentSchemaVersion() {
+    return CURRENT_VERSION;
+}

package/dist/core/routines/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { Routine } from './schema.js';
+export declare function builtInDefaultRoutines(): Routine[];

package/dist/core/routines/defaults.js

@@ -0,0 +1,72 @@
+export function builtInDefaultRoutines() {
+    return [
+        {
+            id: 'nightly-audit',
+            name: 'Nightly fleet audit',
+            description: 'Runs `/auto-audit:tick` against each registered repo, capturing findings and opening PRs for high-severity fixes.',
+            schedule: { kind: 'calendar', onCalendar: '*-*-* 02:00:00', randomizedDelaySec: 600, persistent: true },
+            enabled: false,
+            targets: [],
+            perTarget: true,
+            task: {
+                kind: 'claude-cli',
+                prompt: 'Run /auto-audit:tick against this repo. Report any HIGH-severity findings as bullet points; be terse.',
+                outputFormat: 'json',
+                tokenCap: 150_000,
+                wallClockMs: 20 * 60 * 1000,
+                maxUsd: 2,
+            },
+            notify: [{ kind: 'stdout', on: 'failure', config: {} }],
+            tags: ['security', 'audit'],
+        },
+        {
+            id: 'weekly-dep-drift',
+            name: 'Weekly dep drift',
+            description: 'Detects outdated dependencies and packages >1 major behind. Produces a consolidated markdown report.',
+            schedule: { kind: 'calendar', onCalendar: 'Mon *-*-* 06:00:00', randomizedDelaySec: 300, persistent: true },
+            enabled: false,
+            targets: [],
+            perTarget: true,
+            task: {
+                kind: 'shell',
+                argv: ['npm', 'outdated', '--json'],
+                wallClockMs: 5 * 60 * 1000,
+            },
+            notify: [{ kind: 'stdout', on: 'always', config: {} }],
+            tags: ['deps'],
+        },
+        {
+            id: 'stale-pr-nag',
+            name: 'Stale PR nag',
+            description: 'Lists open PRs older than 7 days across the fleet.',
+            schedule: { kind: 'calendar', onCalendar: 'Fri *-*-* 16:00:00', randomizedDelaySec: 0, persistent: true },
+            enabled: false,
+            targets: [],
+            perTarget: true,
+            task: {
+                kind: 'shell',
+                argv: ['gh', 'pr', 'list', '--state', 'open', '--json', 'number,title,updatedAt,author,url', '--limit', '50'],
+                wallClockMs: 60_000,
+            },
+            notify: [{ kind: 'stdout', on: 'always', config: {} }],
+            tags: ['git', 'nag'],
+        },
+        {
+            id: 'deploy-readiness',
+            name: 'Deploy readiness',
+            description: 'Aggregates fleet signals into a ship/block verdict. Manual trigger only.',
+            schedule: { kind: 'manual' },
+            enabled: true,
+            targets: [],
+            perTarget: false,
+            task: {
+                kind: 'mcp-call',
+                tool: 'fleet_status',
+                args: { summary: true },
+                wallClockMs: 60_000,
+            },
+            notify: [],
+            tags: ['deploy', 'release'],
+        },
+    ];
+}

package/dist/core/routines/engine.d.ts

@@ -0,0 +1,59 @@
+import type Database from 'better-sqlite3';
+import type { NotifierAdapter, RunnerAdapter, SchedulerAdapter } from '../../adapters/types.js';
+import type { Routine, RunEvent, RunStatus } from './schema.js';
+import { RoutineStore } from './store.js';
+export type RunTrigger = 'manual' | 'scheduled' | 'api';
+export interface RunPersistencePayload {
+    runId: string;
+    routineId: string;
+    target: string | null;
+    startedAt: string;
+    endedAt?: string;
+    status: RunStatus;
+    exitCode?: number;
+    durationMs?: number;
+    error?: string;
+    runnerKind: Routine['task']['kind'];
+    schedulerKind: SchedulerAdapter['id'] | 'none';
+    triggeredBy: RunTrigger;
+}
+export interface RecentRun {
+    runId: string;
+    routineId: string;
+    target: string | null;
+    startedAt: string;
+    endedAt: string | null;
+    status: RunStatus;
+    exitCode: number | null;
+    durationMs: number | null;
+    error: string | null;
+    usd: number | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+}
+export interface EngineOptions {
+    store: RoutineStore;
+    db: Database.Database;
+    runners: RunnerAdapter[];
+    scheduler?: SchedulerAdapter | null;
+    notifiers?: NotifierAdapter[];
+    logsDir?: string;
+}
+export declare class RoutineEngine {
+    private readonly opts;
+    private readonly runners;
+    constructor(opts: EngineOptions);
+    get store(): RoutineStore;
+    get db(): Database.Database;
+    runOnce(routineId: string, target?: {
+        repo: string | null;
+        repoPath: string | null;
+    }, trigger?: RunTrigger, signal?: AbortSignal): AsyncIterable<RunEvent>;
+    recentRuns(routineId: string, limit?: number): RecentRun[];
+    costSinceDays(routineId: string, days?: number): {
+        usd: number;
+        runs: number;
+    };
+    register(routine: Routine): Promise<Routine>;
+    unregister(routineId: string): Promise<boolean>;
+}

package/dist/core/routines/engine.js

@@ -0,0 +1,175 @@
+import { randomUUID } from 'node:crypto';
+function initRunRow(db, p) {
+    db.prepare(`
+    INSERT INTO routine_runs (run_id, routine_id, target, started_at, status, runner_kind, scheduler_kind, triggered_by)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(p.runId, p.routineId, p.target, p.startedAt, p.status, p.runnerKind, p.schedulerKind, p.triggeredBy);
+}
+function finishRunRow(db, runId, update) {
+    db.prepare(`
+    UPDATE routine_runs
+    SET ended_at = ?, status = ?, exit_code = ?, duration_ms = ?, error = ?
+    WHERE run_id = ?
+  `).run(update.endedAt, update.status, update.exitCode, update.durationMs, update.error ?? null, runId);
+}
+function appendEvent(db, runId, seq, event) {
+    const at = 'at' in event ? event.at : new Date().toISOString();
+    db.prepare(`
+    INSERT INTO routine_run_events (run_id, seq, at, kind, payload)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(runId, seq, at, event.kind, JSON.stringify(event));
+}
+function upsertCost(db, runId, c) {
+    db.prepare(`
+    INSERT INTO routine_cost (run_id, input_tokens, output_tokens, cache_create_tokens, cache_read_tokens, usd)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(run_id) DO UPDATE SET
+      input_tokens = excluded.input_tokens,
+      output_tokens = excluded.output_tokens,
+      cache_create_tokens = excluded.cache_create_tokens,
+      cache_read_tokens = excluded.cache_read_tokens,
+      usd = excluded.usd
+  `).run(runId, c.inputTokens, c.outputTokens, c.cacheCreateTokens, c.cacheReadTokens, c.usd);
+}
+export class RoutineEngine {
+    opts;
+    runners;
+    constructor(opts) {
+        this.opts = opts;
+        this.runners = new Map(opts.runners.map(r => [r.id, r]));
+    }
+    get store() {
+        return this.opts.store;
+    }
+    get db() {
+        return this.opts.db;
+    }
+    async *runOnce(routineId, target = { repo: null, repoPath: null }, trigger = 'manual', signal = new AbortController().signal) {
+        const routine = this.opts.store.get(routineId);
+        if (!routine)
+            throw new Error(`routine not found: ${routineId}`);
+        const runner = this.runners.get(routine.task.kind);
+        if (!runner)
+            throw new Error(`no runner registered for task kind: ${routine.task.kind}`);
+        const runId = randomUUID();
+        const startedAt = new Date().toISOString();
+        initRunRow(this.opts.db, {
+            runId,
+            routineId,
+            target: target.repo,
+            startedAt,
+            status: 'running',
+            runnerKind: routine.task.kind,
+            schedulerKind: this.opts.scheduler?.id ?? 'none',
+            triggeredBy: trigger,
+        });
+        const ctx = {
+            repo: target.repo,
+            repoPath: target.repoPath,
+            runId,
+            routineId,
+            startedAt,
+            logsDir: this.opts.logsDir ?? '/var/log/fleet',
+            env: { FLEET_ROUTINE_ID: routineId, FLEET_RUN_ID: runId },
+        };
+        let seq = 0;
+        let lastExitCode = -1;
+        let lastDurationMs = 0;
+        let lastStatus = 'failed';
+        let lastError;
+        try {
+            for await (const event of runner.run(routine.task, ctx, signal)) {
+                appendEvent(this.opts.db, runId, seq++, event);
+                if (event.kind === 'cost')
+                    upsertCost(this.opts.db, runId, event);
+                if (event.kind === 'end') {
+                    lastExitCode = event.exitCode;
+                    lastDurationMs = event.durationMs;
+                    lastStatus = event.status;
+                    lastError = event.error;
+                }
+                yield event;
+            }
+        }
+        catch (err) {
+            lastError = err.message;
+            appendEvent(this.opts.db, runId, seq++, {
+                kind: 'end',
+                status: 'failed',
+                exitCode: -1,
+                durationMs: 0,
+                at: new Date().toISOString(),
+                error: lastError,
+            });
+            lastStatus = 'failed';
+        }
+        finally {
+            finishRunRow(this.opts.db, runId, {
+                endedAt: new Date().toISOString(),
+                status: lastStatus,
+                exitCode: lastExitCode,
+                durationMs: lastDurationMs,
+                error: lastError,
+            });
+            if (this.opts.notifiers?.length) {
+                const shouldNotify = routine.notify.some(n => n.on === 'always' || (n.on === 'failure' && lastStatus !== 'ok') || (n.on === 'success' && lastStatus === 'ok'));
+                if (shouldNotify) {
+                    const subject = `fleet: ${routine.id} ${lastStatus}`;
+                    const body = `run ${runId} for ${routine.id} ended ${lastStatus} (exit=${lastExitCode}, ${lastDurationMs}ms)`;
+                    await Promise.allSettled(this.opts.notifiers.map(n => n.notify(subject, body, { routineId, runId, status: lastStatus })));
+                }
+            }
+        }
+    }
+    recentRuns(routineId, limit = 20) {
+        const rows = this.opts.db.prepare(`
+      SELECT r.run_id, r.routine_id, r.target, r.started_at, r.ended_at, r.status, r.exit_code, r.duration_ms, r.error,
+             c.usd, c.input_tokens, c.output_tokens
+      FROM routine_runs r
+      LEFT JOIN routine_cost c ON c.run_id = r.run_id
+      WHERE r.routine_id = ?
+      ORDER BY r.started_at DESC
+      LIMIT ?
+    `).all(routineId, limit);
+        return rows.map(row => ({
+            runId: row.run_id,
+            routineId: row.routine_id,
+            target: row.target,
+            startedAt: row.started_at,
+            endedAt: row.ended_at,
+            status: row.status,
+            exitCode: row.exit_code,
+            durationMs: row.duration_ms,
+            error: row.error,
+            usd: row.usd,
+            inputTokens: row.input_tokens,
+            outputTokens: row.output_tokens,
+        }));
+    }
+    costSinceDays(routineId, days = 30) {
+        const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+        const row = this.opts.db.prepare(`
+      SELECT COALESCE(SUM(c.usd), 0) AS usd, COUNT(DISTINCT c.run_id) AS runs
+      FROM routine_cost c
+      JOIN routine_runs r ON r.run_id = c.run_id
+      WHERE r.routine_id = ? AND r.started_at >= ?
+    `).get(routineId, since);
+        return { usd: row.usd, runs: row.runs };
+    }
+    async register(routine) {
+        const stored = this.opts.store.upsert(routine);
+        if (this.opts.scheduler && stored.schedule.kind !== 'manual') {
+            await this.opts.scheduler.upsert(stored);
+        }
+        return stored;
+    }
+    async unregister(routineId) {
+        if (this.opts.scheduler) {
+            try {
+                await this.opts.scheduler.remove(routineId);
+            }
+            catch { /* ignore */ }
+        }
+        return this.opts.store.remove(routineId);
+    }
+}

package/dist/core/routines/incidents.d.ts

@@ -0,0 +1,13 @@
+import type Database from 'better-sqlite3';
+export type IncidentKind = 'routine-failed' | 'routine-timeout' | 'signal-error' | 'signal-warn';
+export interface Incident {
+    at: string;
+    kind: IncidentKind;
+    subject: string;
+    detail: string;
+}
+export interface IncidentQueryOptions {
+    sinceDays?: number;
+    limit?: number;
+}
+export declare function loadIncidents(db: Database.Database, opts?: IncidentQueryOptions): Incident[];

package/dist/core/routines/incidents.js

@@ -0,0 +1,35 @@
+export function loadIncidents(db, opts = {}) {
+    const sinceDays = opts.sinceDays ?? 7;
+    const limit = opts.limit ?? 100;
+    const since = new Date(Date.now() - sinceDays * 86_400_000).toISOString();
+    const routineRows = db.prepare(`
+    SELECT started_at AS at, routine_id AS subject, status, error, target
+    FROM routine_runs
+    WHERE started_at >= ? AND status IN ('failed', 'timeout', 'aborted')
+    ORDER BY started_at DESC
+    LIMIT ?
+  `).all(since, limit);
+    const incidents = routineRows.map(r => ({
+        at: r.at,
+        kind: r.status === 'timeout' ? 'routine-timeout' : 'routine-failed',
+        subject: `${r.subject}${r.target ? ` · ${r.target}` : ''}`,
+        detail: r.error ?? r.status,
+    }));
+    const signalRows = db.prepare(`
+    SELECT collected_at AS at, repo, kind AS signal_kind, state, detail
+    FROM signal_history
+    WHERE collected_at >= ? AND state IN ('error', 'warn')
+    ORDER BY collected_at DESC
+    LIMIT ?
+  `).all(since, limit);
+    for (const row of signalRows) {
+        incidents.push({
+            at: row.at,
+            kind: row.state === 'error' ? 'signal-error' : 'signal-warn',
+            subject: `${row.repo} · ${row.signal_kind}`,
+            detail: row.detail,
+        });
+    }
+    incidents.sort((a, b) => new Date(b.at).getTime() - new Date(a.at).getTime());
+    return incidents.slice(0, limit);
+}