monomind 1.14.6 → 1.15.0

package/packages/@monomind/cli/dist/src/browser/workflow/builtin-handlers.d.ts

@@ -0,0 +1,3 @@
+import type { NodeHandler } from './engine.js';
+export declare function createBuiltinHandlers(): Map<string, NodeHandler>;
+//# sourceMappingURL=builtin-handlers.d.ts.map

package/packages/@monomind/cli/dist/src/browser/workflow/builtin-handlers.js

@@ -0,0 +1,343 @@
+// Built-in node handlers registered for every `browse workflow run` invocation.
+//
+// action.http         — fetch a URL (GET/POST/etc.) and put the response in item.data
+// action.save_file    — write item data or binaryBase64 to a file on disk
+// action.log          — console.log each item (useful for debugging workflows)
+// action.gemini_image — generate image via Gemini web app (browser automation + session store)
+//                       or Imagen REST API (GEMINI_API_KEY), or mock mode
+import { writeFile, readFile, mkdir, chmod } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+/** Resolve a user-supplied path and assert it stays within the working directory. */
+function safeResolvePath(rawPath) {
+    const cwd = process.cwd();
+    const safePath = resolve(cwd, rawPath);
+    if (safePath !== cwd && !safePath.startsWith(cwd + '/')) {
+        throw new Error(`Path traversal blocked: "${rawPath}" resolves outside working directory`);
+    }
+    return safePath;
+}
+// ---------------------------------------------------------------------------
+// Session persistence (shared format with browse-platform.ts)
+// ---------------------------------------------------------------------------
+const SESSIONS_FILE = join(homedir(), '.monomind', 'sessions.json');
+async function loadStoredSession(platform) {
+    if (!existsSync(SESSIONS_FILE))
+        return null;
+    try {
+        const sessions = JSON.parse(await readFile(SESSIONS_FILE, 'utf-8'));
+        return sessions.find(s => s.platform === platform) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveStoredSession(platform, cookies, userAgent, username) {
+    let sessions = [];
+    if (existsSync(SESSIONS_FILE)) {
+        try {
+            sessions = JSON.parse(await readFile(SESSIONS_FILE, 'utf-8'));
+        }
+        catch { /* start fresh */ }
+    }
+    const id = `${platform}:${username}`;
+    const now = Date.now();
+    const existing = sessions.findIndex(s => s.platform === platform);
+    const entry = {
+        id, platform, username, userAgent,
+        cookies: JSON.stringify(cookies),
+        createdAt: existing >= 0 ? sessions[existing].createdAt : now,
+        lastUsedAt: now,
+    };
+    if (existing >= 0)
+        sessions[existing] = entry;
+    else
+        sessions.push(entry);
+    await mkdir(join(homedir(), '.monomind'), { recursive: true });
+    await writeFile(SESSIONS_FILE, JSON.stringify(sessions, null, 2));
+    await chmod(SESSIONS_FILE, 0o600);
+}
+// ---------------------------------------------------------------------------
+// Gemini browser automation
+// ---------------------------------------------------------------------------
+const GEMINI_IMAGE_CHECK = `
+  (() => {
+    const imgs = Array.from(document.querySelectorAll('img'));
+    return imgs.some(img =>
+      img.complete && img.naturalWidth > 200 && img.naturalHeight > 200 &&
+      img.src && !img.src.includes('icon') && !img.src.includes('avatar') &&
+      !img.src.includes('logo') && !img.src.includes('profile')
+    );
+  })()
+`;
+const GEMINI_IMAGE_SRC = `
+  (() => {
+    const imgs = Array.from(document.querySelectorAll('img'));
+    const c = imgs.filter(img =>
+      img.complete && img.naturalWidth > 200 && img.naturalHeight > 200 &&
+      img.src && !img.src.includes('icon') && !img.src.includes('avatar') &&
+      !img.src.includes('logo') && !img.src.includes('profile')
+    );
+    return c.length ? c[c.length - 1].src : '';
+  })()
+`;
+// Generate an image via the Gemini web app, with session management.
+// Flow: connect → restore saved session → if not logged in, wait for user login → generate.
+// Returns the saved file path, or null if Chrome is not available.
+async function generateViaGeminiBrowser(prompt, outputPath, cdpPort) {
+    let browser;
+    try {
+        browser = await import('../index.js');
+    }
+    catch {
+        return null;
+    }
+    let conn;
+    try {
+        conn = await browser.connectToTarget(cdpPort);
+    }
+    catch {
+        return null;
+    }
+    const { client, sessionId } = conn;
+    const refs = new Map();
+    try {
+        // Restore stored Gemini session cookies before navigating
+        const stored = await loadStoredSession('gemini');
+        if (stored?.cookies) {
+            try {
+                const cookies = JSON.parse(stored.cookies);
+                if (cookies.length > 0) {
+                    await browser.setCookies(client, sessionId, cookies);
+                }
+            }
+            catch { /* ignore malformed cookies */ }
+        }
+        // Navigate to Gemini
+        await browser.openUrl(client, sessionId, 'https://gemini.google.com/app');
+        // Dismiss cookie consent if present
+        const refs2 = new Map();
+        const consentBtn = await browser.findByRole(client, sessionId, refs2, 'button', { name: 'Accept all' }).catch(() => null);
+        if (consentBtn) {
+            await browser.clickElement(client, sessionId, consentBtn);
+            await new Promise(r => setTimeout(r, 1500));
+        }
+        // Check if logged in — .ql-editor only appears when authenticated
+        let inputRef = await browser.findBySelector(client, sessionId, refs, '.ql-editor').catch(() => null);
+        if (!inputRef) {
+            // Not logged in — ask the user to authenticate
+            console.log('');
+            console.log('┌─────────────────────────────────────────────────────────┐');
+            console.log('│  Gemini login required                                  │');
+            console.log('│                                                         │');
+            console.log('│  A browser window has been opened to Gemini.            │');
+            console.log('│  Please sign in with your Google account.               │');
+            console.log('│                                                         │');
+            console.log('│  The workflow will resume automatically after login.    │');
+            console.log('│  Waiting up to 5 minutes…                               │');
+            console.log('└─────────────────────────────────────────────────────────┘');
+            console.log('');
+            // Navigate to Google sign-in
+            await browser.openUrl(client, sessionId, 'https://accounts.google.com/signin/v2/identifier');
+            // Wait up to 5 min for the user to complete login and land back on Gemini
+            const loginDeadline = Date.now() + 5 * 60 * 1000;
+            let loggedIn = false;
+            while (Date.now() < loginDeadline) {
+                await new Promise(r => setTimeout(r, 2000));
+                const url = await browser.getCurrentUrl(client, sessionId).catch(() => '');
+                if (url.includes('gemini.google.com')) {
+                    inputRef = await browser.findBySelector(client, sessionId, refs, '.ql-editor').catch(() => null);
+                    if (inputRef) {
+                        loggedIn = true;
+                        break;
+                    }
+                }
+            }
+            if (!loggedIn) {
+                console.log('[action.gemini_image] Login timeout. Run: monomind browse platform connect gemini');
+                return null;
+            }
+            console.log('[action.gemini_image] Login detected! Saving session...');
+        }
+        // Save/refresh cookies after confirming login
+        const liveCookies = await browser.getCookies(client, sessionId).catch(() => []);
+        const userAgent = await browser.evaluateJs(client, sessionId, 'navigator.userAgent').catch(() => 'unknown');
+        const username = await browser.evaluateJs(client, sessionId, "document.querySelector('.gb_A.gb_Sa')?.textContent?.trim() ?? 'gemini-user'").catch(() => 'gemini-user');
+        await saveStoredSession('gemini', liveCookies, String(userAgent), String(username));
+        // Ensure we're on the app page with the input visible
+        if (!inputRef) {
+            await browser.openUrl(client, sessionId, 'https://gemini.google.com/app');
+            inputRef = await browser.findBySelector(client, sessionId, refs, '.ql-editor').catch(() => null);
+        }
+        if (!inputRef)
+            return null;
+        // Fill and submit the prompt
+        await browser.fillElement(client, sessionId, inputRef, prompt);
+        await new Promise(r => setTimeout(r, 300));
+        await browser.pressKey(client, sessionId, 'Return');
+        console.log('[action.gemini_image] Prompt submitted to Gemini, waiting for image...');
+        // Poll up to 90s for generated image
+        const deadline = Date.now() + 90_000;
+        while (Date.now() < deadline) {
+            const found = await browser.evaluateJs(client, sessionId, GEMINI_IMAGE_CHECK).catch(() => false);
+            if (found)
+                break;
+            await new Promise(r => setTimeout(r, 500));
+        }
+        await mkdir(dirname(outputPath), { recursive: true });
+        // Extract image URL and download
+        const imgSrc = (await browser.evaluateJs(client, sessionId, GEMINI_IMAGE_SRC).catch(() => ''));
+        if (imgSrc && (imgSrc.startsWith('https://') || imgSrc.startsWith('http://'))) {
+            try {
+                const resp = await fetch(imgSrc);
+                if (resp.ok) {
+                    await writeFile(outputPath, Buffer.from(await resp.arrayBuffer()));
+                    console.log(`[action.gemini_image] Image saved → ${outputPath}`);
+                    return outputPath;
+                }
+            }
+            catch { /* fall through to screenshot */ }
+        }
+        // Fallback: screenshot the response
+        const screenshotPath = outputPath.replace(/\.(png|jpe?g|webp)$/i, '') + '-screenshot.png';
+        const ss = await browser.captureScreenshot(client, sessionId, { path: screenshotPath, fullPage: true }).catch(() => null);
+        if (ss) {
+            console.log(`[action.gemini_image] Screenshot saved → ${ss.path}`);
+            return ss.path;
+        }
+        return null;
+    }
+    finally {
+        client.close();
+    }
+}
+export function createBuiltinHandlers() {
+    const handlers = new Map();
+    // action.http
+    // config: { url, method?, headers?, body?, responseField? }
+    // Puts { statusCode, body, json? } into item.data[responseField ?? 'response']
+    handlers.set('action.http', async (items, config) => {
+        const url = String(config['url'] ?? '');
+        const method = String(config['method'] ?? 'GET').toUpperCase();
+        const headers = config['headers'] ?? {};
+        const body = config['body'] !== undefined ? JSON.stringify(config['body']) : undefined;
+        const responseField = String(config['responseField'] ?? 'response');
+        const res = await fetch(url, {
+            method,
+            headers: { 'Content-Type': 'application/json', ...headers },
+            body: method !== 'GET' && method !== 'HEAD' ? body : undefined,
+        });
+        const text = await res.text();
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch { /* not JSON */ }
+        return items.map(item => ({
+            ...item,
+            data: {
+                ...item.data,
+                [responseField]: { statusCode: res.status, body: text, json },
+            },
+        }));
+    });
+    // action.save_file
+    // config: { path, content?, field?, encoding? }
+    // Writes item.data[field] (or binaryBase64 decoded) to disk
+    handlers.set('action.save_file', async (items, config) => {
+        const results = [];
+        for (const item of items) {
+            const outPath = safeResolvePath(String(config['path'] ?? './output.txt'));
+            const field = config['field'];
+            const encoding = String(config['encoding'] ?? 'utf8');
+            await mkdir(dirname(outPath), { recursive: true });
+            if (item.binaryBase64) {
+                await writeFile(outPath, Buffer.from(item.binaryBase64, 'base64'));
+            }
+            else {
+                const content = field
+                    ? JSON.stringify(item.data[field] ?? '', null, 2)
+                    : (config['content'] ?? JSON.stringify(item.data, null, 2));
+                await writeFile(outPath, content, encoding);
+            }
+            results.push({ ...item, data: { ...item.data, savedPath: outPath } });
+        }
+        return results;
+    });
+    // action.log
+    // config: { label? }
+    handlers.set('action.log', async (items, config) => {
+        const label = String(config['label'] ?? 'action.log');
+        for (const item of items) {
+            console.log(`[${label}]`, JSON.stringify(item.data, null, 2));
+        }
+        return items;
+    });
+    // action.gemini_image
+    // config: { prompt, cdpPort?, outputPath?, apiKey?, model?, aspectRatio? }
+    // Priority: (1) Gemini web browser via CDP port 9222, (2) Imagen REST API, (3) mock
+    handlers.set('action.gemini_image', async (items, config) => {
+        const cdpPort = Number(config['cdpPort'] ?? process.env['GEMINI_CDP_PORT'] ?? 9222);
+        const apiKey = String(config['apiKey'] ?? process.env['GEMINI_API_KEY'] ?? process.env['GOOGLE_API_KEY'] ?? '');
+        const model = String(config['model'] ?? 'imagen-3.0-generate-001');
+        const aspectRatio = String(config['aspectRatio'] ?? '1:1');
+        const outputPath = config['outputPath'];
+        const results = [];
+        for (const item of items) {
+            const prompt = String(config['prompt'] ?? item.data['prompt'] ?? '');
+            const filePath = safeResolvePath(outputPath ?? `./output/gemini-image-${Date.now()}.png`);
+            // Priority 1: Browser automation via authenticated Chrome session
+            const browserPath = await generateViaGeminiBrowser(prompt, filePath, cdpPort);
+            if (browserPath) {
+                results.push({
+                    ...item,
+                    data: { ...item.data, prompt, generatedImagePath: browserPath, source: 'gemini-browser' },
+                });
+                continue;
+            }
+            // Priority 2: Gemini Imagen REST API
+            if (apiKey) {
+                console.log(`[action.gemini_image] Browser unavailable — trying Imagen REST API`);
+                const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:predict?key=${apiKey}`;
+                const res = await fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        instances: [{ prompt }],
+                        parameters: { sampleCount: 1, aspectRatio },
+                    }),
+                });
+                if (!res.ok)
+                    throw new Error(`Gemini Imagen API error ${res.status}: ${await res.text()}`);
+                const data = await res.json();
+                const prediction = data.predictions?.[0];
+                if (!prediction?.bytesBase64Encoded)
+                    throw new Error('No image data in Gemini response');
+                await mkdir(dirname(filePath), { recursive: true });
+                await writeFile(filePath, Buffer.from(prediction.bytesBase64Encoded, 'base64'));
+                results.push({
+                    ...item,
+                    data: { ...item.data, prompt, generatedImagePath: filePath, mimeType: prediction.mimeType ?? 'image/png', source: 'gemini-api' },
+                    binaryBase64: prediction.bytesBase64Encoded,
+                });
+                continue;
+            }
+            // Priority 3: Mock mode — no browser on port 9222 and no API key
+            console.log(`[action.gemini_image] No browser on port ${cdpPort} and no API key — mock mode.`);
+            console.log(`  Prompt: "${prompt}"`);
+            results.push({
+                ...item,
+                data: {
+                    ...item.data,
+                    prompt,
+                    mockMode: true,
+                    note: `Set GEMINI_CDP_PORT env var (default: 9222) for browser mode, or GEMINI_API_KEY for REST API`,
+                },
+            });
+        }
+        return results;
+    });
+    return handlers;
+}
+//# sourceMappingURL=builtin-handlers.js.map

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

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

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

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

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

@@ -0,0 +1,24 @@
+import type { WorkflowDef, RunRecord } from './types.js';
+export declare class WorkflowStoreError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+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