@getopencrawl/cli 0.1.1 → 0.2.1

package/package.json

@@ -1,27 +1,33 @@
 {
   "name": "@getopencrawl/cli",
-  "version": "0.1.1",
-  "description": "Search, import and bring OpenCrawl context to your agents",
+  "version": "0.2.1",
+  "description": "OpenCrawl CLI: sign in now, query the index as features become available",
   "type": "module",
+  "license": "UNLICENSED",
   "bin": {
-    "opencrawl": "bin/opencrawl.mjs"
+    "opencrawl": "bin/opencrawl.cjs"
   },
-  "exports": "./src/client.mjs",
   "files": [
-    "bin",
-    "src",
-    "README.md",
-    "browser.mjs"
+    "bin/opencrawl.cjs",
+    "README.md"
   ],
-  "scripts": {
-    "test": "node --test src/*.test.mjs",
-    "test:product-browser": "node --test tests/product-monitor-browser.test.mjs"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1patch/opencrawl-core.git",
+    "directory": "cli"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   },
-  "license": "UNLICENSED",
   "optionalDependencies": {
-    "playwright": "^1.58.0"
+    "@getopencrawl/cli-darwin-arm64": "0.2.1",
+    "@getopencrawl/cli-darwin-x64": "0.2.1",
+    "@getopencrawl/cli-linux-arm64": "0.2.1",
+    "@getopencrawl/cli-linux-x64": "0.2.1",
+    "@getopencrawl/cli-win32-x64": "0.2.1"
   }
 }

package/bin/opencrawl.mjs

@@ -1,553 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import readline from 'node:readline';
-import { createClient, readConfig, writeConfig, validateBaseUrl, configDir, loggedInConfig, loggedOutConfig, profileSummaries, resolveCredentials } from '../src/client.mjs';
-import { SESSIONS_HELP, sessionsCommand } from '../src/sessions.mjs';
-import { RESEARCH_HELP, researchCommand } from '../src/research.mjs';
-import { TASKS_HELP, tasksCommand } from '../src/tasks.mjs';
-import { MONITORS_HELP, monitorsCommand } from '../src/monitors.mjs';
-import { PRODUCT_MONITORS_HELP, productMonitorsCommand } from '../src/product-monitors.mjs';
-import { CONNECT_HELP, connectCommand } from '../src/connect.mjs';
-import { displayText, displayLine } from '../src/display.mjs';
-import { JOBS_HELP, jobsCommand, allowedOptions, waitOptions, withInterrupt, requestFailure } from '../src/jobs.mjs';
-import { UPLOADS_HELP, PROVIDERS, submitUpload, finishUpload, lookupReceipt, uploadsCommand } from '../src/uploads.mjs';
-import { coverageWarnings, hookContext, HOOK_RETRIEVAL_BUDGET, utf8Prefix } from '../src/context.mjs';
-import { CAPTURE_HELP, AGENT_OPTIONS, agentClient, verifyAgentIdentity, configureCapture, assertCaptureHook, captureHook, captureCommand } from '../src/capture.mjs';
-
-const SCRIPT = fileURLToPath(import.meta.url);
-let productMonitorJson = false;
-const WATCH_HELP = `OpenCrawl · watch an explicit export folder
-
-  opencrawl watch DIRECTORY --provider P [--once] [--json]
-    [--source ID] [--visibility private|workspace]
-
-Providers: auto, chatgpt, claude, claude-code, codex, generic.
-Only JSON/JSONL files are watched. Hidden paths and symbolic links are skipped.
---once makes one pass; otherwise this runs in the foreground until Ctrl+C.
-Pending request keys are saved before sending and looked up after restart.
-Unconfirmed, prepared, retryable, or expired requests are never resent automatically.
-Use uploads lookup and explicit import --request-key with the original scope.
-Global options: --account PROFILE_ID --server URL --config-dir DIRECTORY --json
-`;
-const HELP = `OpenCrawl · knowledge that follows your work
-
-New here? Start free, no card or browser needed:
-  opencrawl agent signup --organization NAME --email EMAIL   Create a free organization; its key is saved
-  opencrawl agent "what data you need"   The OpenCrawl agent plans it; then --session ID --build
-  Guide: https://app.getopencrawl.com/start.md
-
-  opencrawl login [--server URL]         Save a workspace API key securely
-  opencrawl configure --server URL       Change the server
-  opencrawl profiles                    List saved workspace account profiles
-  opencrawl agent --help                 Ask the OpenCrawl agent to build a data project
-  opencrawl search "question" [--json]    Search connected knowledge
-  opencrawl context "task" [--budget N]  Get a compact, cited context pack
-  opencrawl research --help              Collect and search public-source research
-  opencrawl tasks --help                 Run saved questions against current evidence
-  opencrawl monitors --help              Inspect selected public-page changes
-  opencrawl sessions --help              Read and export imported conversation ranges
-  opencrawl import FILE [--provider P]   Import a JSON/ZIP chat export or text
-  opencrawl ingest FILE [--wait]        Upload a document, image, audio, or video
-  opencrawl jobs --help                 List, inspect, or wait for a background job
-  opencrawl uploads --help              Recover an upload using its saved receipt
-  opencrawl watch DIRECTORY --provider P Watch an explicitly selected export folder
-  opencrawl connect --help              Authorize, configure and sync an app
-  opencrawl status                       Show live workspace usage
-  opencrawl doctor                       Check local setup and server health
-  opencrawl mcp                          Run the MCP stdio bridge
-  opencrawl install claude-code          Add local MCP + prompt context hook
-  opencrawl install cursor|codex         Add project-local MCP configuration
-  opencrawl install claude-code|codex --capture  Also capture new private messages
-  opencrawl capture --help               Inspect or flush project capture
-  opencrawl browser monitor --help      Capture and compare private product screens
-  opencrawl browser login URL           Sign in to an isolated browser profile
-  opencrawl browser capture URL         Index an explicitly selected page
-  opencrawl browser crawl URL           Crawl selected origin and path scope
-  opencrawl hook                        Run Claude Code's UserPromptSubmit hook
-  opencrawl logout                       Remove the locally saved API key
-
-Options: --server URL  --account PROFILE_ID  --json  --limit N  --source ID  --customer NAME (search/context: one customer's index)  --once (watch)
-Providers: auto, chatgpt, claude, claude-code, codex, generic
-Credentials: OPENCRAWL_API_KEY, OPENCRAWL_URL. Node.js 20+.
-Hosted ChatGPT/Claude history is imported from an export; it is not silently read.
-`;
-
-function parseArgs(args) {
-  const positional = [], options = {}, duplicates = [], valuedFlags = [];
-  for (let index = 0; index < args.length; index++) {
-    const arg = args[index];
-    if (!arg.startsWith('--')) { positional.push(arg); continue; }
-    const [key, inline] = arg.slice(2).split(/=(.*)/s);
-    if (key !== 'selection' && Object.hasOwn(options,key)) duplicates.push(key);
-    if (['json','help','version','wait','once','acknowledge-unknown','capture','content-only','build','check','new-key','create-new','print-keys'].includes(key) && inline !== undefined) valuedFlags.push(key);
-    if (['json', 'once', 'help', 'version', 'headless', 'interactive', 'ocr', 'wait','acknowledge-unknown','capture','content-only','build','check','new-key','create-new','print-keys'].includes(key)) options[key] = true;
-    else {
-      const value = inline ?? args[++index];
-      if (value === undefined || value.startsWith('--')) throw new Error(`Missing value for --${key}`);
-      if (key === 'selection') (options.selection ||= []).push(value);
-      else options[key] = value;
-    }
-  }
-  if (['research','sessions','tasks','monitors','jobs','uploads','import','ingest','watch','connect','capture','capture-hook','install','browser'].includes(positional[0]) && duplicates.length) throw new Error(`Duplicate option: --${duplicates[0]}`);
-  if (['research','sessions','tasks','monitors','jobs','uploads','import','ingest','watch','connect','capture','capture-hook','install','browser'].includes(positional[0]) && valuedFlags.length) throw new Error(`--${valuedFlags[0]} does not take a value.`);
-  return { positional, options };
-}
-function integer(value, fallback, minimum = 1, maximum = 16000) {
-  if (value === undefined) return fallback;
-  const number = Number(value);
-  if (!Number.isInteger(number) || number < minimum || number > maximum) throw new Error(`Expected a number between ${minimum} and ${maximum}.`);
-  return number;
-}
-function printRpc(value) { process.stdout.write(JSON.stringify(value) + '\n'); }
-function print(value) { process.stdout.write(typeof value === 'string' ? value + '\n' : JSON.stringify(value, null, 2) + '\n'); }
-function shellQuote(value) { return "'" + value.replaceAll("'", "'\\''") + "'"; }
-async function readStdin(max = 2_000_000) {
-  let text = '';
-  for await (const chunk of process.stdin) {
-    text += chunk;
-    if (text.length > max) throw new Error('Input exceeds the size limit.');
-  }
-  return text;
-}
-async function askSecret(prompt) {
-  if (!process.stdin.isTTY) return (await readStdin(10000)).trim();
-  process.stderr.write(prompt);
-  process.stdin.setRawMode(true); process.stdin.resume();
-  return new Promise((resolve, reject) => {
-    let text = '';
-    function finish(error) {
-      process.stdin.setRawMode(false); process.stdin.pause(); process.stdin.off('data', onData); process.stderr.write('\n');
-      error ? reject(error) : resolve(text);
-    }
-    function onData(chunk) {
-      for (const char of chunk.toString()) {
-        if (char === '\u0003') return finish(new Error('Cancelled.'));
-        if (char === '\r' || char === '\n') return finish();
-        if (char === '\u007f' || char === '\b') text = text.slice(0, -1);
-        else if (char >= ' ') text += char;
-      }
-    }
-    process.stdin.on('data', onData);
-  });
-}
-async function backupWrite(file, text) {
-  await fs.mkdir(path.dirname(file), { recursive: true });
-  try {
-    const current = await fs.readFile(file, 'utf8');
-    if (current === text) return false;
-    await fs.copyFile(file, `${file}.opencrawl-backup-${Date.now()}`);
-  } catch (error) { if (error.code !== 'ENOENT') throw error; }
-  const temp = `${file}.${process.pid}.tmp`;
-  await fs.writeFile(temp, text, { mode: 0o600 });
-  await fs.rename(temp, file);
-  return true;
-}
-async function readJsonIfPresent(file) {
-  try { return JSON.parse(await fs.readFile(file, 'utf8')); }
-  catch (error) { if (error.code === 'ENOENT') return {}; throw new Error(`Cannot parse ${file}; no settings were changed.`); }
-}
-async function install(clientName, options) {
-  if (!['claude-code', 'cursor', 'codex'].includes(clientName)) throw new Error('Install targets: claude-code, cursor, codex');
-  allowedOptions(options,['capture','credential-env'],'install');
-  if(options.capture && clientName==='cursor')throw new Error('New-message capture supports Claude Code and Codex. Cursor installation provides MCP retrieval.');
-  const client = await agentClient(options,{installing:true});
-  if (!client.configured || client.credentialSource !== 'profile' && !options['credential-env'])
-    throw new Error('Sign in to save a verified workspace account before installing. Use --account PROFILE_ID to select a saved account when shell credentials are set.');
-  const root = await fs.realpath(process.cwd());
-  const identity=options.capture||options['credential-env']?await verifyAgentIdentity(client):null;
-  if(options['credential-env'])client.expectedIdentity={user_id:identity.user_id,workspace_id:identity.workspace_id};
-  const bound = [...(options['credential-env']?['--credential-env',options['credential-env'],'--expect-user',identity.user_id,'--expect-workspace',identity.workspace_id]:['--account', client.profile.id]), '--server', client.baseUrl, '--config-dir', path.resolve(configDir())];
-  const server = { command: process.execPath, args: [SCRIPT, 'mcp', ...bound] };
-  const captureMarker='# opencrawl-managed-capture';
-  const captureCommandText=[process.execPath,SCRIPT,'capture-hook','--provider',clientName,'--project',root,...bound].map(shellQuote).join(' ')+' '+captureMarker;
-  function captureSettings(settings) {
-    settings.hooks ||= {};
-    for(const event of ['UserPromptSubmit','Stop']) {
-      const groups=settings.hooks[event]||[];
-      if(!Array.isArray(groups)||groups.some(group=>!group||!Array.isArray(group.hooks)))throw new Error('Existing hooks are malformed; no settings were changed.');
-      const retained=groups.map(group=>({...group,hooks:group.hooks.filter(hook=>!hook.command?.includes(captureMarker)&&!(event==='UserPromptSubmit'&&hook.command?.includes('# opencrawl-managed-hook')))})).filter(group=>group.hooks.length);
-      settings.hooks[event]=[...retained,{hooks:[{type:'command',command:captureCommandText,timeout:10}]}];
-    }
-    return settings;
-  }
-  if (clientName === 'claude-code' || clientName === 'cursor') {
-    const mcpPath = path.join(root, clientName === 'cursor' ? '.cursor/mcp.json' : '.mcp.json');
-    const existing = await readJsonIfPresent(mcpPath);
-    existing.mcpServers = { ...(existing.mcpServers || {}), opencrawl: server };
-    const settingsPath = path.join(root, '.claude/settings.local.json');
-    // Parse both files before any writes so an invalid settings file cannot partially install.
-    const settings = clientName === 'claude-code' ? await readJsonIfPresent(settingsPath) : null;
-    const priorCapture=settings&&JSON.stringify(settings.hooks||{}).includes(captureMarker);
-    if(settings&&options.capture)captureSettings(settings);
-    else if (settings&&!priorCapture) {
-      const command = [process.execPath, SCRIPT, 'hook', ...bound].map(shellQuote).join(' ') + ' # opencrawl-managed-hook';
-      settings.hooks ||= {};
-      const existingHooks = settings.hooks.UserPromptSubmit || [];
-      if (!Array.isArray(existingHooks)) throw new Error('Existing Claude Code hooks are malformed; no settings were changed.');
-      const retained = existingHooks.map(group => ({...group, hooks: (group.hooks || []).filter(hook => !hook.command?.includes('# opencrawl-managed-hook'))})).filter(group => group.hooks.length);
-      settings.hooks.UserPromptSubmit = [...retained, { hooks: [{ type: 'command', command, timeout: 5 }] }];
-    }
-    if(options.capture)await configureCapture(client,clientName,root);
-    await backupWrite(mcpPath, JSON.stringify(existing, null, 2) + '\n');
-    if (settings) await backupWrite(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-    print(`Installed OpenCrawl ${client.profile?.id||'verified environment account'} at ${client.baseUrl} in ${root}. Existing settings were preserved and changed files backed up. Restart ${clientName}.`);
-    if (settings) print(options.capture||priorCapture?'New user prompts and final assistant messages in this exact project are captured privately. No history, tool output or transcript files are read. Use capture status; capture pause stops new collection.':'Each submitted prompt now retrieves relevant OpenCrawl context. This does not upload the conversation.');
-  } else if (clientName === 'codex') {
-    const file = path.join(root, '.codex/config.toml');
-    const hooksFile=path.join(root,'.codex/hooks.json');
-    const captureHooks=options.capture?captureSettings(await readJsonIfPresent(hooksFile)):null;
-    let text = '';
-    try { text = await fs.readFile(file, 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
-    const start = '# OpenCrawl managed MCP start', end = '# OpenCrawl managed MCP end';
-    if (text.includes('[mcp_servers.opencrawl]') && !text.includes(start)) throw new Error('An unmanaged OpenCrawl MCP entry already exists. Preserve it or remove it before installing.');
-    const block = `${start}\n[mcp_servers.opencrawl]\ncommand = ${JSON.stringify(process.execPath)}\nargs = ${JSON.stringify([SCRIPT, 'mcp', ...bound])}\n${options['credential-env']?'env_vars = '+JSON.stringify([options['credential-env']])+'\n':''}${end}`;
-    const begin = text.indexOf(start), finish = text.indexOf(end);
-    if ((begin >= 0) !== (finish >= 0)) throw new Error('The existing managed MCP block is incomplete. No settings were changed.');
-    if (begin >= 0) text = text.slice(0, begin) + block + text.slice(finish + end.length);
-    else text = text.replace(/\s*$/, '') + (text.trim() ? '\n\n' : '') + block + '\n';
-    if(options.capture)await configureCapture(client,clientName,root);
-    await backupWrite(file, text);
-    if(captureHooks)await backupWrite(hooksFile,JSON.stringify(captureHooks,null,2)+'\n');
-    print(`Installed OpenCrawl MCP in ${file}. Restart Codex and trust the project to load project settings.`);
-    if(captureHooks)print('New prompts and final assistant messages in this exact project are captured privately. Review and trust these hooks with /hooks in Codex; nothing bypasses client approval. No history or tool output is read. Use capture status to confirm actual delivery.');
-  } else throw new Error('Install targets: claude-code, cursor, codex');
-  if(options.capture) {
-    print('Check delivery with this account and project binding:');
-    print(['opencrawl','capture','status','--provider',clientName,'--project',root,...bound,'--json'].map(shellQuote).join(' '));
-  }
-}
-async function uploadFile(file, client, options = {}, callbacks = {}) {
-  return withInterrupt(signal => submitUpload(file, client, options, { ...callbacks, signal }));
-}
-async function importFile(file, provider, client, options = {}) {
-  if (/\.zip$/i.test(file)) return uploadFile(file, client, { ...options, chat: true, provider: provider || 'auto' });
-  if (/\.(pdf|docx?|pptx?|xlsx?|xlsm|png|jpe?g|tiff?|heic|bmp|rtf|mp4|webm|mov|mkv|avi|mp3|m4a|wav|flac|ogg|amr)$/i.test(file)) {
-    if (provider) throw new Error('Use a JSON, JSONL, or ZIP chat export with --provider, or use opencrawl ingest for documents and media.');
-    return uploadFile(file, client, options);
-  }
-  const stat = await fs.stat(file);
-  if (!stat.isFile() || stat.size > 25_000_000) throw new Error('Import a regular file smaller than 25 MB.');
-  const bytes = await fs.readFile(file);
-  let text;
-  try { text = new TextDecoder('utf-8', { fatal: true }).decode(bytes); }
-  catch { throw new Error('This file is not UTF-8 text. Use opencrawl ingest for documents and media.'); }
-  if (text.includes('\0')) throw new Error('This file contains binary data. Use opencrawl ingest for documents and media.');
-  if (provider || /\.(json|jsonl)$/i.test(file)) {
-    return uploadFile(file, client, { ...options, chat: true, provider: provider || 'auto' });
-  }
-  if (options['request-key']) return uploadFile(file, client, options);
-  const hash = crypto.createHash('sha256').update(text).digest('hex');
-  const body = { title: path.basename(file), content: text, visibility: options.visibility || 'private',
-    source_id: options.source, external_id: `cli-file:${path.resolve(file)}`, metadata: { imported_by: 'cli', content_hash: hash } };
-  if (!['private', 'workspace'].includes(body.visibility)) throw new Error('--visibility must be private or workspace.');
-  // JSON escaping can make a text document much larger than its source file.
-  // Oversized notes use the same bounded multipart queue as documents/media.
-  if (Buffer.byteLength(JSON.stringify(body)) > 8 * 1024 * 1024) return uploadFile(file, client, options);
-  return client.request('/api/v1/documents', { method: 'POST', body });
-}
-async function listFiles(directory, depth = 0) {
-  if (depth > 8) return [];
-  const entries = await fs.readdir(directory, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith('.') || entry.isSymbolicLink()) continue;
-    const full = path.join(directory, entry.name);
-    if (entry.isDirectory()) files.push(...await listFiles(full, depth + 1));
-    else if (entry.isFile() && /\.(json|jsonl)$/i.test(entry.name)) files.push(full);
-    if (files.length > 10000) throw new Error('Choose a smaller export folder (maximum 10,000 files).');
-  }
-  return files;
-}
-async function watch(directory, options, client) {
-  if (!directory) throw new Error('Choose an explicit directory to watch.');
-  if (!PROVIDERS.includes(options.provider)) throw new Error('Specify --provider auto, chatgpt, claude, claude-code, codex, or generic.');
-  if (options.visibility !== undefined && !['private','workspace'].includes(options.visibility)) throw new Error('--visibility must be private or workspace.');
-  const root = await fs.realpath(directory);
-  if (!(await fs.stat(root)).isDirectory()) throw new Error('Watch target must be a directory.');
-  // Receipt ownership follows the verified account, not a rotatable API key.
-  let userId = client.profile?.userId, workspaceId = client.profile?.workspaceId;
-  if (!userId || !workspaceId) {
-    const identity = await client.request('/api/auth/me', { maxResponseBytes: 128 * 1024 });
-    userId = identity?.user?.id; workspaceId = identity?.workspace?.id;
-  }
-  if (![userId, workspaceId].every(value => typeof value === 'string' && /^[A-Za-z0-9_-]{1,200}$/.test(value))) throw new Error('OpenCrawl did not return a verified watcher account. No files were submitted.');
-  const scope = { server: client.baseUrl, user_id: userId, workspace_id: workspaceId, directory: root,
-    provider: options.provider, source_id: options.source || null, visibility: options.visibility || 'private' };
-  const stateName = crypto.createHash('sha256').update(JSON.stringify(scope)).digest('hex').slice(0, 24);
-  const legacyNames = [`${client.baseUrl}:${client.identity}:${root}:${options.provider}`, `${client.baseUrl}:${userId}:${workspaceId}:${root}:${options.provider}`]
-    .map(value => crypto.createHash('sha256').update(value).digest('hex').slice(0, 24));
-  const legacyPaths = legacyNames.map(name => path.join(configDir(), `watch-${name}.json`));
-  const statePath = path.join(configDir(), `watch-${stateName}.json`), lockPath = statePath + '.lock';
-  await fs.mkdir(configDir(), { recursive: true, mode: 0o700 });
-  let lock;
-  try { lock = await fs.open(lockPath, 'wx', 0o600); await lock.writeFile(String(process.pid)); }
-  catch (error) { if (error.code === 'EEXIST') throw new Error('This export folder already has a watcher lock. Stop that watcher first. If it crashed, verify its process has stopped before removing the matching watch-*.json.lock file from the configuration directory.'); throw error; }
-  let running = true; const controller = new AbortController();
-  const stop = () => { running = false; controller.abort(); };
-  process.on('SIGINT', stop); process.on('SIGTERM', stop);
-  try {
-    let state = {};
-    try {
-      const info = await fs.stat(statePath);
-      if (!info.isFile() || info.size > 32 * 1024 * 1024) throw new Error('Watcher state is not a bounded regular file. Review it before continuing.');
-      const saved = await readJsonIfPresent(statePath);
-      if (saved.version !== 2 || JSON.stringify(saved.scope) !== JSON.stringify(scope) || !saved.entries || typeof saved.entries !== 'object' || Array.isArray(saved.entries) || Object.keys(saved.entries).length > 10000)
-        throw new Error('Watcher state does not match this exact account and scope. Review it before continuing; no upload was submitted.');
-      state = saved.entries;
-    } catch (error) {
-      if (error.code !== 'ENOENT') throw error;
-      // Old signatures do not prove their source/visibility. Never silently
-      // assign them to a new scope or discard an uncertain prior request.
-      for (const legacyPath of legacyPaths) {
-        try { await fs.access(legacyPath); }
-        catch (missing) { if (missing.code === 'ENOENT') continue; throw missing; }
-        throw new Error(`Older watcher state has no verified source/visibility scope: ${legacyPath}. Stop old watchers, inspect any saved receipts, and back up or rename that state only after deciding a new scoped import is intended. The original state was preserved.`);
-      }
-    }
-    const reported = new Set();
-    const save = async () => {
-      const encoded = JSON.stringify({ version: 2, scope, entries: state });
-      if (Buffer.byteLength(encoded) > 32 * 1024 * 1024) throw new Error('Watcher state reached its byte limit. Review completed records before continuing.');
-      const temp = `${statePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
-      const file = await fs.open(temp, 'wx', 0o600);
-      try { await file.writeFile(encoded); await file.sync(); }
-      finally { await file.close(); }
-      try { await fs.rename(temp, statePath); }
-      finally { await fs.rm(temp, { force: true }); }
-      // POSIX directory fsync makes the rename durable before network effects.
-      // Windows does not expose directory handles through fs.open; the file
-      // itself is still synced before the atomic replacement there.
-      if (process.platform !== 'win32') {
-        const directory = await fs.open(configDir(), 'r');
-        try { await directory.sync(); } finally { await directory.close(); }
-      }
-    };
-    await save(); // Persist the exact account/scope before any network side effect.
-    process.stderr.write(`Watching only ${displayLine(root)}. Matching JSON/JSONL exports will be uploaded to ${displayLine(client.baseUrl)}.\n`);
-    do {
-      const outcomes = [];
-      for (const file of await listFiles(root)) {
-        if (!running) break;
-        try {
-          const stat = await fs.stat(file);
-          if (stat.size > 25_000_000) continue;
-          const signature = `${stat.size}:${stat.mtimeMs}`;
-          let entry = state[file];
-          if (entry === signature || entry?.accepted === signature) continue;
-          if (entry?.pending) {
-            // An earlier process may have lost prepare/content acceptance. Never
-            // create another key or resend bytes until this request is resolved.
-            let receipt;
-            try { receipt = await lookupReceipt(client, entry.pending.request_key, { timeout: 10000, signal: controller.signal }); }
-            catch (error) {
-              const report = `${entry.pending.request_key}:lookup`;
-              if (!reported.has(report)) { process.stderr.write(`Upload pending for ${displayLine(path.basename(file))}. Inspect request ${entry.pending.request_key}: ${requestFailure(error).message}\n`); reported.add(report); }
-              outcomes.push({ request_key: entry.pending.request_key, outcome: 'unconfirmed' }); continue;
-            }
-            if (receipt.state === 'accepted') {
-              state[file] = { accepted: entry.pending.signature, receipt_id: receipt.id, job_id: receipt.job.id }; await save();
-              process.stderr.write(`Accepted ${displayLine(path.basename(file))}; job ${displayLine(receipt.job.id)}.\n`);
-            } else {
-              const report = `${receipt.request_key}:${receipt.state}`;
-              if (!reported.has(report)) { process.stderr.write(`Upload ${displayLine(receipt.state)} for ${displayLine(path.basename(file))}. Inspect with opencrawl uploads lookup ${receipt.request_key}; no automatic resend.\n`); reported.add(report); }
-            }
-            outcomes.push({ request_key: receipt.request_key, receipt_id: receipt.id, outcome: receipt.state, job_id: receipt.job?.id || null });
-            continue;
-          }
-          const result = await submitUpload(file, client, { ...options, chat: true }, {
-            signal: controller.signal,
-            onIntent: async (key, descriptor) => { if (!Object.hasOwn(state, file) && Object.keys(state).length >= 10000) throw new Error('Watcher state reached 10,000 records. Review completed records before continuing.'); state[file] = { accepted: typeof entry === 'string' ? entry : entry?.accepted, pending: { request_key: key, signature, descriptor } }; await save(); },
-          });
-          if (result.outcome === 'accepted') {
-            state[file] = { accepted: signature, receipt_id: result.receipt_id, job_id: result.job_id }; await save();
-            process.stderr.write(`Accepted ${displayLine(path.basename(file))}; job ${displayLine(result.job_id)}.\n`);
-          } else process.stderr.write(`Upload ${displayLine(result.outcome)} for ${displayLine(path.basename(file))}. Keep request ${result.request_key}; no automatic resend.\n`);
-          outcomes.push({ request_key: result.request_key, receipt_id: result.receipt_id, outcome: result.outcome, job_id: result.job_id });
-        } catch (error) { process.stderr.write(`Skipped ${displayLine(path.basename(file))}: ${displayLine(error.message)}\n`); outcomes.push({ outcome: 'failed', error: 'This file could not be submitted.' }); }
-      }
-      if (options.json && options.once) print({ outcomes });
-      if (options.once) { if (outcomes.some(item => item.outcome !== 'accepted')) process.exitCode = 1; break; }
-      if (!running) break;
-      const until = Date.now() + 2500;
-      while (running && Date.now() < until) await new Promise(resolve => setTimeout(resolve, 100));
-    } while (running);
-  } finally {
-    process.off('SIGINT', stop); process.off('SIGTERM', stop);
-    await lock.close(); await fs.unlink(lockPath);
-  }
-}
-async function hook(client) {
-  try {
-    const input = JSON.parse(await readStdin());
-    if (typeof input.prompt !== 'string' || !input.prompt.trim() || !client.configured) return;
-    if(client.expectedIdentity)await verifyAgentIdentity(client,1000);
-    const data = await client.request('/api/v1/context', { method: 'POST', body: { query: input.prompt.slice(0, 1000), budget: HOOK_RETRIEVAL_BUDGET, limit: 5 }, timeout: 3500, channel: 'hook' });
-    const wrapped = hookContext(data);
-    if (!wrapped) return;
-    print({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: wrapped } });
-  } catch { /* Retrieval is best effort and must never block the user's prompt. */ }
-}
-async function liveCaptureHook(client,options) {
-  let result={},input;
-  try {
-    input=JSON.parse(await readStdin(300000));
-    await assertCaptureHook(input,options,client);
-    // Read previous knowledge before storing the current question, so a new
-    // prompt cannot immediately retrieve itself as supporting evidence.
-    if(input.hook_event_name==='UserPromptSubmit'&&typeof input.prompt==='string'&&input.prompt.trim()) {
-      try {
-        await verifyAgentIdentity(client,1000);
-        const data=await client.request('/api/v1/context',{method:'POST',body:{query:input.prompt.slice(0,1000),budget:HOOK_RETRIEVAL_BUDGET,limit:5},timeout:2500,channel:'hook'});
-        const wrapped=hookContext(data);if(wrapped)result={hookSpecificOutput:{hookEventName:'UserPromptSubmit',additionalContext:wrapped}};
-      }catch{/* Retrieval remains fail-open. */}
-    }
-    await captureHook(input,options,client);
-  } catch {if(input?.hook_event_name!=='Stop')process.stderr.write('OpenCrawl capture did not complete. Inspect capture status in this project; the agent may continue.\n');}
-  printRpc(result); // Stop requires JSON and must never control continuation.
-}
-async function mcp(client) {
-  let protocolVersion;
-  const lines = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
-  for await (const line of lines) {
-    if (!line.trim()) continue;
-    let message;
-    try { message = JSON.parse(line); }
-    catch { printRpc({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }); continue; }
-    try {
-      const result = await client.request('/mcp', { method: 'POST', body: message, protocolVersion });
-      if (message.method === 'initialize' && result?.result?.protocolVersion) protocolVersion = result.result.protocolVersion;
-      if (result !== null) printRpc(result);
-    } catch (error) {
-      if (message && Object.hasOwn(message, 'id')) printRpc({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: error.message } });
-      else process.stderr.write(error.message + '\n');
-    }
-  }
-}
-async function main() {
-  const { positional, options } = parseArgs(process.argv.slice(2));
-  productMonitorJson = positional[0] === 'browser' && positional[1] === 'monitor' && options.json === true;
-  const [command, ...rest] = positional;
-  if (options['config-dir']) process.env.OPENCRAWL_CONFIG_DIR = path.resolve(options['config-dir']);
-  if (options.token !== undefined || options.key !== undefined) throw new Error('Do not pass credentials in command-line arguments. Use the hidden login prompt or OPENCRAWL_API_KEY.');
-  if (options.version) return print('0.1.1');
-  if (command === 'agent' && (options.help || (!rest.length && !options.session))) { const { AGENT_HELP } = await import('../src/agent.mjs'); return print(AGENT_HELP); }
-  if (command === 'sessions' && (options.help || !rest.length)) return print(SESSIONS_HELP);
-  if (command === 'research' && (options.help || !rest.length)) return print(RESEARCH_HELP);
-  if (command === 'tasks' && (options.help || !rest.length)) return print(TASKS_HELP);
-  if (command === 'monitors' && (options.help || !rest.length)) return print(MONITORS_HELP);
-  if (command === 'connect' && options.help) return print(CONNECT_HELP);
-  if (command === 'capture' && (options.help || !rest.length)) return print(CAPTURE_HELP);
-  if (command === 'jobs' && (options.help || !rest.length)) return print(JOBS_HELP);
-  if (command === 'watch' && options.help) return print(WATCH_HELP);
-  if (command === 'uploads' && (options.help || !rest.length) || ['import','ingest'].includes(command) && options.help) return print(UPLOADS_HELP);
-  if(command==='browser'&&rest[0]==='monitor'&&(options.help||rest.length===1))return print(PRODUCT_MONITORS_HELP);
-  if (!command || command === 'help' || options.help) return print(HELP);
-  if (command === 'configure') {
-    if (!options.server) throw new Error('Use configure --server URL.');
-    const config = await readConfig(); config.server = validateBaseUrl(options.server); await writeConfig(config); return print(`Server: ${config.server}. Saved keys remain bound to their original servers. Use login to authorize this destination.`);
-  }
-  if (command === 'login') {
-    const config = await readConfig();
-    // Resolve an explicit account before reading/sending the replacement key.
-    const { baseUrl: server } = resolveCredentials(config, { account: options.account, server: options.server }, { ...process.env, OPENCRAWL_API_KEY: undefined });
-    const apiKey = process.env.OPENCRAWL_API_KEY ?? await askSecret('Workspace API key (hidden): ');
-    if (!apiKey) throw new Error('No API key was given. New to OpenCrawl? Create a free organization and key with: opencrawl agent signup --organization NAME --email EMAIL. Existing account: create a key under Connect an agent → API keys and developer tools, then pipe it into opencrawl login or set OPENCRAWL_API_KEY.');
-    const client = await createClient({ server, token: apiKey });
-    const identity = await client.request('/api/auth/me');
-    const next = loggedInConfig(config, server, apiKey, identity);
-    if (options.account && options.account !== next.activeProfile) throw new Error('This key does not match the selected account’s server and workspace. No saved profile was changed.');
-    await writeConfig(next); return print(`Signed in to ${server}. Account ${next.activeProfile} saved with owner-only permissions.`);
-  }
-  if (command === 'logout') { await writeConfig(loggedOutConfig(await readConfig(), options.account)); return print('Saved API key removed for this account. Other account profiles and server keys are unchanged.'); }
-  if (command === 'profiles') return print({ accounts: profileSummaries(await readConfig()) });
-  if (command === 'install') return install(rest[0], options);
-  const client = ['mcp','hook','capture','capture-hook'].includes(command)?await agentClient(options):await createClient(options);
-  if (['mcp', 'hook'].includes(command) && client.credentialSource === 'profile' && !options.account)
-    throw new Error('This agent connection needs a pinned account. Rerun opencrawl install for this project, or use --account PROFILE_ID from opencrawl profiles.');
-  if(command==='browser'&&rest[0]==='monitor'){process.exitCode=await productMonitorsCommand(rest.slice(1),options,client);return;}
-  if (command === 'browser') { const { browserCommand } = await import('../browser.mjs'); return print(await browserCommand(rest[0], rest[1], options, client)); }
-  if (command === 'agent') {
-    const { agentCommand } = await import('../src/agent.mjs');
-    // Save each returned key as a verified account plus an owner-only key file; the default account changes only at signup.
-    const saveKey = async (apiKey, { activate }) => {
-      const identity = await (await createClient({ server: client.baseUrl, token: apiKey })).request('/api/auth/me');
-      const config = await readConfig();
-      const next = loggedInConfig(config, client.baseUrl, apiKey, identity);
-      const account = next.activeProfile;
-      if (!activate && config.activeProfile) Object.assign(next, { activeProfile: config.activeProfile, server: config.server });
-      await writeConfig(next);
-      const dir = path.join(configDir(), 'keys');
-      await fs.mkdir(dir, { recursive: true, mode: 0o700 });
-      const keyFile = path.join(dir, `${account}.key`);
-      await fs.writeFile(keyFile, apiKey + '\n', { mode: 0o600 }); await fs.chmod(keyFile, 0o600);
-      return { account, key_file: keyFile, use: `opencrawl --account ${account} <command>, or OPENCRAWL_API_KEY="$(cat ${keyFile})" for MCP and server code` };
-    };
-    process.exitCode = await agentCommand(rest, options, client, undefined, saveKey); return;
-  }
-  if (command === 'sessions') return sessionsCommand(rest,options,client);
-  if (command === 'research') { process.exitCode = await researchCommand(rest, options, client); return; }
-  if (command === 'tasks') { process.exitCode = await tasksCommand(rest, options, client); return; }
-  if (command === 'monitors') { process.exitCode = await monitorsCommand(rest, options, client); return; }
-  if (command === 'connect') { process.exitCode = await connectCommand(rest, options, client); return; }
-  if (command === 'jobs') { process.exitCode = await jobsCommand(rest, options, client); return; }
-  if (command === 'uploads') { process.exitCode = await uploadsCommand(rest, options, client); return; }
-  if (command === 'capture') { process.exitCode = await captureCommand(rest,options,client); return; }
-  if (command === 'capture-hook') {allowedOptions(options,['provider','project',...AGENT_OPTIONS],'capture-hook');return liveCaptureHook(client,options);}
-  if (command === 'hook') return hook(client);
-  if (command === 'mcp') {if(client.expectedIdentity)await verifyAgentIdentity(client);return mcp(client);}
-  if (command === 'search' || command === 'context') {
-    const query = rest.join(' ');
-    if (!query.trim()) throw new Error('Enter a query.');
-    const body = { query, limit: integer(options.limit, 8, 1, 50), budget: integer(options.budget, 2000, 256), ...(options.source ? { source_ids: [options.source] } : {}), ...(options.customer ? { customer: String(options.customer) } : {}) };
-    const data = await client.request(`/api/v1/${command}`, { method: 'POST', body });
-    if (options.json) return print(data);
-    for (const warning of coverageWarnings(data)) process.stderr.write(`OpenCrawl coverage: ${displayLine(warning)}\n`);
-    if (command === 'context') {
-      const value = data.context ?? data.text;
-      if (typeof value !== 'string') throw new Error('Server returned an invalid context response.');
-      const bounded = utf8Prefix(value, body.budget);
-      process.stdout.write(bounded);
-      if (bounded && !bounded.endsWith('\n') && Buffer.byteLength(bounded) < body.budget) process.stdout.write('\n');
-      return;
-    }
-    const results = data.results || data.hits || [];
-    if (!results.length) return print('No results. Connect a source or import a document to get started.');
-    for (const [index, result] of results.entries()) print(`${index + 1}. ${displayLine(result.title || 'Untitled')}\n${displayText(result.snippet || result.content || result.text || '')}\n${displayLine(result.url || result.citation || result.id || '')}\n`);
-    return;
-  }
-  if (command === 'import' || command === 'ingest') {
-    allowedOptions(options, ['source','visibility','request-key','wait','timeout', ...(command === 'import' ? ['provider'] : [])], command);
-    waitOptions(options);
-    if (rest.length !== 1) throw new Error('Choose exactly one file to import or ingest.');
-    const result = command === 'import' ? await importFile(rest[0], options.provider, client, options) : await uploadFile(rest[0], client, options);
-    if (result?.request_key) process.exitCode = await finishUpload(result, options, client);
-    else print(result); // Small text imports index synchronously and have no background job.
-    return;
-  }
-  if (command === 'watch') {
-    allowedOptions(options, ['source','visibility','provider','once'], 'watch');
-    if (rest.length !== 1) throw new Error('Choose exactly one directory to watch.');
-    return watch(rest[0], options, client);
-  }
-  if (command === 'status') return print(await client.request('/api/v1/usage'));
-  if (command === 'doctor') {
-    let health, access;
-    try { health = await client.request('/healthz', { authenticated: false, timeout: 5000 }); } catch (error) { health = { error: error.message }; }
-    if (client.configured) { try { await client.request('/api/v1/usage', { timeout: 5000 }); access = 'verified'; } catch (error) { access = error.message; } }
-    const report = { node: process.versions.node, server: client.baseUrl, account: client.profile?.id, credentials: client.configured ? 'present' : 'missing', access: access || client.credentialError || 'not configured', health };
-    print(report); if (health?.error || !client.configured || access && access !== 'verified') process.exitCode = 1; return;
-  }
-  throw new Error(`Unknown command: ${command}. Run opencrawl help.`);
-}
-main().catch(error => {
-  // A hook is nonblocking even when config cannot be loaded.
-  if (process.argv[2] === 'hook') return;
-  if (process.argv[2] === 'capture-hook') {process.stderr.write('OpenCrawl capture is unavailable. Inspect capture status; the agent may continue.\n');printRpc({});return;}
-  const json = productMonitorJson || process.argv.slice(2).includes('--json') && process.argv.slice(2).some(value => ['research','tasks','monitors','jobs','uploads','import','ingest','watch','connect','capture'].includes(value));
-  if (json) print({ error: { code: Number.isInteger(error.status) ? `http_${error.status}` : 'command_failed', message: Number.isInteger(error.status) ? requestFailure(error).message : error.message } });
-  else process.stderr.write(`OpenCrawl: ${displayLine(error.message)}\n`);
-  process.exitCode = 1;
-});