monomind 1.14.6 → 1.15.0

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

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

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

@@ -0,0 +1,48 @@
+export interface WorkflowDef {
+    id: string;
+    name: string;
+    nodes: NodeDef[];
+    connections: ConnectionDef[];
+}
+export interface NodeDef {
+    id: string;
+    type: string;
+    name?: string;
+    config: Record<string, unknown>;
+    onError?: 'skip' | 'stop';
+}
+export interface ConnectionDef {
+    from: string;
+    to: string;
+    handle?: string;
+}
+export interface Item {
+    data: Record<string, unknown>;
+    binary?: string;
+}
+export type RunStatus = 'running' | 'completed' | 'failed' | 'stopped';
+export interface RunRecord {
+    id: string;
+    workflowId: string;
+    workflowName: string;
+    status: RunStatus;
+    startedAt: number;
+    completedAt?: number;
+    itemsProcessed: number;
+    itemsTotal: number;
+    error?: string;
+}
+export interface StepEvent {
+    runId: string;
+    workflowId: string;
+    workflowName: string;
+    nodeId: string;
+    nodeName: string;
+    eventType: 'run_started' | 'step_started' | 'step_completed' | 'step_failed' | 'run_completed' | 'run_stopped';
+    itemIndex?: number;
+    itemTotal?: number;
+    durationMs?: number;
+    error?: string;
+    timestamp: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/browser/workflow/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/commands/browse-action.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+export declare const browseActionCommand: Command;
+export default browseActionCommand;
+//# sourceMappingURL=browse-action.d.ts.map

package/packages/@monomind/cli/dist/src/commands/browse-action.js

@@ -0,0 +1,151 @@
+import { readdir, readFile } from 'fs/promises';
+import { join } from 'path';
+import { output } from '../output.js';
+const buildSubcommand = {
+    name: 'build',
+    description: 'AI-powered: open a URL, analyze DOM, generate an action JSON file',
+    options: [
+        { name: 'url', short: 'u', type: 'string', description: 'URL to analyze', required: true },
+        { name: 'task', short: 't', type: 'string', description: 'What you want the action to do', required: true },
+        { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
+        { name: 'output', short: 'o', type: 'string', description: 'Output directory', default: '.monomind/actions' },
+    ],
+    action: async (ctx) => {
+        const url = ctx.flags.url;
+        const task = ctx.flags.task;
+        const port = ctx.flags.port ?? 9222;
+        const outDir = join(ctx.cwd, ctx.flags.output ?? '.monomind/actions');
+        if (!url || !task) {
+            output.printError('--url and --task are required');
+            return { success: false, exitCode: 1 };
+        }
+        if (!process.env.ANTHROPIC_API_KEY) {
+            output.printError('ANTHROPIC_API_KEY is not set. Required for action build.');
+            return { success: false, exitCode: 1 };
+        }
+        const spinner = output.createSpinner({ text: `Opening ${url}...`, spinner: 'dots' });
+        spinner.start();
+        try {
+            const browser = await import('@monoes/monobrowse');
+            const cdpPort = await browser.launchBrowser({ port, headless: false });
+            const { client, sessionId } = await browser.connectToTarget(cdpPort);
+            spinner.stop('Navigated. Analyzing DOM...');
+            const { analyzeAndBuild } = await import('../browser/action-builder/analyzer.js');
+            const action = await analyzeAndBuild({ url, task, client, sessionId, outputDir: outDir });
+            spinner.succeed(`Action generated: ${action.id}`);
+            output.writeln();
+            output.printBox([
+                `ID: ${action.id}`,
+                `Platform: ${action.platform}`,
+                `Steps: ${action.steps.length}`,
+                `Params: ${action.params.join(', ')}`,
+                `Saved to: ${outDir}/${action.id.replace(/[^a-z0-9_-]/gi, '_')}.json`,
+            ].join('\n'), 'Action Built');
+            client.close();
+            return { success: true, data: action };
+        }
+        catch (err) {
+            spinner.fail('Action build failed');
+            output.printError(err.message);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+const listSubcommand = {
+    name: 'list',
+    aliases: ['ls'],
+    description: 'List available actions (built-in + custom)',
+    action: async (ctx) => {
+        const customDir = join(ctx.cwd, '.monomind', 'actions');
+        let customFiles = [];
+        try {
+            customFiles = (await readdir(customDir)).filter(f => f.endsWith('.json'));
+        }
+        catch { }
+        const builtinActions = [
+            { id: 'linkedin:comment_post', platform: 'linkedin', name: 'Comment on Post', source: 'built-in' },
+            { id: 'linkedin:like_post', platform: 'linkedin', name: 'Like Post', source: 'built-in' },
+            { id: 'linkedin:send_connection', platform: 'linkedin', name: 'Send Connection Request', source: 'built-in' },
+            { id: 'linkedin:publish_post', platform: 'linkedin', name: 'Publish Post', source: 'built-in' },
+            { id: 'instagram:like_post', platform: 'instagram', name: 'Like Post', source: 'built-in' },
+            { id: 'instagram:comment_post', platform: 'instagram', name: 'Comment on Post', source: 'built-in' },
+            { id: 'instagram:follow_user', platform: 'instagram', name: 'Follow User', source: 'built-in' },
+            { id: 'x:like_post', platform: 'x', name: 'Like Post', source: 'built-in' },
+            { id: 'x:reply_post', platform: 'x', name: 'Reply to Post', source: 'built-in' },
+            { id: 'x:follow_user', platform: 'x', name: 'Follow User', source: 'built-in' },
+            { id: 'gemini:submit_prompt', platform: 'gemini', name: 'Submit Prompt', source: 'built-in' },
+        ];
+        const customActions = await Promise.all(customFiles.map(async (f) => {
+            try {
+                const raw = await readFile(join(customDir, f), 'utf8');
+                const def = JSON.parse(raw);
+                return { id: def.id, platform: def.platform ?? 'custom', name: def.name, source: 'custom' };
+            }
+            catch {
+                return null;
+            }
+        }));
+        const all = [...builtinActions, ...customActions.filter(Boolean)];
+        output.printTable({
+            columns: [
+                { key: 'id', header: 'Action ID', width: 30 },
+                { key: 'platform', header: 'Platform', width: 12 },
+                { key: 'name', header: 'Name', width: 25 },
+                { key: 'source', header: 'Source', width: 10 },
+            ],
+            data: all,
+        });
+        return { success: true };
+    },
+};
+const showSubcommand = {
+    name: 'show',
+    description: 'Print an action definition JSON',
+    action: async (ctx) => {
+        const actionId = ctx.args[0];
+        if (!actionId) {
+            output.printError('Action ID required');
+            return { success: false, exitCode: 1 };
+        }
+        const customDir = join(ctx.cwd, '.monomind', 'actions');
+        const filename = actionId.replace(/[^a-z0-9_-]/gi, '_') + '.json';
+        try {
+            const raw = await readFile(join(customDir, filename), 'utf8');
+            output.printJson(JSON.parse(raw));
+            return { success: true };
+        }
+        catch {
+            output.printError(`Action not found: ${actionId}. Check "monomind browse action list".`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+const runSubcommand = {
+    name: 'run',
+    description: 'Run a single action directly',
+    options: [
+        { name: 'account', short: 'a', type: 'string', description: 'Platform account username' },
+        { name: 'params', short: 'p', type: 'array', description: 'Params as key=value pairs' },
+        { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
+    ],
+    action: async (ctx) => {
+        output.printInfo('Direct action run is coming soon. Use workflow run to execute actions.');
+        return { success: true };
+    },
+};
+export const browseActionCommand = {
+    name: 'action',
+    description: 'Manage and run browser actions',
+    subcommands: [buildSubcommand, runSubcommand, listSubcommand, showSubcommand],
+    action: async () => {
+        output.writeln(output.bold('browse action — usage:'));
+        output.printList([
+            'monomind browse action build --url <url> --task "description"',
+            'monomind browse action list',
+            'monomind browse action show <action-id>',
+        ]);
+        return { success: true };
+    },
+};
+export default browseActionCommand;
+//# sourceMappingURL=browse-action.js.map

package/packages/@monomind/cli/dist/src/commands/browse-platform.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+export declare const browsePlatformCommand: Command;
+export default browsePlatformCommand;
+//# sourceMappingURL=browse-platform.d.ts.map

package/packages/@monomind/cli/dist/src/commands/browse-platform.js

@@ -0,0 +1,117 @@
+import { output } from '../output.js';
+const SUPPORTED_PLATFORMS = ['linkedin', 'instagram', 'x', 'gemini'];
+const connectSubcommand = {
+    name: 'connect',
+    description: 'Open browser, log in to a platform, save session',
+    options: [
+        { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
+    ],
+    action: async (ctx) => {
+        const platform = ctx.args[0];
+        if (!platform || !SUPPORTED_PLATFORMS.includes(platform)) {
+            output.printError(`Platform required: ${SUPPORTED_PLATFORMS.join(', ')}`);
+            return { success: false, exitCode: 1 };
+        }
+        const { getAdapter } = await import('../browser/adapters/index.js');
+        const { saveSession } = await import('../browser/workflow/store.js');
+        const browser = await import('@monoes/monobrowse');
+        const adapter = getAdapter(platform);
+        const port = ctx.flags.port ?? 9222;
+        output.printInfo(`Opening browser → navigating to ${adapter.loginURL()}`);
+        output.printInfo('Please log in. Detection is automatic — checking every 2s...');
+        const cdpPort = await browser.launchBrowser({ port, headless: false });
+        const { client, sessionId } = await browser.connectToTarget(cdpPort);
+        const cdpClient = client;
+        await cdpClient.send('Page.navigate', { url: adapter.loginURL() }, sessionId);
+        const page = {
+            client: cdpClient, sessionId,
+            async evaluate(fn) {
+                const result = await cdpClient.send('Runtime.evaluate', { expression: fn, returnByValue: true }, sessionId);
+                return result.result.value;
+            },
+            async url() {
+                const result = await cdpClient.send('Runtime.evaluate', { expression: 'window.location.href', returnByValue: true }, sessionId);
+                return result.result.value;
+            },
+        };
+        // Poll for login
+        let loggedIn = false;
+        for (let i = 0; i < 30; i++) {
+            await new Promise(r => setTimeout(r, 2000));
+            loggedIn = await adapter.isLoggedIn(page).catch(() => false);
+            if (loggedIn)
+                break;
+            process.stdout.write('.');
+        }
+        process.stdout.write('\n');
+        if (!loggedIn) {
+            output.printError('Login not detected after 60s. Please try again.');
+            client.close();
+            return { success: false, exitCode: 1 };
+        }
+        const username = await adapter.extractUsername(page).catch(() => 'unknown');
+        const cookieResult = await cdpClient.send('Network.getAllCookies', {}, sessionId);
+        const cookies = JSON.stringify(cookieResult.cookies);
+        const sessionId_ = `${platform}:${username}`;
+        await saveSession({ id: sessionId_, platform, username, cookies });
+        output.printSuccess(`Connected ${platform} as ${username} (session saved)`);
+        cdpClient.close();
+        return { success: true };
+    },
+};
+const listSubcommand = {
+    name: 'list',
+    aliases: ['ls'],
+    description: 'List connected platform accounts',
+    action: async () => {
+        const { listSessions } = await import('../browser/workflow/store.js');
+        const sessions = await listSessions();
+        if (sessions.length === 0) {
+            output.printInfo('No connected accounts. Use: monomind browse platform connect <platform>');
+            return { success: true };
+        }
+        output.printTable({
+            columns: [
+                { key: 'platform', header: 'Platform', width: 12 },
+                { key: 'username', header: 'Username', width: 25 },
+                { key: 'lastUsedAt', header: 'Last Used', width: 20,
+                    format: (v) => new Date(v).toLocaleString() },
+                { key: 'id', header: 'Session ID', width: 30 },
+            ],
+            data: sessions,
+        });
+        return { success: true };
+    },
+};
+const disconnectSubcommand = {
+    name: 'disconnect',
+    description: 'Remove a saved platform session',
+    action: async (ctx) => {
+        const sessionId = ctx.args[0];
+        if (!sessionId) {
+            output.printError('Session ID required. Use "monomind browse platform list" to see IDs.');
+            return { success: false, exitCode: 1 };
+        }
+        const { deleteSession } = await import('../browser/workflow/store.js');
+        await deleteSession(sessionId);
+        output.printSuccess(`Session removed: ${sessionId}`);
+        return { success: true };
+    },
+};
+export const browsePlatformCommand = {
+    name: 'platform',
+    description: 'Manage platform connections (linkedin, instagram, x, gemini)',
+    subcommands: [connectSubcommand, listSubcommand, disconnectSubcommand],
+    action: async () => {
+        output.writeln(output.bold('browse platform — usage:'));
+        output.printList([
+            'monomind browse platform connect <platform>',
+            'monomind browse platform list',
+            'monomind browse platform disconnect <session-id>',
+        ]);
+        output.writeln(`\nPlatforms: ${SUPPORTED_PLATFORMS.join(', ')}`);
+        return { success: true };
+    },
+};
+export default browsePlatformCommand;
+//# sourceMappingURL=browse-platform.js.map

package/packages/@monomind/cli/dist/src/commands/browse-workflow.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+export declare const browseWorkflowCommand: Command;
+export default browseWorkflowCommand;
+//# sourceMappingURL=browse-workflow.d.ts.map

package/packages/@monomind/cli/dist/src/commands/browse-workflow.js

@@ -0,0 +1,153 @@
+import { writeFile, mkdir } from 'fs/promises';
+import { join, resolve, isAbsolute } from 'path';
+import { output } from '../output.js';
+import { input } from '../prompt.js';
+const createSubcommand = {
+    name: 'create',
+    description: 'Scaffold a new workflow JSON file',
+    options: [
+        { name: 'output', short: 'o', type: 'string', description: 'Output directory', default: '.monomind/workflows' },
+    ],
+    action: async (ctx) => {
+        const name = ctx.args[0] ?? (ctx.interactive ? await input({ message: 'Workflow name:' }) : undefined);
+        if (!name || !/^[a-zA-Z0-9_-]{1,64}$/.test(name)) {
+            output.printError('Workflow name required (alphanumeric, dash, underscore, max 64 chars)');
+            return { success: false, exitCode: 1 };
+        }
+        const outDir = join(ctx.cwd, ctx.flags.output ?? '.monomind/workflows');
+        await mkdir(outDir, { recursive: true });
+        const filePath = join(outDir, `${name}.json`);
+        const template = {
+            id: name, name: name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+            nodes: [
+                { id: 'trigger', type: 'trigger.manual', config: {} },
+                { id: 'action1', type: 'action.linkedin.comment_post',
+                    config: { post_url: '{{$json.url}}', text: '{{$json.comment}}', account: '{{$env.LINKEDIN_USER}}' } },
+            ],
+            connections: [{ from: 'trigger', to: 'action1' }],
+        };
+        await writeFile(filePath, JSON.stringify(template, null, 2));
+        output.printSuccess(`Created ${filePath}`);
+        output.printInfo('Edit the file, then run: monomind browse workflow run ' + filePath);
+        return { success: true };
+    },
+};
+const runSubcommand = {
+    name: 'run',
+    description: 'Execute a workflow JSON file',
+    options: [
+        { name: 'no-dashboard', type: 'boolean', description: 'Skip opening web dashboard', default: false },
+        { name: 'port', type: 'number', description: 'Dashboard port', default: 4242 },
+        { name: 'items', short: 'i', type: 'string', description: 'JSON file of input items array' },
+    ],
+    action: async (ctx) => {
+        const rawPath = ctx.args[0];
+        if (!rawPath) {
+            output.printError('Workflow file required: monomind browse workflow run <file.json>');
+            return { success: false, exitCode: 1 };
+        }
+        const filePath = isAbsolute(rawPath) ? rawPath : resolve(ctx.cwd, rawPath);
+        const { readWorkflow } = await import('../browser/workflow/store.js');
+        const { runWorkflow } = await import('../browser/workflow/engine.js');
+        const { getDashboardServer } = await import('../browser/dashboard/server.js');
+        const wf = await readWorkflow(filePath).catch(e => { output.printError(e.message); return null; });
+        if (!wf)
+            return { success: false, exitCode: 1 };
+        const port = ctx.flags.port ?? 4242;
+        const dashboard = getDashboardServer(port);
+        if (!ctx.flags['no-dashboard']) {
+            output.printInfo(`Dashboard: http://localhost:${dashboard.port}`);
+            const { exec } = await import('child_process');
+            exec(`open http://localhost:${dashboard.port}`).unref();
+        }
+        output.writeln(output.bold(`Running: ${wf.name}`));
+        const spinner = output.createSpinner({ text: 'Executing...', spinner: 'dots' });
+        spinner.start();
+        const record = await runWorkflow(wf, {
+            onEvent: (ev) => dashboard.broadcast(ev),
+        });
+        if (record.status === 'completed') {
+            spinner.succeed(`Done — ${record.itemsProcessed} items in ${((record.completedAt - record.startedAt) / 1000).toFixed(1)}s`);
+        }
+        else {
+            spinner.fail(`${record.status}${record.error ? ': ' + record.error : ''}`);
+        }
+        return { success: record.status === 'completed' };
+    },
+};
+const listSubcommand = {
+    name: 'list',
+    aliases: ['ls'],
+    description: 'List recent workflow runs',
+    action: async (ctx) => {
+        const { listRuns } = await import('../browser/workflow/store.js');
+        const runs = await listRuns();
+        if (runs.length === 0) {
+            output.printInfo('No runs found');
+            return { success: true };
+        }
+        output.printTable({
+            columns: [
+                { key: 'id', header: 'Run ID', width: 12 },
+                { key: 'workflowName', header: 'Workflow', width: 20 },
+                { key: 'status', header: 'Status', width: 10 },
+                { key: 'itemsProcessed', header: 'Items', width: 8, align: 'right' },
+                { key: 'startedAt', header: 'Started', width: 20,
+                    format: (v) => new Date(v).toLocaleString() },
+            ],
+            data: runs,
+        });
+        return { success: true };
+    },
+};
+const statusSubcommand = {
+    name: 'status',
+    description: 'Show status of a specific run',
+    action: async (ctx) => {
+        const runId = ctx.args[0];
+        if (!runId) {
+            output.printError('Run ID required');
+            return { success: false, exitCode: 1 };
+        }
+        const { listRuns } = await import('../browser/workflow/store.js');
+        const runs = await listRuns();
+        const run = runs.find(r => r.id.startsWith(runId));
+        if (!run) {
+            output.printError(`Run not found: ${runId}`);
+            return { success: false, exitCode: 1 };
+        }
+        output.printBox([
+            `ID: ${run.id}`, `Workflow: ${run.workflowName}`, `Status: ${run.status}`,
+            `Items: ${run.itemsProcessed}/${run.itemsTotal}`,
+            `Started: ${new Date(run.startedAt).toLocaleString()}`,
+            run.completedAt ? `Completed: ${new Date(run.completedAt).toLocaleString()}` : '',
+            run.error ? `Error: ${run.error}` : '',
+        ].filter(Boolean).join('\n'), 'Run Status');
+        return { success: true };
+    },
+};
+const stopSubcommand = {
+    name: 'stop',
+    description: 'Stop a running workflow (sends abort signal)',
+    action: async (ctx) => {
+        output.printInfo('Stop is handled via the dashboard Stop button or Ctrl-C in the running terminal.');
+        return { success: true };
+    },
+};
+export const browseWorkflowCommand = {
+    name: 'workflow',
+    description: 'Browser workflow automation (create, run, list, status)',
+    subcommands: [createSubcommand, runSubcommand, listSubcommand, statusSubcommand, stopSubcommand],
+    action: async () => {
+        output.writeln(output.bold('browse workflow — usage:'));
+        output.printList([
+            'monomind browse workflow create <name>',
+            'monomind browse workflow run <file.json>',
+            'monomind browse workflow list',
+            'monomind browse workflow status <run-id>',
+        ]);
+        return { success: true };
+    },
+};
+export default browseWorkflowCommand;
+//# sourceMappingURL=browse-workflow.js.map

package/packages/@monomind/cli/dist/src/commands/browse.d.ts

@@ -1,8 +1,12 @@
-/**
- * Browse Command — Native browser automation via Chrome DevTools Protocol
- * Provides ref-based element model and token-efficient accessibility snapshots
- */
-import type { Command } from '../types.js';
-declare const browseCommand: Command;
+declare const browseCommand: {
+    subcommands: import("../types.js").Command[];
+    name: string;
+    description: string;
+    aliases?: string[];
+    options?: import("@monoes/monobrowse/cli/types").CommandOption[];
+    examples?: import("@monoes/monobrowse/cli/types").CommandExample[];
+    action?: import("@monoes/monobrowse/cli/types").CommandAction;
+    hidden?: boolean;
+};
 export default browseCommand;
 //# sourceMappingURL=browse.d.ts.map