npm - monomind - Versions diffs - 2.7.12 → 2.7.13 - Mend

monomind 2.7.12 → 2.7.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1159) hide show

package/packages/@monomind/cli/dist/src/browser/dashboard/ui.html DELETED Viewed

@@ -1,261 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>monobrowse dashboard</title>
-<style>
-  * { box-sizing: border-box; margin: 0; padding: 0; }
-  body { background: #0f0f1a; color: #ccc; font-family: system-ui, sans-serif; font-size: 13px; }
-  header { background: #7c3aed; padding: 10px 16px; display: flex; justify-content: space-between; align-items: center; }
-  header h1 { color: #fff; font-size: 14px; font-weight: 600; }
-  header .meta { color: rgba(255,255,255,.7); font-size: 11px; }
-  .stats { display: flex; gap: 10px; padding: 12px 16px; background: #1a1a2e; border-bottom: 1px solid #2a2a3e; }
-  .badge { border-radius: 4px; padding: 3px 10px; font-size: 11px; border: 1px solid; }
-  .badge.running { background: #22c55e22; border-color: #22c55e55; color: #22c55e; }
-  .badge.done { background: #55555522; border-color: #55555544; color: #888; }
-  .badge.failed { background: #ef444422; border-color: #ef444444; color: #ef4444; }
-  .runs { padding: 12px 16px; display: flex; flex-direction: column; gap: 10px; }
-  .run { background: #1a1a2e; border: 1px solid #2a2a3e; border-radius: 8px; padding: 12px; }
-  .run.active { border-color: #7c3aed44; }
-  .run.completed { opacity: .6; }
-  .run.failed { border-color: #ef444444; }
-  .run-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px; }
-  .run-name { font-weight: 600; color: #e2e8f0; }
-  .status-badge { font-size: 10px; padding: 1px 6px; border-radius: 3px; margin-left: 8px; }
-  .status-running { background: #7c3aed22; color: #7c3aed; }
-  .status-completed { background: #22c55e22; color: #22c55e; }
-  .status-failed { background: #ef444422; color: #ef4444; }
-  .status-stopped { background: #f59e0b22; color: #f59e0b; }
-  .run-meta { color: #555; font-size: 11px; display: flex; gap: 12px; }
-  .steps { margin-top: 8px; display: flex; flex-direction: column; gap: 3px; font-size: 11px; font-family: monospace; }
-  .step { display: flex; align-items: center; gap: 8px; }
-  .step-icon { width: 14px; flex-shrink: 0; }
-  .step-name { flex: 1; }
-  .step-time { color: #555; font-size: 10px; }
-  .step.current .step-name { color: #fff; font-weight: 600; }
-  .step.done .step-icon { color: #22c55e; }
-  .step.current .step-icon { color: #3b82f6; }
-  .step.pending .step-icon { color: #555; }
-  .step.error .step-icon { color: #ef4444; }
-  .progress-bar { height: 3px; background: #333; border-radius: 2px; margin: 6px 0 2px; }
-  .progress-fill { height: 3px; background: #3b82f6; border-radius: 2px; transition: width .3s; }
-  .log { margin-top: 8px; background: #0f0f0f; border-radius: 4px; padding: 6px 8px;
-         font-family: monospace; font-size: 10px; color: #555; line-height: 1.6; max-height: 60px; overflow: hidden; }
-  .stop-btn { background: #ef444422; border: 1px solid #ef444444; color: #ef4444;
-              border-radius: 4px; padding: 2px 8px; font-size: 10px; cursor: pointer; }
-  .empty { padding: 40px; text-align: center; color: #555; }
-  .panels { padding: 12px 16px; display: flex; flex-direction: column; gap: 10px; }
-  .panel { background: #1a1a2e; border: 1px solid #2a2a3e; border-radius: 8px; padding: 12px; }
-  .panel h2 { font-size: 12px; color: #e2e8f0; margin-bottom: 8px; text-transform: uppercase; letter-spacing: .04em; }
-  .panel .empty { padding: 10px; font-size: 11px; }
-  .kv-list { display: flex; flex-direction: column; gap: 4px; font-size: 11px; font-family: monospace; }
-  .kv-row { display: flex; justify-content: space-between; gap: 12px; color: #aaa; }
-  .kv-row b { color: #ddd; font-weight: 600; }
-  .worker-chip { display: inline-block; background: #7c3aed22; border: 1px solid #7c3aed44; color: #a78bfa;
-                 border-radius: 4px; padding: 2px 8px; font-size: 10px; margin: 2px 4px 2px 0; }
-</style>
-</head>
-<body>
-<header>
-  <h1>monobrowse dashboard</h1>
-  <span class="meta" id="meta">connecting...</span>
-</header>
-<div class="stats">
-  <span class="badge running" id="stat-running">0 running</span>
-  <span class="badge done" id="stat-done">0 done</span>
-  <span class="badge failed" id="stat-failed">0 failed</span>
-</div>
-<div class="runs" id="runs">
-  <div class="empty">No workflows running. Start one with:<br><code>monomind browse workflow run &lt;file.json&gt;</code></div>
-</div>
-<div class="panels">
-  <div class="panel">
-    <h2>Worker Metrics</h2>
-    <div id="panel-workers" class="empty">loading...</div>
-  </div>
-  <div class="panel">
-    <h2>Swarm Status</h2>
-    <div id="panel-swarm" class="empty">loading...</div>
-  </div>
-  <div class="panel">
-    <h2>Routing Info</h2>
-    <div id="panel-route" class="empty">loading...</div>
-  </div>
-</div>
-<script>
-const runs = new Map();
-const logs = new Map();
-function connect() {
-  const ws = new WebSocket(`ws://${location.host}/ws`);
-  ws.onopen = () => { document.getElementById('meta').textContent = `localhost:${location.port} · connected`; };
-  ws.onclose = () => { document.getElementById('meta').textContent = 'disconnected · reconnecting...'; setTimeout(connect, 2000); };
-  ws.onmessage = (e) => {
-    const msg = JSON.parse(e.data);
-    if (msg.type === 'init') { msg.runs?.forEach(r => runs.set(r.id, r)); render(); return; }
-    if (msg.hookType === 'route-change' || msg.hookType === 'daemon-complete') { refreshDashboard(); return; }
-    handleEvent(msg);
-  };
-}
-function escapeHtml(s) {
-  return String(s).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
-}
-async function refreshDashboard() {
-  try {
-    const res = await fetch('/api/dashboard');
-    if (!res.ok) return;
-    const data = await res.json();
-    renderDashboard(data);
-  } catch {}
-}
-function renderDashboard(data) {
-  const daemonEl = document.getElementById('panel-workers');
-  if (data.worker_metrics?.length) {
-    daemonEl.className = '';
-    daemonEl.innerHTML = data.worker_metrics.map(w => `<span class="worker-chip">${escapeHtml(w)}</span>`).join('');
-  } else {
-    daemonEl.className = 'empty';
-    daemonEl.textContent = 'No worker metrics yet. Workers run at session start (or: monomind hooks worker run map)';
-  }
-  const swarmEl = document.getElementById('panel-swarm');
-  if (data.swarm_status) {
-    swarmEl.className = '';
-    const s = data.swarm_status;
-    swarmEl.innerHTML = `<div class="kv-list">` + Object.entries(s).map(([k, v]) =>
-      `<div class="kv-row"><span>${escapeHtml(k)}</span><b>${escapeHtml(typeof v === 'object' ? JSON.stringify(v) : v)}</b></div>`
-    ).join('') + `</div>`;
-  } else {
-    swarmEl.className = 'empty';
-    swarmEl.textContent = 'No active swarm. Run: monomind swarm init';
-  }
-  const routeEl = document.getElementById('panel-route');
-  if (data.last_route) {
-    routeEl.className = '';
-    const r = data.last_route;
-    routeEl.innerHTML = `<div class="kv-list">
-      <div class="kv-row"><span>agent</span><b>${escapeHtml(r.agent ?? '—')}</b></div>
-      <div class="kv-row"><span>confidence</span><b>${escapeHtml(r.confidence ?? '—')}</b></div>
-      <div class="kv-row"><span>reason</span><b>${escapeHtml(r.reason ?? '—')}</b></div>
-      <div class="kv-row"><span>updated</span><b>${escapeHtml(r.updatedAt ?? '—')}</b></div>
-    </div>`;
-  } else {
-    routeEl.className = 'empty';
-    routeEl.textContent = 'No routing decisions yet.';
-  }
-}
-refreshDashboard();
-setInterval(refreshDashboard, 5000);
-function handleEvent(ev) {
-  if (ev.eventType === 'run_started') {
-    runs.set(ev.runId, { id: ev.runId, workflowId: ev.workflowId, workflowName: ev.workflowName,
-      status: 'running', startedAt: ev.timestamp, steps: [], currentStep: null,
-      itemsProcessed: 0, itemsTotal: ev.itemTotal ?? 0 });
-    logs.set(ev.runId, []);
-  } else if (ev.eventType === 'step_started') {
-    const run = runs.get(ev.runId);
-    if (run) { run.currentStep = ev.nodeName; addLog(ev.runId, `${ev.nodeName} → starting...`); }
-  } else if (ev.eventType === 'step_completed') {
-    const run = runs.get(ev.runId);
-    if (run) {
-      if (!run.steps) run.steps = [];
-      run.steps.push({ name: ev.nodeName, duration: ev.durationMs, status: 'done' });
-      run.currentStep = null;
-      run.itemsProcessed = ev.itemTotal ?? run.itemsProcessed;
-      addLog(ev.runId, `${ev.nodeName} ✓ (${ev.durationMs}ms)`);
-    }
-  } else if (ev.eventType === 'step_failed') {
-    const run = runs.get(ev.runId);
-    if (run) {
-      if (!run.steps) run.steps = [];
-      run.steps.push({ name: ev.nodeName, status: 'error', error: ev.error });
-      run.currentStep = null;
-      addLog(ev.runId, `${ev.nodeName} ✗ ${ev.error}`);
-    }
-  } else if (ev.eventType === 'run_completed') {
-    const run = runs.get(ev.runId);
-    if (run) { run.status = 'completed'; run.completedAt = ev.timestamp; }
-  } else if (ev.eventType === 'run_stopped') {
-    const run = runs.get(ev.runId);
-    if (run) { run.status = 'stopped'; run.completedAt = ev.timestamp; }
-  }
-  render();
-}
-function addLog(runId, msg) {
-  if (!logs.has(runId)) logs.set(runId, []);
-  const ts = new Date().toLocaleTimeString();
-  logs.get(runId).push(`${ts} ${msg}`);
-  if (logs.get(runId).length > 10) logs.get(runId).shift();
-}
-function elapsed(startedAt) {
-  const s = Math.floor((Date.now() - startedAt) / 1000);
-  return s < 60 ? `${s}s` : `${Math.floor(s/60)}m ${s%60}s`;
-}
-function render() {
-  const allRuns = [...runs.values()].sort((a,b) => b.startedAt - a.startedAt);
-  const nRunning = allRuns.filter(r => r.status === 'running').length;
-  const nDone = allRuns.filter(r => r.status === 'completed').length;
-  const nFailed = allRuns.filter(r => r.status === 'failed').length;
-  document.getElementById('stat-running').textContent = `${nRunning} running`;
-  document.getElementById('stat-done').textContent = `✓ ${nDone} done`;
-  document.getElementById('stat-failed').textContent = `✗ ${nFailed} failed`;
-  if (allRuns.length === 0) {
-    document.getElementById('runs').innerHTML = '<div class="empty">No workflows running. Start one with:<br><code>monomind browse workflow run &lt;file.json&gt;</code></div>';
-    return;
-  }
-  document.getElementById('runs').innerHTML = allRuns.map(run => {
-    const stepHtml = (run.steps || []).map(s => `
-      <div class="step ${s.status}">
-        <span class="step-icon">${s.status==='done'?'✓':s.status==='error'?'✗':'○'}</span>
-        <span class="step-name">${s.name}</span>
-        <span class="step-time">${s.duration ? s.duration+'ms' : ''}</span>
-      </div>`).join('') + (run.currentStep ? `
-      <div class="step current">
-        <span class="step-icon">⠸</span>
-        <span class="step-name">${run.currentStep}</span>
-        <span class="step-time">running</span>
-      </div>` : '');
-    const pct = run.itemsTotal > 0 ? Math.round(run.itemsProcessed / run.itemsTotal * 100) : 0;
-    const runLog = (logs.get(run.id) || []).slice(-3).join('\n');
-    return `<div class="run ${run.status==='running'?'active':run.status}">
-      <div class="run-header">
-        <div><span class="run-name">${run.workflowName}</span>
-          <span class="status-badge status-${run.status}">${run.status==='completed'?'✓ done':run.status}</span>
-        </div>
-        <div class="run-meta">
-          <span>items: ${run.itemsProcessed}/${run.itemsTotal}</span>
-          <span>elapsed: ${elapsed(run.startedAt)}</span>
-          ${run.status==='running'?'<button class="stop-btn" onclick="stopRun(\''+run.id+'\')">stop</button>':''}
-        </div>
-      </div>
-      ${run.itemsTotal > 0 ? `<div class="progress-bar"><div class="progress-fill" style="width:${pct}%"></div></div>` : ''}
-      <div class="steps">${stepHtml}</div>
-      ${runLog ? `<div class="log">${runLog}</div>` : ''}
-    </div>`;
-  }).join('');
-}
-async function stopRun(runId) {
-  await fetch(`/stop/${runId}`, { method: 'POST' }).catch(() => {});
-}
-connect();
-setInterval(render, 1000); // Update elapsed time
-</script>
-</body>
-</html>

package/packages/@monomind/cli/dist/src/browser/workflow/engine.d.ts DELETED Viewed

@@ -1,15 +0,0 @@
-import type { WorkflowDef, NodeDef, Item, RunRecord, StepEvent } from './types.js';
-export declare class DagError extends Error {
-    constructor(message: string);
-}
-export declare function buildDag(wf: WorkflowDef): string[];
-export interface RunOptions {
-    items?: Item[];
-    params?: Record<string, string>;
-    signal?: AbortSignal;
-    onEvent?: (event: StepEvent) => void;
-    executeNode?: NodeExecutor;
-}
-export type NodeExecutor = (node: NodeDef, items: Item[], nodeOutputs: Record<string, Item[]>, params: Record<string, string>, signal?: AbortSignal) => Promise<Item[]>;
-export declare function runWorkflow(wf: WorkflowDef, options?: RunOptions): Promise<RunRecord>;
-//# sourceMappingURL=engine.d.ts.map

package/packages/@monomind/cli/dist/src/browser/workflow/engine.js DELETED Viewed

@@ -1,127 +0,0 @@
-import { randomUUID } from 'crypto';
-import { resolveConfig } from './expression.js';
-import { writeRunRecord } from './store.js';
-export class DagError extends Error {
-    constructor(message) { super(message); this.name = 'DagError'; }
-}
-export function buildDag(wf) {
-    const nodeIds = new Set(wf.nodes.map(n => n.id));
-    for (const conn of wf.connections) {
-        if (!nodeIds.has(conn.from))
-            throw new DagError(`Connection references unknown node: ${conn.from}`);
-        if (!nodeIds.has(conn.to))
-            throw new DagError(`Connection references unknown node: ${conn.to}`);
-    }
-    const inDegree = new Map();
-    const adjacency = new Map();
-    for (const n of wf.nodes) {
-        inDegree.set(n.id, 0);
-        adjacency.set(n.id, []);
-    }
-    for (const conn of wf.connections) {
-        adjacency.get(conn.from).push(conn.to);
-        inDegree.set(conn.to, (inDegree.get(conn.to) ?? 0) + 1);
-    }
-    const queue = wf.nodes.filter(n => inDegree.get(n.id) === 0).map(n => n.id);
-    const order = [];
-    while (queue.length > 0) {
-        const nodeId = queue.shift();
-        order.push(nodeId);
-        for (const next of adjacency.get(nodeId) ?? []) {
-            const deg = (inDegree.get(next) ?? 1) - 1;
-            inDegree.set(next, deg);
-            if (deg === 0)
-                queue.push(next);
-        }
-    }
-    if (order.length !== wf.nodes.length)
-        throw new DagError('Workflow contains a cycle');
-    return order;
-}
-export async function runWorkflow(wf, options = {}) {
-    const runId = randomUUID();
-    const startedAt = Date.now();
-    const items = options.items ?? [{ data: {} }];
-    const params = options.params ?? {};
-    const emit = options.onEvent ?? (() => { });
-    const execute = options.executeNode ?? defaultNodeExecutor;
-    const record = {
-        id: runId,
-        workflowId: wf.id,
-        workflowName: wf.name,
-        status: 'running',
-        startedAt,
-        itemsProcessed: 0,
-        itemsTotal: items.length,
-    };
-    emit({ runId, workflowId: wf.id, workflowName: wf.name, nodeId: '', nodeName: '',
-        eventType: 'run_started', itemTotal: items.length, timestamp: Date.now() });
-    const order = buildDag(wf);
-    const nodeMap = new Map(wf.nodes.map(n => [n.id, n]));
-    const nodeOutputs = {};
-    let currentItems = items;
-    try {
-        for (const nodeId of order) {
-            if (options.signal?.aborted) {
-                record.status = 'stopped';
-                record.completedAt = Date.now();
-                emit({ runId, workflowId: wf.id, workflowName: wf.name, nodeId, nodeName: nodeId,
-                    eventType: 'run_stopped', timestamp: Date.now() });
-                await writeRunRecord(record);
-                return record;
-            }
-            const node = nodeMap.get(nodeId);
-            const stepStart = Date.now();
-            emit({ runId, workflowId: wf.id, workflowName: wf.name, nodeId, nodeName: node.name ?? nodeId,
-                eventType: 'step_started', itemTotal: currentItems.length, timestamp: stepStart });
-            try {
-                const output = await execute(node, currentItems, nodeOutputs, params, options.signal);
-                nodeOutputs[nodeId] = output;
-                record.itemsProcessed = output.length;
-                emit({ runId, workflowId: wf.id, workflowName: wf.name, nodeId, nodeName: node.name ?? nodeId,
-                    eventType: 'step_completed', durationMs: Date.now() - stepStart,
-                    itemTotal: output.length, timestamp: Date.now() });
-                if (!node.type.startsWith('trigger.'))
-                    currentItems = output;
-            }
-            catch (err) {
-                emit({ runId, workflowId: wf.id, workflowName: wf.name, nodeId, nodeName: node.name ?? nodeId,
-                    eventType: 'step_failed', error: err.message,
-                    durationMs: Date.now() - stepStart, timestamp: Date.now() });
-                if (node.onError === 'skip')
-                    continue;
-                throw err;
-            }
-        }
-        record.status = 'completed';
-        record.completedAt = Date.now();
-        emit({ runId, workflowId: wf.id, workflowName: wf.name, nodeId: '', nodeName: '',
-            eventType: 'run_completed', timestamp: Date.now() });
-    }
-    catch (err) {
-        record.status = 'failed';
-        record.error = err.message;
-        record.completedAt = Date.now();
-    }
-    await writeRunRecord(record);
-    return record;
-}
-async function defaultNodeExecutor(node, items, nodeOutputs, params) {
-    if (node.type.startsWith('trigger.'))
-        return items;
-    if (node.type === 'core.filter') {
-        const field = node.config['field'];
-        const value = node.config['value'];
-        return items.filter(item => item.data[field] === value);
-    }
-    if (node.type === 'core.set') {
-        const assignments = node.config['fields'];
-        return items.map(item => {
-            const resolved = resolveConfig(assignments, item, nodeOutputs, params);
-            return { ...item, data: { ...item.data, ...resolved } };
-        });
-    }
-    // action.* nodes — resolved by caller who passes a real executeNode
-    return items;
-}
-//# sourceMappingURL=engine.js.map

package/packages/@monomind/cli/dist/src/browser/workflow/expression.d.ts DELETED Viewed

@@ -1,4 +0,0 @@
-import type { Item } from './types.js';
-export declare function resolveExpression(template: string, item: Item, nodeOutputs: Record<string, Item[]>, params: Record<string, string>): string;
-export declare function resolveConfig(config: Record<string, unknown>, item: Item, nodeOutputs: Record<string, Item[]>, params: Record<string, string>): Record<string, unknown>;
-//# sourceMappingURL=expression.d.ts.map

package/packages/@monomind/cli/dist/src/browser/workflow/expression.js DELETED Viewed

@@ -1,64 +0,0 @@
-const TEMPLATE_RE = /\{\{([^}]+)\}\}/g;
-const cache = new Map();
-function extractTemplates(template) {
-    if (cache.has(template))
-        return cache.get(template);
-    const matches = [...template.matchAll(new RegExp(TEMPLATE_RE.source, 'g'))];
-    cache.set(template, matches);
-    return matches;
-}
-export function resolveExpression(template, item, nodeOutputs, params) {
-    const matches = extractTemplates(template);
-    if (matches.length === 0)
-        return template;
-    let result = template;
-    for (const match of matches) {
-        const expr = match[1].trim();
-        const value = resolveToken(expr, item, nodeOutputs, params);
-        result = result.replace(match[0], String(value));
-    }
-    return result;
-}
-function resolveToken(expr, item, nodeOutputs, params) {
-    if (expr.startsWith('$json.')) {
-        const key = expr.slice(6);
-        if (!(key in item.data))
-            throw new Error(`Unresolved: $json.${key} not found in item data`);
-        return item.data[key];
-    }
-    if (expr.startsWith('$env.')) {
-        const key = expr.slice(5);
-        const val = process.env[key];
-        if (val === undefined)
-            throw new Error(`Unresolved: $env.${key} not set`);
-        return val;
-    }
-    if (expr.startsWith('params.')) {
-        const key = expr.slice(7);
-        if (!(key in params))
-            throw new Error(`Unresolved: params.${key} not provided`);
-        return params[key];
-    }
-    if (expr.startsWith('$node.')) {
-        const parts = expr.slice(6).split('.');
-        const nodeId = parts[0];
-        const field = parts.slice(1).join('.');
-        const items = nodeOutputs[nodeId];
-        if (!items || items.length === 0)
-            throw new Error(`Unresolved: $node.${nodeId} has no output`);
-        const val = items[0].data[field];
-        if (val === undefined)
-            throw new Error(`Unresolved: $node.${nodeId}.${field} not found`);
-        return val;
-    }
-    // Named ref (from find step) — caller resolves these at execution time
-    return `{{${expr}}}`;
-}
-export function resolveConfig(config, item, nodeOutputs, params) {
-    const result = {};
-    for (const [k, v] of Object.entries(config)) {
-        result[k] = typeof v === 'string' ? resolveExpression(v, item, nodeOutputs, params) : v;
-    }
-    return result;
-}
-//# sourceMappingURL=expression.js.map

package/packages/@monomind/cli/dist/src/browser/workflow/store.d.ts DELETED Viewed

@@ -1,24 +0,0 @@
-import type { WorkflowDef, RunRecord } from './types.js';
-export declare class WorkflowStoreError extends Error {
-    readonly cause?: unknown;
-    constructor(message: string, cause?: unknown);
-}
-export declare function readWorkflow(filePath: string): Promise<WorkflowDef>;
-export declare function writeRunRecord(record: RunRecord): Promise<void>;
-export declare function listRuns(workflowId?: string): Promise<RunRecord[]>;
-export declare function saveSession(session: {
-    id: string;
-    platform: string;
-    username: string;
-    cookies: string;
-    userAgent?: string;
-}): Promise<void>;
-export declare function listSessions(): Promise<Array<{
-    id: string;
-    platform: string;
-    username: string;
-    lastUsedAt: number;
-}>>;
-export declare function deleteSession(id: string): Promise<void>;
-export declare function getSessionCookies(platform: string, username: string): Promise<string | null>;
-//# sourceMappingURL=store.d.ts.map

package/packages/@monomind/cli/dist/src/browser/workflow/store.js DELETED Viewed

@@ -1,145 +0,0 @@
-import { readFile, mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-export class WorkflowStoreError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = 'WorkflowStoreError';
-    }
-}
-// ── JSON file operations ──────────────────────────────────────────────────────
-export async function readWorkflow(filePath) {
-    let raw;
-    try {
-        raw = await readFile(filePath, 'utf8');
-    }
-    catch (err) {
-        const code = err.code;
-        throw new WorkflowStoreError(code === 'ENOENT' ? `Workflow file not found: ${filePath}` : `Cannot read workflow file: ${filePath}`, err);
-    }
-    try {
-        const wf = JSON.parse(raw);
-        if (!wf.id || !Array.isArray(wf.nodes) || !Array.isArray(wf.connections)) {
-            throw new Error('Missing required fields: id, nodes, connections');
-        }
-        return wf;
-    }
-    catch (err) {
-        throw new WorkflowStoreError(`Invalid workflow JSON in ${filePath}: ${err.message}`, err);
-    }
-}
-// ── SQLite run history (sql.js) ───────────────────────────────────────────────
-const DB_PATH = join(homedir(), '.monomind', 'browse.db');
-async function getDb() {
-    const { default: initSqlJs } = await import('sql.js');
-    const SQL = await initSqlJs();
-    await mkdir(join(homedir(), '.monomind'), { recursive: true });
-    let fileBuffer;
-    try {
-        fileBuffer = await readFile(DB_PATH);
-    }
-    catch {
-        // First run — no DB yet
-    }
-    const db = fileBuffer ? new SQL.Database(fileBuffer) : new SQL.Database();
-    db.run(`CREATE TABLE IF NOT EXISTS browse_runs (
-    id TEXT PRIMARY KEY,
-    workflow_id TEXT NOT NULL,
-    workflow_name TEXT NOT NULL,
-    status TEXT NOT NULL,
-    started_at INTEGER NOT NULL,
-    completed_at INTEGER,
-    items_processed INTEGER DEFAULT 0,
-    items_total INTEGER DEFAULT 0,
-    error TEXT
-  )`);
-    db.run(`CREATE TABLE IF NOT EXISTS browse_sessions (
-    id TEXT PRIMARY KEY,
-    platform TEXT NOT NULL,
-    username TEXT NOT NULL,
-    cookies TEXT NOT NULL,
-    user_agent TEXT,
-    created_at INTEGER NOT NULL,
-    last_used_at INTEGER NOT NULL
-  )`);
-    return { db, flush: async () => {
-            const data = db.export();
-            await writeFile(DB_PATH, Buffer.from(data));
-        } };
-}
-export async function writeRunRecord(record) {
-    const { db, flush } = await getDb();
-    db.run(`INSERT OR REPLACE INTO browse_runs
-     (id, workflow_id, workflow_name, status, started_at, completed_at, items_processed, items_total, error)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [record.id, record.workflowId, record.workflowName, record.status,
-        record.startedAt, record.completedAt ?? null, record.itemsProcessed,
-        record.itemsTotal, record.error ?? null]);
-    await flush();
-}
-export async function listRuns(workflowId) {
-    const { db } = await getDb();
-    const query = workflowId
-        ? db.prepare(`SELECT * FROM browse_runs WHERE workflow_id = ? ORDER BY started_at DESC LIMIT 50`)
-        : db.prepare(`SELECT * FROM browse_runs ORDER BY started_at DESC LIMIT 50`);
-    const rows = [];
-    if (workflowId)
-        query.bind([workflowId]);
-    while (query.step()) {
-        const r = query.getAsObject();
-        rows.push({
-            id: r['id'],
-            workflowId: r['workflow_id'],
-            workflowName: r['workflow_name'],
-            status: r['status'],
-            startedAt: r['started_at'],
-            completedAt: r['completed_at'],
-            itemsProcessed: r['items_processed'],
-            itemsTotal: r['items_total'],
-            error: r['error'],
-        });
-    }
-    query.free();
-    return rows;
-}
-export async function saveSession(session) {
-    const now = Date.now();
-    const { db, flush } = await getDb();
-    db.run(`INSERT OR REPLACE INTO browse_sessions
-     (id, platform, username, cookies, user_agent, created_at, last_used_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`, [session.id, session.platform, session.username, session.cookies,
-        session.userAgent ?? null, now, now]);
-    await flush();
-}
-export async function listSessions() {
-    const { db } = await getDb();
-    const query = db.prepare(`SELECT id, platform, username, last_used_at FROM browse_sessions ORDER BY last_used_at DESC`);
-    const rows = [];
-    while (query.step()) {
-        const r = query.getAsObject();
-        rows.push({ id: r['id'], platform: r['platform'],
-            username: r['username'], lastUsedAt: r['last_used_at'] });
-    }
-    query.free();
-    return rows;
-}
-export async function deleteSession(id) {
-    const { db, flush } = await getDb();
-    db.run(`DELETE FROM browse_sessions WHERE id = ?`, [id]);
-    await flush();
-}
-export async function getSessionCookies(platform, username) {
-    const { db } = await getDb();
-    const stmt = db.prepare(`SELECT cookies FROM browse_sessions WHERE platform = ? AND username = ? LIMIT 1`);
-    stmt.bind([platform, username]);
-    if (stmt.step()) {
-        const r = stmt.getAsObject();
-        stmt.free();
-        db.run(`UPDATE browse_sessions SET last_used_at = ? WHERE platform = ? AND username = ?`, [Date.now(), platform, username]);
-        return r['cookies'];
-    }
-    stmt.free();
-    return null;
-}
-//# sourceMappingURL=store.js.map