@monoes/monobrowse 1.0.0 → 1.0.1

package/src/cli/output.ts

@@ -0,0 +1,37 @@
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+} as const;
+
+class OutputFormatter {
+  private colorEnabled = process.stdout.isTTY ?? false;
+
+  private c(color: keyof typeof COLORS, text: string): string {
+    if (!this.colorEnabled) return text;
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+  }
+
+  printSuccess(message: string): void {
+    console.log(this.c('green', '✓') + ' ' + message);
+  }
+
+  printError(message: string, details?: string): void {
+    console.error(this.c('red', '✗') + ' ' + message);
+    if (details) console.error(this.c('red', '  ' + details));
+  }
+
+  printWarning(message: string): void {
+    console.warn(this.c('yellow', '⚠') + ' ' + message);
+  }
+
+  printInfo(message: string): void {
+    console.log(this.c('cyan', 'ℹ') + ' ' + message);
+  }
+}
+
+export const output = new OutputFormatter();

package/src/cli/platform.ts

@@ -0,0 +1,211 @@
+/**
+ * Browse Platform Command — Manage platform connections (LinkedIn, Instagram, X, Gemini)
+ * Sessions stored as JSON at ~/.monomind/sessions.json
+ */
+
+import { Command } from 'commander';
+import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { getAdapter } from '../index.js';
+
+const CDP_PORT = Number(process.env['MONOMIND_CDP_PORT'] ?? 9222);
+
+const SESSIONS_FILE = join(homedir(), '.monomind', 'sessions.json');
+
+interface Session {
+  id: string;          // "platform:username"
+  platform: string;
+  username: string;
+  cookies: string;     // JSON-serialized
+  userAgent: string;
+  createdAt: number;
+  lastUsedAt: number;
+}
+
+async function loadSessions(): Promise<Session[]> {
+  if (!existsSync(SESSIONS_FILE)) return [];
+  try {
+    const raw = await readFile(SESSIONS_FILE, 'utf-8');
+    return JSON.parse(raw) as Session[];
+  } catch {
+    return [];
+  }
+}
+
+async function saveSessions(sessions: Session[]): Promise<void> {
+  await mkdir(join(homedir(), '.monomind'), { recursive: true });
+  await writeFile(SESSIONS_FILE, JSON.stringify(sessions, null, 2));
+  // Restrict to owner-only (rw-------) since the file contains platform session cookies.
+  await chmod(SESSIONS_FILE, 0o600);
+}
+
+export function createPlatformCommand(): Command {
+  const cmd = new Command('platform').description('Manage platform connections');
+
+  cmd
+    .command('connect <platform>')
+    .description('Connect a platform account via browser — opens Chrome, waits for login, saves session')
+    .option('--port <number>', 'CDP port of running Chrome instance', String(CDP_PORT))
+    .option('--timeout <seconds>', 'Login timeout in seconds', '300')
+    .action(async (platform: string, opts: { port: string; timeout: string }) => {
+      const SUPPORTED = ['linkedin', 'instagram', 'x', 'gemini'];
+      if (!SUPPORTED.includes(platform)) {
+        console.error(`Unknown platform: ${platform}. Supported: ${SUPPORTED.join(', ')}`);
+        process.exit(1);
+      }
+
+      let adapter: ReturnType<typeof getAdapter>;
+      try { adapter = getAdapter(platform); } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+
+      const cdpPort = Number(opts.port);
+      const timeoutMs = Number(opts.timeout) * 1000;
+
+      // Lazy-load browser module
+      let browser: typeof import('@monoes/monobrowse');
+      try { browser = await import('@monoes/monobrowse'); } catch (err) {
+        console.error('Browser module unavailable:', err);
+        process.exit(1);
+      }
+
+      // Connect to Chrome (or launch if needed)
+      let conn: Awaited<ReturnType<typeof browser.connectToTarget>>;
+      try {
+        conn = await browser.connectToTarget(cdpPort);
+        console.log(`Connected to Chrome on port ${cdpPort}`);
+      } catch {
+        console.log(`Chrome not found on port ${cdpPort} — launching managed browser...`);
+        try {
+          const port = await browser.launchBrowser({ port: cdpPort, headless: false });
+          conn = await browser.connectToTarget(port);
+        } catch (err) {
+          console.error('Failed to connect or launch Chrome:', err);
+          process.exit(1);
+        }
+      }
+
+      const { client, sessionId: sid } = conn;
+
+      try {
+        const refs = new Map();
+
+        // Restore any existing cookies first so the user might already be logged in
+        const sessions = await loadSessions();
+        const existingSession = sessions.find(s => s.platform === platform);
+        if (existingSession?.cookies) {
+          try {
+            const cookies = JSON.parse(existingSession.cookies);
+            if (cookies.length > 0) await browser.setCookies(client, sid, cookies);
+          } catch { /* ignore */ }
+        }
+
+        // Navigate to login URL
+        console.log(`\nOpening ${platform} login page...`);
+        await browser.openUrl(client, sid, adapter.loginURL());
+
+        // Check if already logged in after cookie restore
+        const pageIface = {
+          evaluate: async <T>(expr: string) => browser.evaluateJs(client, sid, expr) as Promise<T>,
+          url: async () => browser.getCurrentUrl(client, sid).catch(() => ''),
+        };
+        let isLoggedIn = await adapter.isLoggedIn(pageIface).catch(() => false);
+
+        if (!isLoggedIn) {
+          console.log('');
+          console.log('┌──────────────────────────────────────────────────────┐');
+          console.log(`│  Please sign in to ${platform.padEnd(34)}│`);
+          console.log('│                                                      │');
+          console.log('│  Complete the login in the browser window.           │');
+          console.log(`│  Waiting up to ${Math.round(timeoutMs / 60000)} minutes for login…           │`);
+          console.log('└──────────────────────────────────────────────────────┘');
+          console.log('');
+
+          const deadline = Date.now() + timeoutMs;
+          while (Date.now() < deadline) {
+            await new Promise(r => setTimeout(r, 2000));
+            isLoggedIn = await adapter.isLoggedIn(pageIface).catch(() => false);
+            if (isLoggedIn) break;
+            // Navigate to app URL if user manually browsed away from login
+            const currentUrl = await browser.getCurrentUrl(client, sid).catch(() => '');
+            if (!currentUrl.includes(new URL(adapter.loginURL()).hostname) &&
+                !currentUrl.includes(new URL(adapter.baseURL).hostname)) {
+              await browser.openUrl(client, sid, adapter.loginURL());
+            }
+          }
+
+          if (!isLoggedIn) {
+            console.error(`\nLogin timeout after ${Math.round(timeoutMs / 1000)}s. Session not saved.`);
+            process.exit(1);
+          }
+        }
+
+        console.log('Login detected! Capturing session...');
+
+        // Capture cookies and user agent
+        const liveCookies = await browser.getCookies(client, sid).catch(() => []);
+        const userAgent = await browser.evaluateJs(client, sid, 'navigator.userAgent').catch(() => 'unknown') as string;
+        const username = await adapter.extractUsername(pageIface).catch(() => `${platform}-user`);
+
+        // Save to sessions file
+        const sessionEntry: Session = {
+          id: `${platform}:${username}`,
+          platform,
+          username: username || `${platform}-user`,
+          cookies: JSON.stringify(liveCookies),
+          userAgent: String(userAgent),
+          createdAt: existingSession?.createdAt ?? Date.now(),
+          lastUsedAt: Date.now(),
+        };
+        const idx = sessions.findIndex(s => s.platform === platform);
+        if (idx >= 0) sessions[idx] = sessionEntry; else sessions.push(sessionEntry);
+        await saveSessions(sessions);
+
+        console.log(`\n✓ Session saved: ${sessionEntry.id}`);
+        console.log(`  Cookies: ${liveCookies.length} captured`);
+        console.log(`  File: ${SESSIONS_FILE}`);
+        console.log('');
+        console.log(`Session will be automatically used by: monomind browse playbook run`);
+      } finally {
+        client.close();
+      }
+    });
+
+  cmd
+    .command('list')
+    .description('List connected platform accounts')
+    .action(async () => {
+      const sessions = await loadSessions();
+      if (sessions.length === 0) {
+        console.log('No connected accounts. Run: browse platform connect <platform>');
+        return;
+      }
+      console.log(`\n${'ID'.padEnd(40)} ${'PLATFORM'.padEnd(12)} ${'USERNAME'.padEnd(30)} LAST USED`);
+      console.log('─'.repeat(95));
+      for (const s of sessions) {
+        const lastUsed = new Date(s.lastUsedAt).toLocaleString();
+        console.log(`${s.id.padEnd(40)} ${s.platform.padEnd(12)} ${s.username.padEnd(30)} ${lastUsed}`);
+      }
+    });
+
+  cmd
+    .command('disconnect <id>')
+    .description('Remove a saved platform session')
+    .action(async (id: string) => {
+      const sessions = await loadSessions();
+      const idx = sessions.findIndex(s => s.id === id);
+      if (idx < 0) {
+        console.error(`Session not found: ${id}`);
+        console.log('Run "browse platform list" to see available sessions.');
+        process.exit(1);
+      }
+      sessions.splice(idx, 1);
+      await saveSessions(sessions);
+      console.log(`Disconnected: ${id}`);
+    });
+
+  return cmd;
+}

package/src/cli/playbook.ts

@@ -0,0 +1,280 @@
+// src/commands/browse-playbook.ts
+import { Command } from 'commander';
+import { readdir, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { readPlaybook, listPlaybookRuns, writePlaybookRun, runPlaybook } from '@monoes/monoplaybook';
+import type { PlaybookDef } from '@monoes/monoplaybook';
+import { createDefaultHandlers } from '../index.js';
+import { startDashboard } from '../index.js';
+
+export function createPlaybookCommand(): Command {
+  const cmd = new Command('playbook')
+    .alias('workflow')
+    .description('Manage browser playbooks (saved automation recipes)');
+
+  cmd
+    .command('create <name>')
+    .description('Scaffold a new playbook JSON file')
+    .option('--template <type>', 'Starter template: minimal | http | google-sheets | gmail | github | gemini-image', 'minimal')
+    .action(async (name: string, opts: { template: string }) => {
+      const dir = join(process.cwd(), '.monomind', 'playbooks');
+      await mkdir(dir, { recursive: true });
+      const file = join(dir, `${name}.json`);
+      if (existsSync(file)) {
+        console.error(`Playbook already exists: ${file}`);
+        process.exit(1);
+      }
+
+      const humanName = name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+      let def: PlaybookDef;
+
+      switch (opts.template) {
+        case 'http':
+          def = {
+            id: name, name: humanName,
+            description: 'Fetch data from an HTTP endpoint and save to file',
+            nodes: [
+              { id: 'trigger', type: 'trigger.manual', name: 'Start', config: { items: [{ data: { url: 'https://api.example.com/data' } }] } },
+              { id: 'fetch', type: 'action.http', name: 'Fetch Data', config: { url: '{{$json.url}}', method: 'GET' }, onError: 'skip' },
+              { id: 'log', type: 'action.log', name: 'Log Result', config: { label: 'result' } },
+              { id: 'save', type: 'action.save_file', name: 'Save JSON', config: { path: `./output/${name}-result.json` } },
+            ],
+            connections: [{ from: 'trigger', to: 'fetch' }, { from: 'fetch', to: 'log' }, { from: 'log', to: 'save' }],
+          };
+          break;
+
+        case 'google-sheets': {
+          const accessRef = '{{params.access_token}}';
+          def = {
+            id: name, name: humanName,
+            description: 'Read rows from Google Sheets and process them',
+            params: {
+              spreadsheet_id: { required: true, description: 'Google Sheets ID from URL' },
+              range: { default: 'Sheet1', description: 'Cell range e.g. Sheet1!A:Z' },
+              access_token: { required: true, description: 'OAuth2 access token for Google Sheets API' },
+            },
+            nodes: [
+              { id: 'trigger', type: 'trigger.manual', name: 'Start', config: {} },
+              { id: 'read', type: 'service.google_sheets', name: 'Read Sheet', config: { operation: 'read_rows', spreadsheet_id: '{{params.spreadsheet_id}}', range: '{{params.range}}', access_token: accessRef } },
+              { id: 'log', type: 'action.log', name: 'Log Rows', config: { label: 'row' } },
+            ],
+            connections: [{ from: 'trigger', to: 'read' }, { from: 'read', to: 'log' }],
+          };
+          break;
+        }
+
+        case 'gmail': {
+          const gmailAccessRef = '{{params.access_token}}';
+          def = {
+            id: name, name: humanName,
+            description: 'Send emails via Gmail API',
+            params: {
+              to: { required: true, description: 'Recipient email address' },
+              subject: { required: true, description: 'Email subject line' },
+              body: { required: true, description: 'Email body text' },
+              access_token: { required: true, description: 'OAuth2 access token for Gmail API' },
+            },
+            nodes: [
+              { id: 'trigger', type: 'trigger.manual', name: 'Start', config: { items: [{ data: {} }] } },
+              { id: 'send', type: 'service.gmail', name: 'Send Email', config: { operation: 'send_message', to: '{{params.to}}', subject: '{{params.subject}}', body: '{{params.body}}', access_token: gmailAccessRef } },
+              { id: 'log', type: 'action.log', name: 'Log Result', config: { label: 'sent' } },
+            ],
+            connections: [{ from: 'trigger', to: 'send' }, { from: 'send', to: 'log' }],
+          };
+          break;
+        }
+
+        case 'github': {
+          const ghTokenRef = '{{params.gh_token}}';
+          def = {
+            id: name, name: humanName,
+            description: 'List GitHub issues and process them',
+            params: {
+              owner: { required: true, description: 'GitHub repo owner (user or org)' },
+              repo: { required: true, description: 'GitHub repo name' },
+              gh_token: { required: true, description: 'GitHub personal access token' },
+              state: { default: 'open', description: 'Issue state: open | closed | all' },
+            },
+            nodes: [
+              { id: 'trigger', type: 'trigger.manual', name: 'Start', config: { items: [{ data: {} }] } },
+              { id: 'issues', type: 'service.github', name: 'List Issues', config: { operation: 'list_issues', owner: '{{params.owner}}', repo: '{{params.repo}}', token: ghTokenRef, state: '{{params.state}}' } },
+              { id: 'log', type: 'action.log', name: 'Log Issues', config: { label: 'issue' } },
+            ],
+            connections: [{ from: 'trigger', to: 'issues' }, { from: 'issues', to: 'log' }],
+          };
+          break;
+        }
+
+        case 'gemini-image':
+          def = {
+            id: name, name: humanName,
+            description: 'Generate images using Gemini via browser or API',
+            params: { prompt: { required: true, description: 'Image generation prompt' } },
+            nodes: [
+              { id: 'trigger', type: 'trigger.manual', name: 'Start', config: { items: [{ data: {} }] } },
+              { id: 'generate', type: 'action.gemini_image', name: 'Generate Image', config: { prompt: '{{params.prompt}}', outputPath: `./output/${name}.png` }, onError: 'skip' },
+              { id: 'log', type: 'action.log', name: 'Log Result', config: { label: 'generated' } },
+            ],
+            connections: [{ from: 'trigger', to: 'generate' }, { from: 'generate', to: 'log' }],
+          };
+          break;
+
+        default: // minimal
+          def = {
+            id: name, name: humanName,
+            description: 'New playbook',
+            nodes: [
+              { id: 'trigger', type: 'trigger.manual', name: 'Start', config: { items: [{ data: { message: 'hello' } }] } },
+              { id: 'log', type: 'action.log', name: 'Log', config: { label: name } },
+            ],
+            connections: [{ from: 'trigger', to: 'log' }],
+          };
+      }
+
+      await writeFile(file, JSON.stringify(def, null, 2));
+      console.log(`Created: ${file}`);
+      console.log(`Template: ${opts.template}`);
+      if (def.params) {
+        console.log(`Params: ${Object.entries(def.params).map(([k, v]) => `${k}${v.required ? ' (required)' : ''}`).join(', ')}`);
+      }
+      console.log(`Run with: npx monomind browse playbook run ${file}`);
+    });
+
+  cmd
+    .command('run <file>')
+    .description('Execute a playbook and open the dashboard')
+    .option('--port <number>', 'Dashboard port (default: MONOBROWSE_DASHBOARD_PORT or 4242)', '4242')
+    .option('--no-keep', 'Exit immediately after run instead of keeping dashboard alive')
+    .option('--params <pairs...>', 'Playbook params as key=value pairs e.g. --params name=Alice count=5')
+    .option('--timeout <seconds>', 'Max run time in seconds (default: 900)', '900')
+    .action(async (file: string, opts: { port: string; keep: boolean; params?: string[]; timeout: string }) => {
+      const filePath = resolve(file);
+      let def: PlaybookDef;
+      try {
+        def = await readPlaybook(filePath);
+      } catch (err) {
+        console.error(`Failed to load playbook: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+
+      // Parse --params key=value pairs
+      const params: Record<string, string> = {};
+      for (const pair of opts.params ?? []) {
+        const eq = pair.indexOf('=');
+        if (eq > 0) params[pair.slice(0, eq)] = pair.slice(eq + 1);
+      }
+
+      // Validate required params
+      if (def.params) {
+        for (const [key, spec] of Object.entries(def.params)) {
+          if (spec.required && !(key in params) && spec.default === undefined) {
+            console.error(`Missing required playbook param: ${key}${spec.description ? ` (${spec.description})` : ''}`);
+            process.exit(1);
+          }
+          // Apply defaults
+          if (!(key in params) && spec.default !== undefined) {
+            params[key] = String(spec.default);
+          }
+        }
+      }
+
+      const port = parseInt(process.env['MONOBROWSE_DASHBOARD_PORT'] ?? opts.port, 10);
+      const dashboard = startDashboard(port);
+      console.log(`Dashboard: http://localhost:${dashboard.port}`);
+      console.log(`Running: ${def.name}`);
+      if (Object.keys(params).length > 0) {
+        console.log(`Params: ${JSON.stringify(params)}`);
+      }
+
+      const timeoutMs = parseInt(opts.timeout, 10) * 1000;
+      // Resolve the project directory once so every event carries the same canonical tag.
+      const projectDir = process.cwd();
+      const record = await runPlaybook(def, {
+        handlers: createDefaultHandlers(),
+        onEvent: event => {
+          dashboard.broadcast({ ...event, projectDir });
+          if (event.eventType === 'step_completed' || event.eventType === 'step_failed') {
+            const status = event.eventType === 'step_completed' ? '✓' : '✗';
+            console.log(`  ${status} ${event.nodeName}${event.durationMs ? ` (${event.durationMs}ms)` : ''}`);
+          }
+        },
+        signal: AbortSignal.timeout(timeoutMs),
+        params,
+        isStopRequested: (id) => dashboard.isStopRequested(id),
+      });
+
+      dashboard.addRunRecord(record);
+      await writePlaybookRun(record);
+      console.log(`\nCompleted: ${record.status} — ${record.itemsProcessed} items`);
+      if (record.error) console.error(`Error: ${record.error}`);
+
+      if (opts.keep !== false) {
+        console.log(`\nDashboard kept alive at http://localhost:${dashboard.port} — press Ctrl+C to exit`);
+        process.on('SIGINT', () => { dashboard.close(); process.exit(0); });
+        process.on('SIGTERM', () => { dashboard.close(); process.exit(0); });
+      } else {
+        process.exit(record.status === 'completed' ? 0 : 1);
+      }
+    });
+
+  cmd
+    .command('list')
+    .description('List available playbooks and their last run status')
+    .action(async () => {
+      const dir = join(process.cwd(), '.monomind', 'playbooks');
+      if (!existsSync(dir)) {
+        console.log('No playbooks found. Create one with: browse playbook create <name>');
+        return;
+      }
+      const files = (await readdir(dir)).filter(f => f.endsWith('.json'));
+      if (files.length === 0) {
+        console.log('No playbooks found.');
+        return;
+      }
+      const runs = await listPlaybookRuns();
+      for (const file of files) {
+        const id = file.replace('.json', '');
+        const lastRun = runs.find(r => r.playbookId === id);
+        const status = lastRun ? `[${lastRun.status}]` : '[never run]';
+        console.log(`  ${id}  ${status}`);
+      }
+    });
+
+  cmd
+    .command('status <run-id>')
+    .description('Check the status of a specific run')
+    .action(async (runId: string) => {
+      const runs = await listPlaybookRuns();
+      const run = runs.find(r => r.id === runId);
+      if (!run) {
+        console.error(`Run not found: ${runId}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(run, null, 2));
+    });
+
+  cmd
+    .command('stop <run-id>')
+    .description('Request cancellation of a running playbook via dashboard')
+    .option('--port <number>', 'Dashboard port (default: MONOBROWSE_DASHBOARD_PORT or 4242)', '4242')
+    .action(async (runId: string, opts: { port: string }) => {
+      const port = parseInt(process.env['MONOBROWSE_DASHBOARD_PORT'] ?? opts.port, 10);
+      // Try to signal via HTTP POST to the dashboard server
+      try {
+        const res = await fetch(`http://127.0.0.1:${port}/stop/${runId}`, { method: 'POST' });
+        if (res.ok) {
+          console.log(`Stop requested for run: ${runId}`);
+          console.log(`Dashboard: http://localhost:${port}`);
+        } else {
+          console.error(`Dashboard returned ${res.status}. Is a playbook running on port ${port}?`);
+        }
+      } catch {
+        console.error(`Could not reach dashboard on port ${port}. Make sure the playbook is running.`);
+        console.error(`You can also use the Stop button in the dashboard: http://localhost:${port}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/cli/types.ts

@@ -0,0 +1,47 @@
+export interface CommandContext {
+  args: string[];
+  flags: ParsedFlags;
+  cwd: string;
+  interactive: boolean;
+}
+
+export interface ParsedFlags {
+  [key: string]: string | boolean | number | string[];
+  _: string[];
+}
+
+export interface Command {
+  name: string;
+  description: string;
+  aliases?: string[];
+  subcommands?: Command[];
+  options?: CommandOption[];
+  examples?: CommandExample[];
+  action?: CommandAction;
+  hidden?: boolean;
+}
+
+export interface CommandOption {
+  name: string;
+  short?: string;
+  description: string;
+  type: 'string' | 'boolean' | 'number' | 'array';
+  default?: unknown;
+  required?: boolean;
+  choices?: string[];
+  validate?: (value: unknown) => boolean | string;
+}
+
+export interface CommandExample {
+  command: string;
+  description: string;
+}
+
+export type CommandAction = (ctx: CommandContext) => Promise<CommandResult | void>;
+
+export interface CommandResult {
+  success: boolean;
+  message?: string;
+  data?: unknown;
+  exitCode?: number;
+}