openbroker 1.3.2 → 1.5.0

package/dist/auto/loader.js

@@ -0,0 +1,127 @@
+// Automation script loader — discovers and loads .ts automation files
+import { existsSync, readdirSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const AUTOMATIONS_DIR = path.join(os.homedir(), '.openbroker', 'automations');
+const EXAMPLES_DIR = path.join(__dirname, 'examples');
+/** Resolve a script path from a name or path */
+export function resolveScriptPath(nameOrPath) {
+    // Absolute path
+    if (path.isAbsolute(nameOrPath)) {
+        if (!existsSync(nameOrPath)) {
+            throw new Error(`Automation script not found: ${nameOrPath}`);
+        }
+        return nameOrPath;
+    }
+    // Relative to the user's original cwd (not the openbroker package root that
+    // `bin/openbroker.js` chdirs to before spawning tsx).
+    const userCwd = process.env.OPENBROKER_CWD || process.cwd();
+    const cwdPath = path.resolve(userCwd, nameOrPath);
+    if (existsSync(cwdPath))
+        return cwdPath;
+    // Relative to ~/.openbroker/automations/
+    const globalPath = path.join(AUTOMATIONS_DIR, nameOrPath);
+    if (existsSync(globalPath))
+        return globalPath;
+    // Try appending .ts
+    const withExt = path.join(AUTOMATIONS_DIR, `${nameOrPath}.ts`);
+    if (existsSync(withExt))
+        return withExt;
+    throw new Error(`Automation script not found: ${nameOrPath}\n` +
+        `Searched:\n  ${cwdPath}\n  ${globalPath}\n  ${withExt}`);
+}
+/** Resolve a bundled example by name */
+export function resolveExamplePath(name) {
+    const examplePath = path.join(EXAMPLES_DIR, `${name}.ts`);
+    if (!existsSync(examplePath)) {
+        const available = listExamples().map(e => e.name).join(', ');
+        throw new Error(`Unknown example: ${name}\nAvailable: ${available}`);
+    }
+    return examplePath;
+}
+/** List bundled example automations */
+export function listExamples() {
+    if (!existsSync(EXAMPLES_DIR))
+        return [];
+    return readdirSync(EXAMPLES_DIR)
+        .filter(f => f.endsWith('.ts') && !f.startsWith('.'))
+        .map(f => ({
+        name: f.replace(/\.ts$/, ''),
+        path: path.join(EXAMPLES_DIR, f),
+    }));
+}
+/** Load config metadata from all bundled examples */
+export async function loadExampleConfigs() {
+    const examples = listExamples();
+    const configs = {};
+    for (const example of examples) {
+        try {
+            const mod = await import(example.path);
+            const config = resolveAutomationConfig(mod);
+            if (config && typeof config === 'object' && config.description) {
+                configs[example.name] = config;
+            }
+        }
+        catch {
+            // Skip examples that fail to load
+        }
+    }
+    return configs;
+}
+function resolveAutomationFactory(mod) {
+    const candidates = [
+        mod.default,
+        mod.default?.default,
+        mod["module.exports"],
+        (mod["module.exports"]?.default)
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "function") {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveAutomationConfig(mod) {
+    const candidates = [
+        mod.config,
+        mod.default?.config,
+        mod["module.exports"]?.config
+    ];
+    for (const candidate of candidates) {
+        if (candidate && typeof candidate === "object" && "description" in candidate) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/** Load an automation module and validate the default export */
+export async function loadAutomation(scriptPath) {
+    const absolutePath = path.resolve(scriptPath);
+    // Dynamic import — tsx handles TypeScript transpilation
+    const mod = await import(absolutePath);
+    const factory = resolveAutomationFactory(mod);
+    if (typeof factory !== 'function') {
+        throw new Error(`Automation script must export a default function.\n` +
+            `Got: ${typeof factory} from ${scriptPath}`);
+    }
+    return factory;
+}
+/** List available automation scripts in ~/.openbroker/automations/ */
+export function listAutomations() {
+    if (!existsSync(AUTOMATIONS_DIR))
+        return [];
+    return readdirSync(AUTOMATIONS_DIR)
+        .filter(f => f.endsWith('.ts') && !f.startsWith('.'))
+        .map(f => ({
+        name: f.replace(/\.ts$/, ''),
+        path: path.join(AUTOMATIONS_DIR, f),
+    }));
+}
+/** Ensure the automations directory exists */
+export function ensureAutomationsDir() {
+    mkdirSync(AUTOMATIONS_DIR, { recursive: true });
+}

package/dist/auto/prune.d.ts

@@ -0,0 +1,40 @@
+import { DatabaseSync } from 'node:sqlite';
+export declare const AUDIT_DB_PATH: string;
+export interface PruneFilters {
+    /** Delete runs whose started_at < (now - olderThanMs). Falsy = no age filter. */
+    olderThanMs?: number;
+    /** Delete runs whose status is in this set. Default: stopped, error, stale. */
+    statuses?: Set<string>;
+    /** For each automation_id, keep the N most recent runs regardless of other filters. */
+    keepLastPerAutomation?: number;
+    /** Delete every run that is not currently alive (overrides status/age). */
+    all?: boolean;
+}
+export interface PruneOptions extends PruneFilters {
+    dbPath?: string;
+    dryRun?: boolean;
+    vacuum?: boolean;
+    /**
+     * When true, skip the deletion phase and only update status of orphaned
+     * 'running' rows whose pid is dead — used by `auto clean` to reconcile state
+     * without losing history.
+     */
+    reconcileOnly?: boolean;
+}
+export interface PruneResult {
+    reconciled: number;
+    candidateRunIds: string[];
+    deletedRows: Record<string, number>;
+    freedBytes: number;
+    dryRun: boolean;
+}
+/** Parse human-friendly durations like `7d`, `24h`, `30m`, `45s`. */
+export declare function parseDuration(input: string): number;
+/** Reconcile orphan-running rows in the DB (process dead → mark stopped). */
+export declare function reconcileStaleRuns(db: DatabaseSync, opts?: {
+    dryRun?: boolean;
+    now?: number;
+}): number;
+export declare function prune(opts?: PruneOptions): PruneResult;
+export declare function fmtBytes(n: number): string;
+//# sourceMappingURL=prune.d.ts.map

package/dist/auto/prune.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune.d.ts","sourceRoot":"","sources":["../../scripts/auto/prune.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,eAAO,MAAM,aAAa,QACkC,CAAC;AAE7D,MAAM,WAAW,YAAY;IAC3B,iFAAiF;IACjF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,uFAAuF;IACvF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2EAA2E;IAC3E,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB;AA6BD,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASnD;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,MAAM,CAuB1G;AAED,wBAAgB,KAAK,CAAC,IAAI,GAAE,YAAiB,GAAG,WAAW,CAgI1D;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAO1C"}

package/dist/auto/prune.js

@@ -0,0 +1,204 @@
+// Audit DB pruning — delete stale automation runs and their child rows.
+//
+// The audit DB is the same SQLite file the daemon writes to and the dashboard
+// reads from. WAL mode lets us open it from another process for delete writes
+// without blocking the daemon. We always protect runs whose status is 'running'
+// AND whose pid is alive.
+//
+// Used by: `openbroker auto prune` and as a sub-step of `openbroker auto clean`.
+import path from 'path';
+import { existsSync } from 'fs';
+import { DatabaseSync } from 'node:sqlite';
+import { ensureConfigDir } from '../core/config.js';
+export const AUDIT_DB_PATH = process.env.OPENBROKER_AUDIT_DB_PATH
+    || path.join(ensureConfigDir(), 'automation-audit.sqlite');
+const CHILD_TABLES = [
+    'automation_logs',
+    'automation_events',
+    'automation_actions',
+    'automation_snapshots',
+    'automation_order_updates',
+    'automation_fills',
+    'automation_user_events',
+    'automation_state_changes',
+    'automation_publishes',
+    'automation_errors',
+    'automation_notes',
+    'automation_metrics',
+];
+const DEFAULT_STATUSES = new Set(['stopped', 'error', 'stale']);
+function isProcessAlive(pid) {
+    if (typeof pid !== 'number' || !Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Parse human-friendly durations like `7d`, `24h`, `30m`, `45s`. */
+export function parseDuration(input) {
+    const m = /^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)?\s*$/.exec(input);
+    if (!m)
+        throw new Error(`invalid duration: ${input}`);
+    const n = Number(m[1]);
+    const unit = m[2] ?? 'ms';
+    const mult = {
+        ms: 1, s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 7 * 86_400_000,
+    };
+    return n * mult[unit];
+}
+/** Reconcile orphan-running rows in the DB (process dead → mark stopped). */
+export function reconcileStaleRuns(db, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const runningRows = db.prepare(`
+    SELECT run_id, pid FROM automation_runs WHERE status = 'running'
+  `).all();
+    const orphans = runningRows.filter((r) => !isProcessAlive(r.pid));
+    if (orphans.length === 0)
+        return 0;
+    if (opts.dryRun)
+        return orphans.length;
+    const update = db.prepare(`
+    UPDATE automation_runs
+    SET status = 'stopped',
+        stop_reason = COALESCE(stop_reason, 'reconciled (process exited)'),
+        stopped_at = COALESCE(stopped_at, ?)
+    WHERE run_id = ?
+  `);
+    let n = 0;
+    for (const o of orphans) {
+        update.run(now, o.run_id);
+        n++;
+    }
+    return n;
+}
+export function prune(opts = {}) {
+    const dbPath = opts.dbPath ?? AUDIT_DB_PATH;
+    if (!existsSync(dbPath)) {
+        return {
+            reconciled: 0,
+            candidateRunIds: [],
+            deletedRows: {},
+            freedBytes: 0,
+            dryRun: !!opts.dryRun,
+        };
+    }
+    const db = new DatabaseSync(dbPath);
+    db.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;');
+    try {
+        const reconciled = reconcileStaleRuns(db, { dryRun: opts.dryRun });
+        if (opts.reconcileOnly) {
+            return {
+                reconciled,
+                candidateRunIds: [],
+                deletedRows: {},
+                freedBytes: 0,
+                dryRun: !!opts.dryRun,
+            };
+        }
+        const allRuns = db.prepare(`
+      SELECT run_id, automation_id, status, pid, started_at
+      FROM automation_runs
+      ORDER BY started_at DESC
+    `).all();
+        const statuses = opts.statuses ?? DEFAULT_STATUSES;
+        const cutoff = opts.olderThanMs && opts.olderThanMs > 0 ? Date.now() - opts.olderThanMs : null;
+        // group runs per automation_id (already sorted DESC by started_at)
+        const byAuto = new Map();
+        for (const r of allRuns) {
+            const arr = byAuto.get(r.automation_id) ?? [];
+            arr.push(r);
+            byAuto.set(r.automation_id, arr);
+        }
+        const candidates = [];
+        for (const [, runs] of byAuto) {
+            const protectedIdx = new Set();
+            if (opts.keepLastPerAutomation && opts.keepLastPerAutomation > 0) {
+                for (let i = 0; i < Math.min(opts.keepLastPerAutomation, runs.length); i++) {
+                    protectedIdx.add(i);
+                }
+            }
+            runs.forEach((r, i) => {
+                if (protectedIdx.has(i))
+                    return;
+                // never delete a truly-running automation
+                if (r.status === 'running' && isProcessAlive(r.pid))
+                    return;
+                if (opts.all) {
+                    candidates.push(r);
+                    return;
+                }
+                if (!statuses.has(r.status)) {
+                    // 'running' rows that aren't actually alive were just reconciled to
+                    // 'stopped' above, so the status check catches them.
+                    return;
+                }
+                if (cutoff !== null && r.started_at >= cutoff)
+                    return;
+                candidates.push(r);
+            });
+        }
+        const candidateRunIds = candidates.map((r) => r.run_id);
+        const deletedRows = {};
+        let freedBytes = 0;
+        if (!opts.dryRun && candidateRunIds.length > 0) {
+            const sizeBefore = db.prepare('PRAGMA page_count').get();
+            const pageSize = db.prepare('PRAGMA page_size').get();
+            db.exec('BEGIN');
+            try {
+                for (const table of CHILD_TABLES) {
+                    let n = 0;
+                    const stmt = db.prepare(`DELETE FROM ${table} WHERE run_id = ?`);
+                    for (const id of candidateRunIds) {
+                        const info = stmt.run(id);
+                        n += Number(info.changes ?? 0);
+                    }
+                    deletedRows[table] = n;
+                }
+                const runStmt = db.prepare('DELETE FROM automation_runs WHERE run_id = ?');
+                let runChanges = 0;
+                for (const id of candidateRunIds) {
+                    const info = runStmt.run(id);
+                    runChanges += Number(info.changes ?? 0);
+                }
+                deletedRows.automation_runs = runChanges;
+                db.exec('COMMIT');
+            }
+            catch (err) {
+                db.exec('ROLLBACK');
+                throw err;
+            }
+            if (opts.vacuum) {
+                // VACUUM cannot run inside a transaction
+                db.exec('VACUUM');
+            }
+            const sizeAfter = db.prepare('PRAGMA page_count').get();
+            freedBytes = (Number(sizeBefore.page_count) - Number(sizeAfter.page_count)) * Number(pageSize.page_size);
+        }
+        return {
+            reconciled,
+            candidateRunIds,
+            deletedRows,
+            freedBytes: Math.max(0, freedBytes),
+            dryRun: !!opts.dryRun,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function fmtBytes(n) {
+    if (!Number.isFinite(n) || n <= 0)
+        return '0 B';
+    const u = ['B', 'KB', 'MB', 'GB'];
+    let i = 0;
+    let v = n;
+    while (v >= 1024 && i < u.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(v >= 100 || i === 0 ? 0 : 1)} ${u[i]}`;
+}

package/dist/auto/registry.d.ts

@@ -0,0 +1,24 @@
+export interface RegistryEntry {
+    id: string;
+    scriptPath: string;
+    dryRun: boolean;
+    verbose: boolean;
+    pollIntervalMs: number;
+    startedAt: string;
+    pid: number;
+    status: 'running' | 'stopped' | 'error';
+    error?: string;
+}
+/** Register an automation as running */
+export declare function registerAutomation(entry: Omit<RegistryEntry, 'status' | 'pid' | 'startedAt'>): void;
+/** Unregister an automation (remove from desired state) */
+export declare function unregisterAutomation(id: string): void;
+/** Mark an automation as errored (keep in registry for visibility) */
+export declare function markAutomationError(id: string, error: string): void;
+/** Get all registered automations, with stale process detection */
+export declare function getRegisteredAutomations(): RegistryEntry[];
+/** Get automations that should be restarted (were running when process died) */
+export declare function getAutomationsToRestart(): RegistryEntry[];
+/** Clean up the registry — remove stopped/errored entries */
+export declare function cleanRegistry(): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/auto/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../scripts/auto/registry.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAgCD,wCAAwC;AACxC,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,GAAG,KAAK,GAAG,WAAW,CAAC,GAAG,IAAI,CAcnG;AAED,2DAA2D;AAC3D,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAGrD;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAQnE;AAED,mEAAmE;AACnE,wBAAgB,wBAAwB,IAAI,aAAa,EAAE,CAc1D;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,IAAI,aAAa,EAAE,CAMzD;AAED,6DAA6D;AAC7D,wBAAgB,aAAa,IAAI,IAAI,CAGpC"}

package/dist/auto/registry.js

@@ -0,0 +1,93 @@
+// File-based automation registry — tracks desired state across processes
+// Persisted at ~/.openbroker/state/_registry.json so both CLI and plugin
+// can see which automations should be running.
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+const STATE_DIR = path.join(os.homedir(), '.openbroker', 'state');
+const REGISTRY_FILE = path.join(STATE_DIR, '_registry.json');
+function ensureDir() {
+    mkdirSync(STATE_DIR, { recursive: true });
+}
+function readRegistry() {
+    if (!existsSync(REGISTRY_FILE))
+        return [];
+    try {
+        const raw = readFileSync(REGISTRY_FILE, 'utf-8');
+        const entries = JSON.parse(raw);
+        return Array.isArray(entries) ? entries : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeRegistry(entries) {
+    ensureDir();
+    writeFileSync(REGISTRY_FILE, JSON.stringify(entries, null, 2));
+}
+/** Check if a process is still alive */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // Signal 0 = just check, don't kill
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Register an automation as running */
+export function registerAutomation(entry) {
+    const entries = readRegistry();
+    // Remove any existing entry with the same id
+    const filtered = entries.filter(e => e.id !== entry.id);
+    filtered.push({
+        ...entry,
+        status: 'running',
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+    });
+    writeRegistry(filtered);
+}
+/** Unregister an automation (remove from desired state) */
+export function unregisterAutomation(id) {
+    const entries = readRegistry();
+    writeRegistry(entries.filter(e => e.id !== id));
+}
+/** Mark an automation as errored (keep in registry for visibility) */
+export function markAutomationError(id, error) {
+    const entries = readRegistry();
+    const entry = entries.find(e => e.id === id);
+    if (entry) {
+        entry.status = 'error';
+        entry.error = error;
+        writeRegistry(entries);
+    }
+}
+/** Get all registered automations, with stale process detection */
+export function getRegisteredAutomations() {
+    const entries = readRegistry();
+    let dirty = false;
+    for (const entry of entries) {
+        if (entry.status === 'running' && !isProcessAlive(entry.pid)) {
+            // Process died without cleanup — mark as stopped
+            entry.status = 'stopped';
+            dirty = true;
+        }
+    }
+    if (dirty)
+        writeRegistry(entries);
+    return entries;
+}
+/** Get automations that should be restarted (were running when process died) */
+export function getAutomationsToRestart() {
+    const entries = getRegisteredAutomations();
+    // Return entries that were running but whose process is no longer alive
+    // (getRegisteredAutomations already marked them as 'stopped')
+    // We want entries that are 'stopped' — they need to be restarted
+    return entries.filter(e => e.status === 'stopped');
+}
+/** Clean up the registry — remove stopped/errored entries */
+export function cleanRegistry() {
+    const entries = readRegistry();
+    writeRegistry(entries.filter(e => e.status === 'running' && isProcessAlive(e.pid)));
+}

package/dist/auto/report.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=report.d.ts.map

package/dist/auto/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../scripts/auto/report.ts"],"names":[],"mappings":""}