@4ier/neo 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4ier/neo",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Turn any website into an AI-callable API. Passive traffic capture, API schema generation, and execution.",
   "type": "module",
   "scripts": {

package/tools/neo.cjs

@@ -28,7 +28,7 @@
 //   neo tab                                 List CDP targets in the active session
 //   neo tab <index> | neo tab --url <pat>  Switch active tab target
 //   neo inject [--persist] [--tab pattern]  Inject Neo capture script into page target
-//   neo snapshot [-i] [-C] [--json]         Snapshot a11y tree with @ref mapping
+//   neo snapshot [-i] [-C] [--json] [--diff] Snapshot a11y tree with @ref mapping
 //   neo click @ref [--new-tab]              Click element by @ref
 //   neo fill @ref "text"                     Clear then fill element by @ref
 //   neo type @ref "text"                     Type text without clearing
@@ -58,7 +58,13 @@ const SCHEMA_DIR = process.env.NEO_SCHEMA_DIR || path.join(process.env.HOME, '.n
 const WORKFLOW_FILE_EXT = '.workflows.json';
 const SESSION_FILE = '/tmp/neo-sessions.json';
 const EXTENSION_ID_CACHE_FILE = '/tmp/neo-ext-id';
-const NEO_HOME_DIR = path.join(process.env.HOME, '.neo');
+const NEO_BASE_DIR = path.join(process.env.HOME, '.neo');
+const NEO_PROFILE = process.env.NEO_PROFILE || null;
+function getNeoHomeDir(profile) {
+  const p = profile || NEO_PROFILE;
+  return p ? path.join(NEO_BASE_DIR, 'profiles', p) : NEO_BASE_DIR;
+}
+const NEO_HOME_DIR = getNeoHomeDir();
 const NEO_CONFIG_FILE = path.join(NEO_HOME_DIR, 'config.json');
 const NEO_EXTENSION_DIR = path.join(NEO_HOME_DIR, 'extension');
 const DEFAULT_SESSION_NAME = '__default__';
@@ -2151,6 +2157,7 @@ function parseSnapshotArgs(argv) {
     interactiveOnly: false,
     includeCursorPointer: false,
     json: false,
+    diff: false,
     selector: null,
   };
   const unknown = [];
@@ -2170,6 +2177,10 @@ function parseSnapshotArgs(argv) {
       options.json = true;
       continue;
     }
+    if (current === '--diff') {
+      options.diff = true;
+      continue;
+    }
     if (current === '--selector') {
       if (args[i + 1] && !args[i + 1].startsWith('-')) {
         options.selector = args[i + 1];
@@ -2397,14 +2408,43 @@ commands.version = function() {
   console.log(`neo v${pkg.version}`);
 };
 
-// neo setup
+// neo profiles — list configured profiles
+commands.profiles = function() {
+  const profilesDir = path.join(NEO_BASE_DIR, 'profiles');
+  const profiles = [];
+  if (fs.existsSync(profilesDir)) {
+    for (const name of fs.readdirSync(profilesDir)) {
+      const configPath = path.join(profilesDir, name, 'config.json');
+      if (fs.existsSync(configPath)) {
+        profiles.push(name);
+      }
+    }
+  }
+  const defaultExists = fs.existsSync(NEO_CONFIG_FILE);
+  if (defaultExists) console.log(`  default  ${NEO_HOME_DIR}`);
+  for (const name of profiles) {
+    console.log(`  ${name.padEnd(9)} ${path.join(profilesDir, name)}`);
+  }
+  if (!defaultExists && profiles.length === 0) {
+    console.log('No profiles configured. Run neo setup to create default profile.');
+  }
+};
+
+// neo setup [--profile <name>]
 commands.setup = async function(args) {
   const { positional, flags } = parseArgs(args || []);
-  if (positional.length > 0 || Object.keys(flags).length > 0) {
-    console.error('Usage: neo setup');
+  const profileName = typeof flags.profile === 'string' ? flags.profile : null;
+  if (positional.length > 0 || (Object.keys(flags).length > 0 && !('profile' in flags))) {
+    console.error('Usage: neo setup [--profile <name>]');
     process.exit(1);
   }
 
+  // If profile specified, override home dir for this run
+  const homeDir = profileName ? getNeoHomeDir(profileName) : NEO_HOME_DIR;
+  const configFile = path.join(homeDir, 'config.json');
+  const extensionDir = path.join(homeDir, 'extension');
+  const setupSchemaDir = path.join(homeDir, 'schemas');
+
   const chromePath = detectChromeBinaryPath();
   if (!chromePath) {
     throw new Error('Chrome binary not found. Tried: google-chrome-stable, google-chrome, chromium-browser, chromium');
@@ -2412,20 +2452,20 @@ commands.setup = async function(args) {
 
   const projectRoot = path.join(fs.realpathSync(__dirname), '..');
   const extensionSourceDir = path.join(projectRoot, 'extension-dist');
-  const setupSchemaDir = path.join(NEO_HOME_DIR, 'schemas');
 
-  fs.mkdirSync(NEO_HOME_DIR, { recursive: true });
-  copyDirectoryRecursive(extensionSourceDir, NEO_EXTENSION_DIR);
+  fs.mkdirSync(homeDir, { recursive: true });
+  copyDirectoryRecursive(extensionSourceDir, extensionDir);
   fs.mkdirSync(setupSchemaDir, { recursive: true });
 
   const config = {
     chromePath,
     cdpPort: 9222,
   };
-  fs.writeFileSync(NEO_CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  if (profileName) config.profile = profileName;
+  fs.writeFileSync(configFile, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
 
   // Pre-register Neo extension in Chrome Preferences (zero-config install)
-  const profileDefaultDir = path.join(NEO_HOME_DIR, 'chrome-profile', 'Default');
+  const profileDefaultDir = path.join(homeDir, 'chrome-profile', 'Default');
   const prefsFile = path.join(profileDefaultDir, 'Preferences');
   fs.mkdirSync(profileDefaultDir, { recursive: true });
   let prefs = {};
@@ -2442,12 +2482,12 @@ commands.setup = async function(args) {
 
   // Generate deterministic extension ID from path (same algorithm Chrome uses for unpacked)
   const crypto = require('crypto');
-  const extRealPath = fs.realpathSync(NEO_EXTENSION_DIR);
+  const extRealPath = fs.realpathSync(extensionDir);
   const hashHex = crypto.createHash('sha256').update(extRealPath).digest('hex').slice(0, 32);
   const extensionId = [...hashHex].map(c => String.fromCharCode('a'.charCodeAt(0) + parseInt(c, 16))).join('');
 
   // Read extension manifest for permissions
-  const manifest = JSON.parse(fs.readFileSync(path.join(NEO_EXTENSION_DIR, 'manifest.json'), 'utf8'));
+  const manifest = JSON.parse(fs.readFileSync(path.join(extensionDir, 'manifest.json'), 'utf8'));
   const permissions = manifest.permissions || [];
 
   // Register as unpacked extension (location: 4)
@@ -2486,51 +2526,54 @@ commands.setup = async function(args) {
   fs.writeFileSync(prefsFile, JSON.stringify(prefs, null, 2) + '\n', 'utf8');
 
   console.log('Neo setup complete');
+  if (profileName) console.log(`  Profile: ${profileName}`);
   console.log(`  Chrome binary: ${chromePath}`);
-  console.log(`  Extension dir: ${NEO_EXTENSION_DIR}`);
+  console.log(`  Extension dir: ${extensionDir}`);
   console.log(`  Extension ID: ${extensionId}`);
-  console.log(`  Config file: ${NEO_CONFIG_FILE}`);
+  console.log(`  Config file: ${configFile}`);
   console.log(`  Schema dir: ${setupSchemaDir}`);
   console.log('');
   console.log('Launch Chrome with: neo start');
 };
 
-// neo start
+// neo start [--profile <name>] [--force]
 commands.start = async function(args) {
   const { positional, flags } = parseArgs(args || []);
-  if (positional.length > 0 || Object.keys(flags).length > 0) {
-    console.error('Usage: neo start');
-    process.exit(1);
-  }
+  const profileName = typeof flags.profile === 'string' ? flags.profile : null;
+  const force = 'force' in flags;
+
+  const homeDir = profileName ? getNeoHomeDir(profileName) : NEO_HOME_DIR;
+  const configFile = path.join(homeDir, 'config.json');
+  const extensionDir = path.join(homeDir, 'extension');
 
-  if (!fs.existsSync(NEO_CONFIG_FILE)) {
-    throw new Error(`Missing config: ${NEO_CONFIG_FILE}. Run neo setup first`);
+  if (!fs.existsSync(configFile)) {
+    throw new Error(`Missing config: ${configFile}. Run neo setup${profileName ? ' --profile ' + profileName : ''} first`);
   }
 
   let config = null;
   try {
-    config = JSON.parse(fs.readFileSync(NEO_CONFIG_FILE, 'utf8'));
+    config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
   } catch {
-    throw new Error(`Invalid config JSON: ${NEO_CONFIG_FILE}`);
+    throw new Error(`Invalid config JSON: ${configFile}`);
   }
 
   const chromePath = String(config && config.chromePath || '').trim();
   const cdpPort = parseInt(String(config && config.cdpPort !== undefined ? config.cdpPort : 9222), 10);
 
   if (!chromePath) {
-    throw new Error(`Missing chromePath in ${NEO_CONFIG_FILE}. Run neo setup again`);
+    throw new Error(`Missing chromePath in ${configFile}. Run neo setup again`);
   }
   if (!Number.isInteger(cdpPort) || cdpPort <= 0 || cdpPort > 65535) {
-    throw new Error(`Invalid cdpPort in ${NEO_CONFIG_FILE}: ${config && config.cdpPort}`);
+    throw new Error(`Invalid cdpPort in ${configFile}: ${config && config.cdpPort}`);
   }
-  if (!fs.existsSync(NEO_EXTENSION_DIR)) {
-    throw new Error(`Missing extension directory: ${NEO_EXTENSION_DIR}. Run neo setup first`);
+  if (!fs.existsSync(extensionDir)) {
+    throw new Error(`Missing extension directory: ${extensionDir}. Run neo setup first`);
   }
   if (chromePath.includes('/') && !fs.existsSync(chromePath)) {
     throw new Error(`Chrome binary does not exist: ${chromePath}`);
   }
 
-  const userDataDir = String(config && config.userDataDir || '').trim() || path.join(NEO_HOME_DIR, 'chrome-profile');
+  const userDataDir = String(config && config.userDataDir || '').trim() || path.join(homeDir, 'chrome-profile');
   fs.mkdirSync(userDataDir, { recursive: true });
 
   const child = spawn(chromePath, [
@@ -2781,11 +2824,11 @@ commands.inject = async function(args, context = {}) {
   console.log(`Injected Neo capture script${persisted}`);
 };
 
-// neo snapshot [-i] [-C] [--json] [--selector css]
+// neo snapshot [-i] [-C] [--json] [--diff] [--selector css]
 commands.snapshot = async function(args, context = {}) {
   const { options, unknown } = parseSnapshotArgs(args || []);
   if (unknown.length > 0) {
-    console.error('Usage: neo snapshot [-i] [-C] [--json] [--selector css]');
+    console.error('Usage: neo snapshot [-i] [-C] [--json] [--diff] [--selector css]');
     process.exit(1);
   }
 
@@ -2803,11 +2846,12 @@ commands.snapshot = async function(args, context = {}) {
   const displayNodes = options.interactiveOnly
     ? assigned.nodes.filter(node => INTERACTIVE_ROLES.has(String(node.role || '').toLowerCase()))
     : assigned.nodes;
-
-  setSession(sessionName, {
-    ...session,
-    refs: assigned.refs,
-  });
+  const storedSnapshot = displayNodes.map(node => ({
+    ref: node.ref,
+    role: node.role,
+    name: node.name,
+    depth: node.depth,
+  }));
 
   if (options.includeCursorPointer) {
     // TODO: Add Runtime.evaluate scan for cursor:pointer elements.
@@ -2818,6 +2862,59 @@ commands.snapshot = async function(args, context = {}) {
     console.error('TODO: snapshot --selector is not implemented yet');
   }
 
+  if (options.diff) {
+    const prev = Array.isArray(session.prevSnapshot) ? session.prevSnapshot : [];
+    const prevMap = new Map(prev.map(node => [`${node.role}:${node.name}`, node]));
+    const currMap = new Map(displayNodes.map(node => [`${node.role}:${node.name}`, node]));
+
+    const added = displayNodes.filter(node => !prevMap.has(`${node.role}:${node.name}`));
+    const removed = prev.filter(node => !currMap.has(`${node.role}:${node.name}`));
+    const changed = displayNodes.filter((node) => {
+      const previousNode = prevMap.get(`${node.role}:${node.name}`);
+      return previousNode && previousNode.depth !== node.depth;
+    });
+
+    const latestSession = getSession(sessionName) || session || {};
+    setSession(sessionName, {
+      ...latestSession,
+      refs: assigned.refs,
+      prevSnapshot: storedSnapshot,
+    });
+
+    if (options.json) {
+      console.log(JSON.stringify({ added, removed, changed }, null, 2));
+      return;
+    }
+
+    const lines = [];
+    if (added.length) {
+      lines.push(`+ Added (${added.length}):`);
+      lines.push(formatSnapshot(added));
+    }
+    if (removed.length) {
+      lines.push(`- Removed (${removed.length}):`);
+      for (const node of removed) {
+        const indent = '  '.repeat(node.depth || 0);
+        lines.push(`  ${indent}${node.ref}  [${node.role}] "${node.name}"`);
+      }
+    }
+    if (changed.length) {
+      lines.push(`~ Changed (${changed.length}):`);
+      lines.push(formatSnapshot(changed));
+    }
+    if (lines.length === 0) {
+      lines.push('(no changes)');
+    }
+    console.log(lines.join('\n'));
+    return;
+  }
+
+  setSession(sessionName, {
+    ...session,
+    refs: assigned.refs,
+    prevSnapshot: storedSnapshot,
+  });
+
   if (options.json) {
     const refs = {};
     for (const node of displayNodes) {
@@ -4802,11 +4899,13 @@ commands.read = async function(args) {
 
 commands.bridge = async function(args) {
   const { WebSocketServer } = require('ws');
+  const http = require('http');
   const port = parseInt(args.find(a => /^\d+$/.test(a)) || '9234', 10);
   const json = args.includes('--json');
   const quiet = args.includes('--quiet');
+  const wsOnly = args.includes('--ws-only');
 
-  const wss = new WebSocketServer({ port });
+  const wss = new WebSocketServer({ noServer: true });
   const clients = new Set();
   const pendingResponses = new Map(); // id → { resolve, timer }
   let cmdIdCounter = 0;
@@ -4824,9 +4923,143 @@ commands.bridge = async function(args) {
 
   if (!quiet) {
     process.stderr.write(`[Neo Bridge] listening on ws://127.0.0.1:${port}\n`);
+    if (!wsOnly) process.stderr.write(`[Neo Bridge] REST API at http://127.0.0.1:${port}\n`);
     process.stderr.write(`[Neo Bridge] waiting for extension to connect...\n`);
   }
 
+  // ─── HTTP REST handler ───────────────────────────────────
+  function jsonResponse(res, status, data) {
+    const body = JSON.stringify(data, null, 2);
+    res.writeHead(status, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+    res.end(body);
+  }
+
+  function readBody(req) {
+    return new Promise((resolve) => {
+      let body = '';
+      req.on('data', c => body += c);
+      req.on('end', () => resolve(body));
+    });
+  }
+
+  async function handleHttpRequest(req, res) {
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+      });
+      res.end();
+      return;
+    }
+
+    const url = new URL(req.url, 'http://localhost');
+    const pathname = url.pathname;
+
+    try {
+      // GET /status
+      if (pathname === '/status' && req.method === 'GET') {
+        return jsonResponse(res, 200, { ok: true, data: { clients: clients.size, uptime: process.uptime() } });
+      }
+
+      // GET /captures?domain=...&limit=...
+      if (pathname === '/captures' && req.method === 'GET') {
+        const cmdArgs = {};
+        if (url.searchParams.has('domain')) cmdArgs.domain = url.searchParams.get('domain');
+        if (url.searchParams.has('limit')) cmdArgs.limit = parseInt(url.searchParams.get('limit'));
+        const resp = await sendCommand('capture.list', cmdArgs);
+        return jsonResponse(res, 200, { ok: true, data: resp.result });
+      }
+
+      // GET /captures/count
+      if (pathname === '/captures/count' && req.method === 'GET') {
+        const resp = await sendCommand('capture.count', {});
+        return jsonResponse(res, 200, { ok: true, data: resp.result });
+      }
+
+      // GET /captures/domains
+      if (pathname === '/captures/domains' && req.method === 'GET') {
+        const resp = await sendCommand('capture.domains', {});
+        return jsonResponse(res, 200, { ok: true, data: resp.result });
+      }
+
+      // GET /tabs
+      if (pathname === '/tabs' && req.method === 'GET') {
+        const tabs = await (await fetch(`${CDP_URL}/json/list`)).json();
+        const pages = tabs.filter(t => t.type === 'page');
+        return jsonResponse(res, 200, { ok: true, data: pages.map(t => ({ title: t.title, url: t.url, id: t.id })) });
+      }
+
+      // GET /schemas
+      if (pathname === '/schemas' && req.method === 'GET') {
+        const files = fs.existsSync(SCHEMA_DIR) ? fs.readdirSync(SCHEMA_DIR).filter(f => f.endsWith('.json')) : [];
+        const schemas = files.map(f => f.replace('.json', ''));
+        return jsonResponse(res, 200, { ok: true, data: schemas });
+      }
+
+      // GET /schemas/:domain
+      if (pathname.startsWith('/schemas/') && req.method === 'GET') {
+        const domain = pathname.slice('/schemas/'.length);
+        const schemaPath = path.join(SCHEMA_DIR, `${domain}.json`);
+        if (!fs.existsSync(schemaPath)) {
+          return jsonResponse(res, 404, { ok: false, error: `No schema for ${domain}` });
+        }
+        const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+        return jsonResponse(res, 200, { ok: true, data: schema });
+      }
+
+      // GET /snapshot?interactive=true
+      if (pathname === '/snapshot' && req.method === 'GET') {
+        const sessionName = DEFAULT_SESSION_NAME;
+        const session = getSession(sessionName);
+        if (!session || !session.pageWsUrl) {
+          return jsonResponse(res, 400, { ok: false, error: 'No active session. Run neo connect first.' });
+        }
+        await cdpSend(session.pageWsUrl, 'Accessibility.enable');
+        const treeResult = await cdpSend(session.pageWsUrl, 'Accessibility.getFullAXTree');
+        const assigned = assignRefs(treeResult && Array.isArray(treeResult.nodes) ? treeResult.nodes : []);
+        const interactiveOnly = url.searchParams.get('interactive') === 'true';
+        const nodes = interactiveOnly
+          ? assigned.nodes.filter(node => INTERACTIVE_ROLES.has(String(node.role || '').toLowerCase()))
+          : assigned.nodes;
+        setSession(sessionName, { ...session, refs: assigned.refs });
+        return jsonResponse(res, 200, { ok: true, data: { count: nodes.length, nodes } });
+      }
+
+      // POST /eval  { expression: "..." }
+      if (pathname === '/eval' && req.method === 'POST') {
+        const body = JSON.parse(await readBody(req));
+        const sessionName = DEFAULT_SESSION_NAME;
+        const session = getSession(sessionName);
+        if (!session || !session.pageWsUrl) {
+          return jsonResponse(res, 400, { ok: false, error: 'No active session' });
+        }
+        const result = await cdpSend(session.pageWsUrl, 'Runtime.evaluate', {
+          expression: body.expression,
+          returnByValue: true,
+        });
+        return jsonResponse(res, 200, { ok: true, data: result.result });
+      }
+
+      return jsonResponse(res, 404, { ok: false, error: 'Not found' });
+    } catch (err) {
+      return jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+  }
+
+  // ─── HTTP Server + WebSocket upgrade ─────────────────────
+  const server = http.createServer(wsOnly ? (req, res) => {
+    jsonResponse(res, 404, { ok: false, error: 'REST disabled (--ws-only)' });
+  } : handleHttpRequest);
+
+  server.on('upgrade', (req, socket, head) => {
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit('connection', ws, req);
+    });
+  });
+
+  server.listen(port);
+
   wss.on('connection', (ws) => {
     clients.add(ws);
     if (!quiet) process.stderr.write(`[Neo Bridge] extension connected (${clients.size} client${clients.size > 1 ? 's' : ''})\n`);
@@ -5854,14 +6087,22 @@ commands.reload = async function() {
 };
 
 // neo doctor — diagnose setup issues
-commands.doctor = async function() {
+commands.doctor = async function(args) {
+  const fix = (args || []).includes('--fix');
   const checks = [];
-  function check(name, fn) { checks.push({ name, fn }); }
+  function check(name, fn, fixFn) { checks.push({ name, fn, fixFn }); }
 
   check('Chrome CDP endpoint', async () => {
     const resp = await fetch(`${CDP_URL}/json/version`);
     const info = await resp.json();
     return `${info.Browser} (${CDP_URL})`;
+  }, async () => {
+    process.stderr.write('  → Starting Chrome with neo start...\n');
+    await commands.start([]);
+    await new Promise(r => setTimeout(r, 2000));
+    const resp = await fetch(`${CDP_URL}/json/version`);
+    const info = await resp.json();
+    return `Fixed: ${info.Browser} (${CDP_URL})`;
   });
 
   check('Browser tabs', async () => {
@@ -5876,6 +6117,15 @@ commands.doctor = async function() {
     const extensionId = parseExtensionIdFromUrl(sw.url);
     if (!extensionId) return 'OK';
     return `OK (${extensionId.slice(0, 8)}…)`;
+  }, async () => {
+    process.stderr.write('  → Running neo setup to install extension...\n');
+    await commands.setup([]);
+    process.stderr.write('  → Restarting Chrome...\n');
+    await commands.start(['--force']);
+    await new Promise(r => setTimeout(r, 3000));
+    const sw = await findExtensionServiceWorker({ cdpUrl: CDP_URL });
+    if (!sw) throw new Error('Still not found after fix');
+    return 'Fixed: extension installed and loaded';
   });
 
   check('IndexedDB captures', async () => {
@@ -5890,6 +6140,9 @@ commands.doctor = async function() {
     if (!fs.existsSync(SCHEMA_DIR)) throw new Error(`Missing: ${SCHEMA_DIR}`);
     const files = fs.readdirSync(SCHEMA_DIR).filter(f => f.endsWith('.json'));
     return `${files.length} schema(s) in ${SCHEMA_DIR}`;
+  }, async () => {
+    fs.mkdirSync(SCHEMA_DIR, { recursive: true });
+    return `Fixed: created ${SCHEMA_DIR}`;
   });
 
   check('WebSocket bridge port', async () => {
@@ -5901,14 +6154,26 @@ commands.doctor = async function() {
     });
   });
 
-  for (const { name, fn } of checks) {
+  let fixed = 0;
+  for (const { name, fn, fixFn } of checks) {
     try {
       const result = await fn();
       console.log(`  ✓  ${name}: ${result}`);
     } catch (err) {
-      console.log(`  ✗  ${name}: ${err.message}`);
+      if (fix && fixFn) {
+        try {
+          const result = await fixFn();
+          console.log(`  ✓  ${name}: ${result}`);
+          fixed++;
+        } catch (fixErr) {
+          console.log(`  ✗  ${name}: ${fixErr.message}`);
+        }
+      } else {
+        console.log(`  ✗  ${name}: ${err.message}${fixFn ? ' (use --fix to auto-repair)' : ''}`);
+      }
     }
   }
+  if (fix && fixed > 0) console.log(`\n  Fixed ${fixed} issue(s).`);
 };
 
 async function main() {
@@ -5933,8 +6198,9 @@ Commands:
   neo eval "<js>" --tab <pattern>         Evaluate JS in page context
   neo open <url>                          Open URL in Chrome
   neo read <tab-pattern>                  Extract readable text from page
-  neo setup                               Setup ~/.neo config, extension, and schemas
-  neo start                               Start Chrome with configured Neo extension
+  neo setup [--profile <name>]             Setup ~/.neo config, extension, and schemas
+  neo start [--profile <name>]             Start Chrome with configured Neo extension
+  neo profiles                             List configured profiles
   neo launch <app> [--port N]             Launch Electron app with CDP enabled
   neo connect [port]                      Connect to CDP and save active session
   neo connect --electron <app-name>       Auto-discover Electron CDP port and connect
@@ -5943,7 +6209,7 @@ Commands:
   neo tab                                 List CDP targets in the active session
   neo tab <index> | neo tab --url <pat>  Switch active tab target
   neo inject [--persist] [--tab pattern]  Inject Neo capture script into page target
-  neo snapshot [-i] [-C] [--json]         Snapshot a11y tree with @ref mapping
+  neo snapshot [-i] [-C] [--json] [--diff] Snapshot a11y tree with @ref mapping
   neo click @ref [--new-tab]              Click element by @ref
   neo fill @ref "text"                     Clear then fill element by @ref
   neo type @ref "text"                     Type text without clearing
@@ -5964,7 +6230,7 @@ Commands:
   neo export-skill <domain>               Generate agent-ready API reference
   neo mock <domain> [--port N]            Generate mock server from schema
   neo bridge [port] [--json] [--quiet]    Start WebSocket bridge server
-  neo doctor                              Diagnose setup issues
+  neo doctor [--fix]                      Diagnose setup issues (--fix to auto-repair)
   neo reload                              Reload the Neo extension
 
 Options (for exec):