@jackwener/opencli 1.6.9 → 1.7.0

package/dist/src/build-manifest.js

@@ -2,8 +2,8 @@
 /**
  * Build-time CLI manifest compiler.
  *
- * Scans all YAML/TS CLI definitions and pre-compiles them into a single
- * manifest.json for instant cold-start registration (no runtime YAML parsing).
+ * Scans all TS CLI definitions and pre-compiles them into a single
+ * manifest.json for instant cold-start registration.
  *
  * Usage: npx tsx src/build-manifest.ts
  * Output: cli-manifest.json at the package root
@@ -11,14 +11,12 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import yaml from 'js-yaml';
 import { getErrorMessage } from './errors.js';
 import { fullName, getRegistry } from './registry.js';
 import { findPackageRoot, getCliManifestPath } from './package-paths.js';
 const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
 const CLIS_DIR = path.join(PACKAGE_ROOT, 'clis');
 const OUTPUT = getCliManifestPath(CLIS_DIR);
-import { parseYamlArgs } from './yaml-schema.js';
 import { isRecord } from './utils.js';
 const CLI_MODULE_PATTERN = /\bcli\s*\(/;
 function toManifestArgs(args) {
@@ -64,43 +62,6 @@ function toManifestEntry(cmd, modulePath, sourceFile) {
         navigateBefore: cmd.navigateBefore,
     };
 }
-function scanYaml(filePath, site) {
-    try {
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        const def = yaml.load(raw);
-        if (!isRecord(def))
-            return null;
-        const cliDef = def;
-        const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
-        const strategy = strategyStr.toUpperCase();
-        const browser = cliDef.browser ?? (strategy !== 'PUBLIC');
-        const args = parseYamlArgs(cliDef.args);
-        return {
-            site: cliDef.site ?? site,
-            name: cliDef.name ?? path.basename(filePath, path.extname(filePath)),
-            description: cliDef.description ?? '',
-            domain: cliDef.domain,
-            strategy: strategy.toLowerCase(),
-            browser,
-            aliases: isRecord(cliDef) && Array.isArray(cliDef.aliases)
-                ? cliDef.aliases.filter((value) => typeof value === 'string')
-                : undefined,
-            args,
-            columns: cliDef.columns,
-            pipeline: cliDef.pipeline,
-            timeout: cliDef.timeout,
-            deprecated: cliDef.deprecated,
-            replacedBy: cliDef.replacedBy,
-            type: 'yaml',
-            sourceFile: path.relative(CLIS_DIR, filePath),
-            navigateBefore: cliDef.navigateBefore,
-        };
-    }
-    catch (err) {
-        process.stderr.write(`Warning: failed to parse ${filePath}: ${getErrorMessage(err)}\n`);
-        return null;
-    }
-}
 export async function loadTsManifestEntries(filePath, site, importer = moduleHref => import(moduleHref)) {
     try {
         const src = fs.readFileSync(filePath, 'utf-8');
@@ -141,15 +102,6 @@ export async function loadTsManifestEntries(filePath, site, importer = moduleHre
         return [];
     }
 }
-/**
- * When both YAML and TS adapters exist for the same site/name,
- * prefer the TS version (it self-registers and typically has richer logic).
- */
-export function shouldReplaceManifestEntry(current, next) {
-    if (current.type === next.type)
-        return false;
-    return current.type === 'yaml' && next.type === 'ts';
-}
 export async function buildManifest() {
     const manifest = new Map();
     if (fs.existsSync(CLIS_DIR)) {
@@ -158,32 +110,13 @@ export async function buildManifest() {
             if (!fs.statSync(siteDir).isDirectory())
                 continue;
             for (const file of fs.readdirSync(siteDir)) {
-                const filePath = path.join(siteDir, file);
-                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                    const entry = scanYaml(filePath, site);
-                    if (entry) {
-                        const key = `${entry.site}/${entry.name}`;
-                        const existing = manifest.get(key);
-                        if (!existing || shouldReplaceManifestEntry(existing, entry)) {
-                            if (existing && existing.type !== entry.type) {
-                                process.stderr.write(`⚠️  Duplicate adapter ${key}: ${existing.type} superseded by ${entry.type}\n`);
-                            }
-                            manifest.set(key, entry);
-                        }
-                    }
-                }
-                else if ((file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts') && file !== 'index.ts') ||
+                if ((file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts') && file !== 'index.ts') ||
                     (file.endsWith('.js') && !file.endsWith('.d.js') && !file.endsWith('.test.js') && file !== 'index.js')) {
+                    const filePath = path.join(siteDir, file);
                     const entries = await loadTsManifestEntries(filePath, site);
                     for (const entry of entries) {
                         const key = `${entry.site}/${entry.name}`;
-                        const existing = manifest.get(key);
-                        if (!existing || shouldReplaceManifestEntry(existing, entry)) {
-                            if (existing && existing.type !== entry.type) {
-                                process.stderr.write(`⚠️  Duplicate adapter ${key}: ${existing.type} superseded by ${entry.type}\n`);
-                            }
-                            manifest.set(key, entry);
-                        }
+                        manifest.set(key, entry);
                     }
                 }
             }
@@ -195,9 +128,7 @@ async function main() {
     const manifest = await buildManifest();
     fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
     fs.writeFileSync(OUTPUT, JSON.stringify(manifest, null, 2));
-    const yamlCount = manifest.filter(e => e.type === 'yaml').length;
-    const tsCount = manifest.filter(e => e.type === 'ts').length;
-    console.log(`✅ Manifest compiled: ${manifest.length} entries (${yamlCount} YAML, ${tsCount} TS) → ${OUTPUT}`);
+    console.log(`✅ Manifest compiled: ${manifest.length} entries → ${OUTPUT}`);
     // Restore executable permissions on bin entries.
     // tsc does not preserve the +x bit, so after a clean rebuild the CLI
     // entry-point loses its executable permission, causing "Permission denied".

package/dist/src/build-manifest.test.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { cli, getRegistry, Strategy } from './registry.js';
-import { loadTsManifestEntries, shouldReplaceManifestEntry } from './build-manifest.js';
+import { loadTsManifestEntries } from './build-manifest.js';
 describe('manifest helper rules', () => {
     const tempDirs = [];
     afterEach(() => {
@@ -11,44 +11,6 @@ describe('manifest helper rules', () => {
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
-    it('prefers TS adapters over duplicate YAML adapters', () => {
-        expect(shouldReplaceManifestEntry({
-            site: 'demo',
-            name: 'search',
-            description: 'yaml',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'yaml',
-        }, {
-            site: 'demo',
-            name: 'search',
-            description: 'ts',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'ts',
-            modulePath: 'demo/search.js',
-        })).toBe(true);
-        expect(shouldReplaceManifestEntry({
-            site: 'demo',
-            name: 'search',
-            description: 'ts',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'ts',
-            modulePath: 'demo/search.js',
-        }, {
-            site: 'demo',
-            name: 'search',
-            description: 'yaml',
-            strategy: 'public',
-            browser: false,
-            args: [],
-            type: 'yaml',
-        })).toBe(false);
-    });
     it('skips TS files that do not register a cli', () => {
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
         tempDirs.push(dir);

package/dist/src/cascade.js

@@ -72,13 +72,14 @@ export async function probeEndpoint(page, url, strategy, _opts = {}) {
     try {
         const opts = PROBE_OPTIONS[strategy];
         if (opts) {
-            const resp = await page.evaluate(buildFetchProbeJs(url, opts));
+            const resp = (await page.evaluate(buildFetchProbeJs(url, opts)));
             result.statusCode = resp?.status;
-            result.success = resp?.ok && resp?.hasData;
+            result.success = !!(resp?.ok && resp?.hasData);
             result.hasData = resp?.hasData;
             result.responsePreview = resp?.preview;
         }
         else {
+            // INTERCEPT / UI require site-specific implementation.
             result.error = `Strategy ${strategy} requires site-specific implementation`;
         }
     }

package/dist/src/cli.d.ts

@@ -8,16 +8,16 @@ import { Command } from 'commander';
 import { findPackageRoot } from './package-paths.js';
 export declare function createProgram(BUILTIN_CLIS: string, USER_CLIS: string): Command;
 export declare function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void;
-export interface OperateVerifyInvocation {
+export interface BrowserVerifyInvocation {
     binary: string;
     args: string[];
     cwd: string;
     shell?: boolean;
 }
 export { findPackageRoot };
-export declare function resolveOperateVerifyInvocation(opts?: {
+export declare function resolveBrowserVerifyInvocation(opts?: {
     projectRoot?: string;
     platform?: NodeJS.Platform;
     fileExists?: (path: string) => boolean;
     readFile?: (path: string) => string;
-}): OperateVerifyInvocation;
+}): BrowserVerifyInvocation;

package/dist/src/cli.js

@@ -19,13 +19,13 @@ import { printCompletionScript } from './completion.js';
 import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled } from './external.js';
 import { registerAllCommands } from './commanderAdapter.js';
 import { EXIT_CODES, getErrorMessage } from './errors.js';
-import { daemonStatus, daemonStop, daemonRestart } from './commands/daemon.js';
+import { daemonStop } from './commands/daemon.js';
 const CLI_FILE = fileURLToPath(import.meta.url);
-/** Create a browser page for operate commands. Uses 'operate' workspace for session persistence. */
-async function getOperatePage() {
+/** Create a browser page for browser commands. Uses a dedicated browser workspace for session persistence. */
+async function getBrowserPage() {
     const { BrowserBridge } = await import('./browser/index.js');
     const bridge = new BrowserBridge();
-    return bridge.connect({ timeout: 30, workspace: 'operate:default' });
+    return bridge.connect({ timeout: 30, workspace: 'browser:default' });
 }
 function applyVerbose(opts) {
     if (opts.verbose)
@@ -171,24 +171,30 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     });
     program
         .command('generate')
-        .description('One-shot: explore → synthesize → register')
+        .description('One-shot: explore → synthesize → verify → register')
         .argument('<url>')
         .option('--goal <text>')
         .option('--site <name>')
+        .option('--format <fmt>', 'Output format: table, json', 'table')
+        .option('--no-register', 'Verify the generated adapter without registering it')
         .option('-v, --verbose', 'Debug output')
         .action(async (url, opts) => {
         applyVerbose(opts);
-        const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js');
+        const { generateVerifiedFromUrl, renderGenerateVerifiedSummary } = await import('./generate-verified.js');
         const workspace = `generate:${inferHost(url, opts.site)}`;
-        const r = await generateCliFromUrl({
+        const r = await generateVerifiedFromUrl({
             url,
             BrowserFactory: getBrowserFactory(),
             goal: opts.goal,
             site: opts.site,
             workspace,
+            noRegister: opts.register === false,
         });
-        console.log(renderGenerateSummary(r));
-        process.exitCode = r.ok ? EXIT_CODES.SUCCESS : EXIT_CODES.GENERIC_ERROR;
+        if (opts.format === 'json')
+            console.log(JSON.stringify(r, null, 2));
+        else
+            console.log(renderGenerateVerifiedSummary(r));
+        process.exitCode = r.status === 'success' ? EXIT_CODES.SUCCESS : EXIT_CODES.GENERIC_ERROR;
     });
     // ── Built-in: record ─────────────────────────────────────────────────────
     program
@@ -235,22 +241,22 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         }, { workspace });
         console.log(renderCascadeResult(result));
     });
-    // ── Built-in: operate (browser control for Claude Code skill) ───────────────
+    // ── Built-in: browser (browser control for Claude Code skill) ───────────────
     //
     // Make websites accessible for AI agents.
-    // All commands wrapped in operateAction() for consistent error handling.
-    const operate = program
-        .command('operate')
+    // All commands wrapped in browserAction() for consistent error handling.
+    const browser = program
+        .command('browser')
         .description('Browser control — navigate, click, type, extract, wait (no LLM needed)');
-    /** Wrap operate actions with error handling and optional --json output */
-    function operateAction(fn) {
+    /** Wrap browser actions with error handling and optional --json output */
+    function browserAction(fn) {
         return async (...args) => {
             try {
-                const page = await getOperatePage();
+                const page = await getBrowserPage();
                 await fn(page, ...args);
             }
             catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
+                const msg = getErrorMessage(err);
                 if (msg.includes('Extension not connected') || msg.includes('Daemon')) {
                     console.error(`Browser not connected. Run 'opencli doctor' to diagnose.`);
                 }
@@ -267,8 +273,8 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     // ── Navigation ──
     /** Network interceptor JS — injected on every open/navigate to capture fetch/XHR */
     const NETWORK_INTERCEPTOR_JS = `(function(){if(window.__opencli_net)return;window.__opencli_net=[];var M=200,B=50000,F=window.fetch;window.fetch=async function(){var r=await F.apply(this,arguments);try{var ct=r.headers.get('content-type')||'';if(ct.includes('json')||ct.includes('text')){var c=r.clone(),t=await c.text();if(window.__opencli_net.length<M){var b=null;if(t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:r.url||(arguments[0]&&arguments[0].url)||String(arguments[0]),method:(arguments[1]&&arguments[1].method)||'GET',status:r.status,size:t.length,ct:ct,body:b})}}}catch(e){}return r};var X=XMLHttpRequest.prototype,O=X.open,S=X.send;X.open=function(m,u){this._om=m;this._ou=u;return O.apply(this,arguments)};X.send=function(){var x=this;x.addEventListener('load',function(){try{var ct=x.getResponseHeader('content-type')||'';if((ct.includes('json')||ct.includes('text'))&&window.__opencli_net.length<M){var t=x.responseText,b=null;if(t&&t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:x._ou,method:x._om||'GET',status:x.status,size:t?t.length:0,ct:ct,body:b})}}catch(e){}});return S.apply(this,arguments)}})()`;
-    operate.command('open').argument('<url>').description('Open URL in automation window')
-        .action(operateAction(async (page, url) => {
+    browser.command('open').argument('<url>').description('Open URL in automation window')
+        .action(browserAction(async (page, url) => {
         // Start session-level capture before navigation (catches initial requests)
         const hasSessionCapture = await page.startNetworkCapture?.().then(() => true).catch(() => false);
         await page.goto(url);
@@ -282,15 +288,15 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         }
         console.log(`Navigated to: ${await page.getCurrentUrl?.() ?? url}`);
     }));
-    operate.command('back').description('Go back in browser history')
-        .action(operateAction(async (page) => {
+    browser.command('back').description('Go back in browser history')
+        .action(browserAction(async (page) => {
         await page.evaluate('history.back()');
         await page.wait(2);
         console.log('Navigated back');
     }));
-    operate.command('scroll').argument('<direction>', 'up or down').option('--amount <pixels>', 'Pixels to scroll', '500')
+    browser.command('scroll').argument('<direction>', 'up or down').option('--amount <pixels>', 'Pixels to scroll', '500')
         .description('Scroll page')
-        .action(operateAction(async (page, direction, opts) => {
+        .action(browserAction(async (page, direction, opts) => {
         if (direction !== 'up' && direction !== 'down') {
             console.error(`Invalid direction "${direction}". Use "up" or "down".`);
             process.exitCode = EXIT_CODES.USAGE_ERROR;
@@ -300,16 +306,16 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         console.log(`Scrolled ${direction}`);
     }));
     // ── Inspect ──
-    operate.command('state').description('Page state: URL, title, interactive elements with [N] indices')
-        .action(operateAction(async (page) => {
+    browser.command('state').description('Page state: URL, title, interactive elements with [N] indices')
+        .action(browserAction(async (page) => {
         const snapshot = await page.snapshot({ viewportExpand: 2000 });
         const url = await page.getCurrentUrl?.() ?? '';
         console.log(`URL: ${url}\n`);
         console.log(typeof snapshot === 'string' ? snapshot : JSON.stringify(snapshot, null, 2));
     }));
-    operate.command('screenshot').argument('[path]', 'Save to file (base64 if omitted)')
+    browser.command('screenshot').argument('[path]', 'Save to file (base64 if omitted)')
         .description('Take screenshot')
-        .action(operateAction(async (page, path) => {
+        .action(browserAction(async (page, path) => {
         if (path) {
             await page.screenshot({ path });
             console.log(`Screenshot saved to: ${path}`);
@@ -319,45 +325,45 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         }
     }));
     // ── Get commands (structured data extraction) ──
-    const get = operate.command('get').description('Get page properties');
+    const get = browser.command('get').description('Get page properties');
     get.command('title').description('Page title')
-        .action(operateAction(async (page) => {
+        .action(browserAction(async (page) => {
         console.log(await page.evaluate('document.title'));
     }));
     get.command('url').description('Current page URL')
-        .action(operateAction(async (page) => {
+        .action(browserAction(async (page) => {
         console.log(await page.getCurrentUrl?.() ?? await page.evaluate('location.href'));
     }));
     get.command('text').argument('<index>', 'Element index').description('Element text content')
-        .action(operateAction(async (page, index) => {
+        .action(browserAction(async (page, index) => {
         const text = await page.evaluate(`document.querySelector('[data-opencli-ref="${index}"]')?.textContent?.trim()`);
         console.log(text ?? '(empty)');
     }));
     get.command('value').argument('<index>', 'Element index').description('Input/textarea value')
-        .action(operateAction(async (page, index) => {
+        .action(browserAction(async (page, index) => {
         const val = await page.evaluate(`document.querySelector('[data-opencli-ref="${index}"]')?.value`);
         console.log(val ?? '(empty)');
     }));
     get.command('html').option('--selector <css>', 'CSS selector scope').description('Page HTML (or scoped)')
-        .action(operateAction(async (page, opts) => {
+        .action(browserAction(async (page, opts) => {
         const sel = opts.selector ? JSON.stringify(opts.selector) : 'null';
         const html = await page.evaluate(`(${sel} ? document.querySelector(${sel})?.outerHTML : document.documentElement.outerHTML)?.slice(0, 50000)`);
         console.log(html ?? '(empty)');
     }));
     get.command('attributes').argument('<index>', 'Element index').description('Element attributes')
-        .action(operateAction(async (page, index) => {
+        .action(browserAction(async (page, index) => {
         const attrs = await page.evaluate(`JSON.stringify(Object.fromEntries([...document.querySelector('[data-opencli-ref="${index}"]')?.attributes].map(a=>[a.name,a.value])))`);
         console.log(attrs ?? '{}');
     }));
     // ── Interact ──
-    operate.command('click').argument('<index>', 'Element index from state').description('Click element by index')
-        .action(operateAction(async (page, index) => {
+    browser.command('click').argument('<index>', 'Element index from state').description('Click element by index')
+        .action(browserAction(async (page, index) => {
         await page.click(index);
         console.log(`Clicked element [${index}]`);
     }));
-    operate.command('type').argument('<index>', 'Element index').argument('<text>', 'Text to type')
+    browser.command('type').argument('<index>', 'Element index').argument('<text>', 'Text to type')
         .description('Click element, then type text')
-        .action(operateAction(async (page, index, text) => {
+        .action(browserAction(async (page, index, text) => {
         await page.click(index);
         await page.wait(0.3);
         await page.typeText(index, text);
@@ -380,9 +386,9 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             console.log(`Typed "${text}" into element [${index}]`);
         }
     }));
-    operate.command('select').argument('<index>', 'Element index of <select>').argument('<option>', 'Option text')
+    browser.command('select').argument('<index>', 'Element index of <select>').argument('<option>', 'Option text')
         .description('Select dropdown option')
-        .action(operateAction(async (page, index, option) => {
+        .action(browserAction(async (page, index, option) => {
         const result = await page.evaluate(`
         (function() {
           var sel = document.querySelector('[data-opencli-ref="${index}"]');
@@ -404,19 +410,19 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             console.log(`Selected "${result?.selected}" in element [${index}]`);
         }
     }));
-    operate.command('keys').argument('<key>', 'Key to press (Enter, Escape, Tab, Control+a)')
+    browser.command('keys').argument('<key>', 'Key to press (Enter, Escape, Tab, Control+a)')
         .description('Press keyboard key')
-        .action(operateAction(async (page, key) => {
+        .action(browserAction(async (page, key) => {
         await page.pressKey(key);
         console.log(`Pressed: ${key}`);
     }));
     // ── Wait commands ──
-    operate.command('wait')
+    browser.command('wait')
         .argument('<type>', 'selector, text, or time')
         .argument('[value]', 'CSS selector, text string, or seconds')
         .option('--timeout <ms>', 'Timeout in milliseconds', '10000')
         .description('Wait for selector, text, or time (e.g. wait selector ".loaded", wait text "Success", wait time 3)')
-        .action(operateAction(async (page, type, value, opts) => {
+        .action(browserAction(async (page, type, value, opts) => {
         const timeout = parseInt(opts.timeout, 10);
         if (type === 'time') {
             const seconds = parseFloat(value ?? '2');
@@ -447,8 +453,8 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         }
     }));
     // ── Extract ──
-    operate.command('eval').argument('<js>', 'JavaScript code').description('Execute JS in page context, return result')
-        .action(operateAction(async (page, js) => {
+    browser.command('eval').argument('<js>', 'JavaScript code').description('Execute JS in page context, return result')
+        .action(browserAction(async (page, js) => {
         const result = await page.evaluate(js);
         if (typeof result === 'string')
             console.log(result);
@@ -456,11 +462,11 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
             console.log(JSON.stringify(result, null, 2));
     }));
     // ── Network (API discovery) ──
-    operate.command('network')
+    browser.command('network')
         .option('--detail <index>', 'Show full response body of request at index')
         .option('--all', 'Show all requests including static resources')
         .description('Show captured network requests (auto-captured since last open)')
-        .action(operateAction(async (page, opts) => {
+        .action(browserAction(async (page, opts) => {
         let items = [];
         if (page.readNetworkCapture) {
             const raw = await page.readNetworkCapture();
@@ -498,7 +504,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
                 items = JSON.parse(requests);
             }
             catch {
-                console.log('No network data captured. Run "operate open <url>" first.');
+                console.log('No network data captured. Run "browser open <url>" first.');
                 return;
             }
         }
@@ -537,7 +543,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         }
     }));
     // ── Init (adapter scaffolding) ──
-    operate.command('init')
+    browser.command('init')
         .argument('<name>', 'Adapter name in site/command format (e.g. hn/top)')
         .description('Generate adapter scaffold in ~/.opencli/clis/')
         .action(async (name) => {
@@ -563,10 +569,10 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
                 console.log(`Adapter already exists: ${filePath}`);
                 return;
             }
-            // Try to detect domain from last operate session
+            // Try to detect domain from the last browser session
             let domain = site;
             try {
-                const page = await getOperatePage();
+                const page = await getBrowserPage();
                 const url = await page.getCurrentUrl?.();
                 if (url) {
                     try {
@@ -600,7 +606,7 @@ cli({
             fs.mkdirSync(dir, { recursive: true });
             fs.writeFileSync(filePath, template, 'utf-8');
             console.log(`Created: ${filePath}`);
-            console.log(`Edit the file to implement your adapter, then run: opencli operate verify ${name}`);
+            console.log(`Edit the file to implement your adapter, then run: opencli browser verify ${name}`);
         }
         catch (err) {
             console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
@@ -608,7 +614,7 @@ cli({
         }
     });
     // ── Verify (test adapter) ──
-    operate.command('verify')
+    browser.command('verify')
         .argument('<name>', 'Adapter name in site/command format (e.g. hn/top)')
         .description('Execute an adapter and show results')
         .action(async (name) => {
@@ -630,7 +636,7 @@ cli({
             const filePath = path.join(os.homedir(), '.opencli', 'clis', site, `${command}.ts`);
             if (!fs.existsSync(filePath)) {
                 console.error(`Adapter not found: ${filePath}`);
-                console.error(`Run "opencli operate init ${name}" to create it.`);
+                console.error(`Run "opencli browser init ${name}" to create it.`);
                 process.exitCode = EXIT_CODES.GENERIC_ERROR;
                 return;
             }
@@ -641,7 +647,7 @@ cli({
             const hasLimitArg = /['"]limit['"]/.test(adapterSrc);
             const limitFlag = hasLimitArg ? ' --limit 3' : '';
             const limitArgs = hasLimitArg ? ['--limit', '3'] : [];
-            const invocation = resolveOperateVerifyInvocation();
+            const invocation = resolveBrowserVerifyInvocation();
             try {
                 const output = execFileSync(invocation.binary, [...invocation.args, site, command, ...limitArgs], {
                     cwd: invocation.cwd,
@@ -657,10 +663,12 @@ cli({
             }
             catch (err) {
                 console.log(`  Executing: opencli ${site} ${command}${limitFlag}\n`);
-                if (err.stdout)
-                    console.log(err.stdout);
-                if (err.stderr)
-                    console.error(err.stderr.slice(0, 500));
+                // execFileSync attaches captured stdout/stderr on its thrown Error.
+                const execErr = err;
+                if (execErr.stdout)
+                    console.log(String(execErr.stdout));
+                if (execErr.stderr)
+                    console.error(String(execErr.stderr).slice(0, 500));
                 console.log(`\n  ✗ Adapter failed. Fix the code and try again.`);
                 process.exitCode = EXIT_CODES.GENERIC_ERROR;
             }
@@ -671,8 +679,8 @@ cli({
         }
     });
     // ── Session ──
-    operate.command('close').description('Close the automation window')
-        .action(operateAction(async (page) => {
+    browser.command('close').description('Close the automation window')
+        .action(browserAction(async (page) => {
         await page.closeWindow?.();
         console.log('Automation window closed');
     }));
@@ -884,18 +892,10 @@ cli({
     });
     // ── Built-in: daemon ──────────────────────────────────────────────────────
     const daemonCmd = program.command('daemon').description('Manage the opencli daemon');
-    daemonCmd
-        .command('status')
-        .description('Show daemon status')
-        .action(async () => { await daemonStatus(); });
     daemonCmd
         .command('stop')
         .description('Stop the daemon')
         .action(async () => { await daemonStop(); });
-    daemonCmd
-        .command('restart')
-        .description('Restart the daemon')
-        .action(async () => { await daemonRestart(); });
     // ── External CLIs ─────────────────────────────────────────────────────────
     const externalClis = loadExternalClis();
     program
@@ -978,7 +978,7 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
     createProgram(BUILTIN_CLIS, USER_CLIS).parse();
 }
 export { findPackageRoot };
-export function resolveOperateVerifyInvocation(opts = {}) {
+export function resolveBrowserVerifyInvocation(opts = {}) {
     const platform = opts.platform ?? process.platform;
     const fileExists = opts.fileExists ?? fs.existsSync;
     const readFile = opts.readFile ?? ((filePath) => fs.readFileSync(filePath, 'utf-8'));