@monoes/monobrowse 1.0.0 → 1.0.2

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/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;
+}

package/src/cli.ts

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * monobrowse — standalone CLI entry point
+ * Dispatches to the same command tree used by `monomind browse`
+ */
+
+import { createRequire } from 'module';
+import browseCommand from './cli/commands.js';
+import { output } from './cli/output.js';
+import type { Command, CommandContext, CommandOption, ParsedFlags } from './cli/types.js';
+
+const _require = createRequire(import.meta.url);
+
+// ---------------------------------------------------------------------------
+// Subcommand lookup (supports aliases)
+// ---------------------------------------------------------------------------
+
+function findSub(name: string, subs: Command[]): Command | undefined {
+  return subs.find(s => s.name === name || s.aliases?.includes(name));
+}
+
+// ---------------------------------------------------------------------------
+// Minimal argv parser — resolves short flags from the target subcommand's opts
+// ---------------------------------------------------------------------------
+
+function buildShortMap(cmd: Command | undefined): Record<string, string> {
+  const m: Record<string, string> = {};
+  if (!cmd?.options) return m;
+  for (const opt of cmd.options) {
+    if (opt.short) m[opt.short] = opt.name;
+  }
+  return m;
+}
+
+function isBooleanOpt(name: string, cmd: Command | undefined): boolean {
+  const opt = cmd?.options?.find(o => o.name === name);
+  return opt?.type === 'boolean';
+}
+
+function parseArgv(argv: string[], sub: Command | undefined): { args: string[]; flags: ParsedFlags } {
+  const shortMap = buildShortMap(sub);
+  const flags: ParsedFlags = { _: [] };
+  const positional: string[] = [];
+  let i = 0;
+
+  while (i < argv.length) {
+    const arg = argv[i];
+
+    if (arg === '--') {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+
+    if (arg.startsWith('--')) {
+      const raw = arg.slice(2);
+      if (raw.startsWith('no-')) {
+        flags[raw.slice(3)] = false;
+      } else if (raw.includes('=')) {
+        const eq = raw.indexOf('=');
+        flags[raw.slice(0, eq)] = raw.slice(eq + 1);
+      } else if (isBooleanOpt(raw, sub) || i + 1 >= argv.length || argv[i + 1].startsWith('-')) {
+        flags[raw] = true;
+      } else {
+        flags[raw] = argv[++i];
+      }
+    } else if (arg.startsWith('-') && arg.length >= 2) {
+      const short = arg[1];
+      const long = shortMap[short] ?? short;
+      if (arg.length > 2) {
+        flags[long] = arg.slice(2);
+      } else if (isBooleanOpt(long, sub) || i + 1 >= argv.length || argv[i + 1].startsWith('-')) {
+        flags[long] = true;
+      } else {
+        flags[long] = argv[++i];
+      }
+    } else {
+      positional.push(arg);
+    }
+
+    i++;
+  }
+
+  // Coerce number options
+  for (const opt of (sub?.options ?? [])) {
+    if (opt.type === 'number' && typeof flags[opt.name] === 'string') {
+      flags[opt.name] = Number(flags[opt.name]);
+    }
+  }
+
+  return { args: positional, flags };
+}
+
+// ---------------------------------------------------------------------------
+// Help printer
+// ---------------------------------------------------------------------------
+
+function printHelp(cmd: Command, prefix = 'monobrowse'): void {
+  const usage = cmd.name === 'browse'
+    ? `${prefix} <subcommand> [options]`
+    : `${prefix} ${cmd.name} [subcommand] [options]`;
+  console.log(`\nUsage: ${usage}\n`);
+  console.log(cmd.description + '\n');
+
+  if (cmd.subcommands?.length) {
+    console.log('Subcommands:');
+    for (const s of cmd.subcommands) {
+      if (!s.hidden) console.log(`  ${s.name.padEnd(20)} ${s.description}`);
+    }
+    console.log('');
+  }
+
+  if (cmd.options?.length) {
+    console.log('Options:');
+    for (const o of cmd.options) {
+      const shortPart = o.short ? `-${o.short}, ` : '    ';
+      const defaultPart = o.default !== undefined ? ` (default: ${o.default})` : '';
+      console.log(`  ${shortPart}--${o.name.padEnd(18)} ${o.description}${defaultPart}`);
+    }
+    console.log('');
+  }
+
+  if (cmd.examples?.length) {
+    console.log('Examples:');
+    for (const ex of cmd.examples) {
+      const adjusted = ex.command.replace(/^monomind browse/, prefix);
+      console.log(`  ${adjusted}    ${ex.description}`);
+    }
+    console.log('');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Dispatch: find action and build context
+// ---------------------------------------------------------------------------
+
+async function dispatch(cmd: Command, argv: string[]): Promise<void> {
+  if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+    printHelp(cmd);
+    return;
+  }
+
+  const subName = argv[0];
+  const rest = argv.slice(1);
+
+  const sub = findSub(subName, cmd.subcommands ?? []);
+  if (!sub) {
+    output.printError(`Unknown subcommand: ${subName}`);
+    output.printInfo('Run `monobrowse --help` to see available subcommands.');
+    process.exitCode = 1;
+    return;
+  }
+
+  if (rest[0] === '--help' || rest[0] === '-h') {
+    printHelp(sub, 'monobrowse');
+    return;
+  }
+
+  // Check if first remaining arg matches a nested subcommand
+  if (sub.subcommands?.length && rest.length > 0 && !rest[0].startsWith('-')) {
+    const nested = findSub(rest[0], sub.subcommands);
+    if (nested?.action) {
+      const { args, flags } = parseArgv(rest.slice(1), nested);
+      const ctx: CommandContext = { args, flags, cwd: process.cwd(), interactive: !!process.stdout.isTTY };
+      const result = await nested.action(ctx);
+      if (result && !result.success) process.exitCode = result.exitCode ?? 1;
+      return;
+    }
+  }
+
+  // No nested match — invoke the subcommand's own action
+  if (!sub.action) {
+    output.printInfo(`Run \`monobrowse ${subName} --help\` for usage.`);
+    return;
+  }
+
+  const { args, flags } = parseArgv(rest, sub);
+  const ctx: CommandContext = { args, flags, cwd: process.cwd(), interactive: !!process.stdout.isTTY };
+  const result = await sub.action(ctx);
+  if (result && !result.success) process.exitCode = result.exitCode ?? 1;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const userArgs = process.argv.slice(2);
+
+  if (userArgs.length === 0 || userArgs[0] === '--help' || userArgs[0] === '-h') {
+    printHelp(browseCommand);
+    return;
+  }
+
+  if (userArgs[0] === '--version' || userArgs[0] === '-V') {
+    const pkg = _require('../package.json') as { version: string };
+    console.log(pkg.version);
+    return;
+  }
+
+  await dispatch(browseCommand, userArgs);
+}
+
+main().then(() => {
+  process.exit(process.exitCode ?? 0);
+}).catch(err => {
+  output.printError(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});

package/src/index.ts

@@ -1,5 +1,4 @@
 export * from './browser/index.js';
-export * from './browser/workflow/index.js';
 export * from './browser/action-builder/analyzer.js';
 export * from './browser/action-builder/types.js';
 export * from './browser/adapters/index.js';