@jackwener/opencli 1.6.8 → 1.6.10

package/dist/src/discovery.d.ts

@@ -1,10 +1,10 @@
 /**
- * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ * CLI discovery: finds TS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers all YAML commands instantly without runtime YAML parsing.
- *    TS modules are loaded lazily only when their command is executed.
+ *    registers commands instantly. TS modules are loaded lazily only
+ *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 /** User runtime directory: ~/.opencli */

package/dist/src/discovery.js

@@ -1,17 +1,16 @@
 /**
- * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ * CLI discovery: finds TS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers all YAML commands instantly without runtime YAML parsing.
- *    TS modules are loaded lazily only when their command is executed.
+ *    registers commands instantly. TS modules are loaded lazily only
+ *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { getErrorMessage } from './errors.js';
 import { log } from './logger.js';
@@ -24,14 +23,12 @@ export const USER_CLIS_DIR = path.join(USER_OPENCLI_DIR, 'clis');
 export const PLUGINS_DIR = path.join(USER_OPENCLI_DIR, 'plugins');
 /** Matches files that register commands via cli() or lifecycle hooks */
 const PLUGIN_MODULE_PATTERN = /\b(?:cli|onStartup|onBeforeExecute|onAfterExecute)\s*\(/;
-import { parseYamlArgs } from './yaml-schema.js';
 function parseStrategy(rawStrategy, fallback = Strategy.COOKIE) {
     if (!rawStrategy)
         return fallback;
     const key = rawStrategy.toUpperCase();
     return Strategy[key] ?? fallback;
 }
-import { isRecord } from './utils.js';
 const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
 /**
  * Ensure ~/.opencli/node_modules/@jackwener/opencli symlink exists so that
@@ -140,7 +137,6 @@ export async function discoverClis(...dirs) {
 }
 /**
  * Fast-path: register commands from pre-compiled manifest.
- * YAML pipelines are inlined — zero YAML parsing at runtime.
  * TS modules are deferred — loaded lazily on first execution.
  */
 async function loadFromManifest(manifestPath, clisDir) {
@@ -148,53 +144,30 @@ async function loadFromManifest(manifestPath, clisDir) {
         const raw = await fs.promises.readFile(manifestPath, 'utf-8');
         const manifest = JSON.parse(raw);
         for (const entry of manifest) {
-            if (entry.type === 'yaml') {
-                // YAML pipelines fully inlined in manifest — register directly
-                const strategy = parseStrategy(entry.strategy);
-                const cmd = {
-                    site: entry.site,
-                    name: entry.name,
-                    aliases: entry.aliases,
-                    description: entry.description ?? '',
-                    domain: entry.domain,
-                    strategy,
-                    browser: entry.browser,
-                    args: entry.args ?? [],
-                    columns: entry.columns,
-                    pipeline: entry.pipeline,
-                    timeoutSeconds: entry.timeout,
-                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : `manifest:${entry.site}/${entry.name}`,
-                    deprecated: entry.deprecated,
-                    replacedBy: entry.replacedBy,
-                    navigateBefore: entry.navigateBefore,
-                };
-                registerCommand(cmd);
-            }
-            else if (entry.type === 'ts' && entry.modulePath) {
-                // TS adapters: register a lightweight stub.
-                // The actual module is loaded lazily on first executeCommand().
-                const strategy = parseStrategy(entry.strategy ?? 'cookie');
-                const modulePath = path.resolve(clisDir, entry.modulePath);
-                const cmd = {
-                    site: entry.site,
-                    name: entry.name,
-                    aliases: entry.aliases,
-                    description: entry.description ?? '',
-                    domain: entry.domain,
-                    strategy,
-                    browser: entry.browser ?? true,
-                    args: entry.args ?? [],
-                    columns: entry.columns,
-                    timeoutSeconds: entry.timeout,
-                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
-                    deprecated: entry.deprecated,
-                    replacedBy: entry.replacedBy,
-                    navigateBefore: entry.navigateBefore,
-                    _lazy: true,
-                    _modulePath: modulePath,
-                };
-                registerCommand(cmd);
-            }
+            if (!entry.modulePath)
+                continue;
+            const strategy = parseStrategy(entry.strategy ?? 'cookie');
+            const modulePath = path.resolve(clisDir, entry.modulePath);
+            const cmd = {
+                site: entry.site,
+                name: entry.name,
+                aliases: entry.aliases,
+                description: entry.description ?? '',
+                domain: entry.domain,
+                strategy,
+                browser: entry.browser ?? true,
+                args: entry.args ?? [],
+                columns: entry.columns,
+                pipeline: entry.pipeline,
+                timeoutSeconds: entry.timeout,
+                source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
+                deprecated: entry.deprecated,
+                replacedBy: entry.replacedBy,
+                navigateBefore: entry.navigateBefore,
+                _lazy: true,
+                _modulePath: modulePath,
+            };
+            registerCommand(cmd);
         }
         return true;
     }
@@ -223,9 +196,10 @@ async function discoverClisFromFs(dir) {
         await Promise.all(files.map(async (file) => {
             const filePath = path.join(siteDir, file);
             if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                await registerYamlCli(filePath, site);
+                log.warn(`Ignoring YAML adapter ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+                return;
             }
-            else if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
+            if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
                 (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
                 if (!(await isCliModule(filePath)))
                     return;
@@ -237,44 +211,6 @@ async function discoverClisFromFs(dir) {
     });
     await Promise.all(sitePromises);
 }
-async function registerYamlCli(filePath, defaultSite) {
-    try {
-        const raw = await fs.promises.readFile(filePath, 'utf-8');
-        const def = yaml.load(raw);
-        if (!isRecord(def))
-            return;
-        const cliDef = def;
-        const site = cliDef.site ?? defaultSite;
-        const name = cliDef.name ?? path.basename(filePath, path.extname(filePath));
-        const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
-        const strategy = parseStrategy(strategyStr);
-        const browser = cliDef.browser ?? (strategy !== Strategy.PUBLIC);
-        const args = parseYamlArgs(cliDef.args);
-        const cmd = {
-            site,
-            name,
-            aliases: isRecord(cliDef) && Array.isArray(cliDef.aliases)
-                ? cliDef.aliases.filter((value) => typeof value === 'string')
-                : undefined,
-            description: cliDef.description ?? '',
-            domain: cliDef.domain,
-            strategy,
-            browser,
-            args,
-            columns: cliDef.columns,
-            pipeline: cliDef.pipeline,
-            timeoutSeconds: cliDef.timeout,
-            source: filePath,
-            deprecated: cliDef.deprecated,
-            replacedBy: cliDef.replacedBy,
-            navigateBefore: cliDef.navigateBefore,
-        };
-        registerCommand(cmd);
-    }
-    catch (err) {
-        log.warn(`Failed to load ${filePath}: ${getErrorMessage(err)}`);
-    }
-}
 /**
  * Discover and register plugins from ~/.opencli/plugins/.
  * Each subdirectory is treated as a plugin (site = directory name).
@@ -296,7 +232,7 @@ export async function discoverPlugins() {
     }));
 }
 /**
- * Flat scan: read yaml/ts files directly in a plugin directory.
+ * Flat scan: read ts/js files directly in a plugin directory.
  * Unlike discoverClisFromFs, this does NOT expect nested site subdirectories.
  */
 async function discoverPluginDir(dir, site) {
@@ -305,9 +241,10 @@ async function discoverPluginDir(dir, site) {
     await Promise.all(files.map(async (file) => {
         const filePath = path.join(dir, file);
         if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-            await registerYamlCli(filePath, site);
+            log.warn(`Ignoring YAML plugin ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+            return;
         }
-        else if (file.endsWith('.js') && !file.endsWith('.d.js')) {
+        if (file.endsWith('.js') && !file.endsWith('.d.js')) {
             if (!(await isCliModule(filePath)))
                 return;
             await import(pathToFileURL(filePath).href).catch((err) => {

package/dist/src/doctor.d.ts

@@ -17,7 +17,9 @@ export type ConnectivityResult = {
 export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
+    daemonFlaky?: boolean;
     extensionConnected: boolean;
+    extensionFlaky?: boolean;
     extensionVersion?: string;
     connectivity?: ConnectivityResult;
     sessions?: Array<{

package/dist/src/doctor.js

@@ -5,11 +5,11 @@
  */
 import chalk from 'chalk';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
-import { checkDaemonStatus } from './browser/discover.js';
 import { BrowserBridge } from './browser/index.js';
-import { listSessions } from './browser/daemon-client.js';
+import { getDaemonHealth, listSessions } from './browser/daemon-client.js';
 import { getErrorMessage } from './errors.js';
 import { getRuntimeLabel } from './runtime-detect.js';
+const DOCTOR_LIVE_TIMEOUT_SECONDS = 8;
 /**
  * Test connectivity by attempting a real browser command.
  */
@@ -17,7 +17,7 @@ export async function checkConnectivity(opts) {
     const start = Date.now();
     try {
         const bridge = new BrowserBridge();
-        const page = await bridge.connect({ timeout: opts?.timeout ?? 8 });
+        const page = await bridge.connect({ timeout: opts?.timeout ?? DOCTOR_LIVE_TIMEOUT_SECONDS });
         // Try a simple eval to verify end-to-end connectivity
         await page.evaluate('1 + 1');
         await bridge.close();
@@ -28,33 +28,48 @@ export async function checkConnectivity(opts) {
     }
 }
 export async function runBrowserDoctor(opts = {}) {
-    // Try to auto-start daemon if it's not running, so we show accurate status.
-    let initialStatus = await checkDaemonStatus();
-    if (!initialStatus.running) {
-        try {
-            const bridge = new BrowserBridge();
-            await bridge.connect({ timeout: 5 });
-            await bridge.close();
-        }
-        catch {
-            // Auto-start failed; we'll report it below.
-        }
-    }
-    // Run the live connectivity check — it may also auto-start the daemon as a
-    // side-effect, so we read daemon status only *after* all side-effects settle.
+    // Live connectivity check doubles as auto-start (bridge.connect spawns daemon).
     let connectivity;
     if (opts.live) {
         connectivity = await checkConnectivity();
     }
-    const status = await checkDaemonStatus();
-    const sessions = opts.sessions && status.running && status.extensionConnected
+    else {
+        // No live probe — daemon may have idle-exited. Do a minimal auto-start
+        // so we don't misreport a lazy-lifecycle stop as a real failure.
+        const initialHealth = await getDaemonHealth();
+        if (initialHealth.state === 'stopped') {
+            try {
+                const bridge = new BrowserBridge();
+                await bridge.connect({ timeout: 5 });
+                await bridge.close();
+            }
+            catch {
+                // Auto-start failed; we'll report it below.
+            }
+        }
+    }
+    // Single status read *after* all side-effects (live check / auto-start) settle.
+    const health = await getDaemonHealth();
+    const daemonRunning = health.state !== 'stopped';
+    const extensionConnected = health.state === 'ready';
+    const daemonFlaky = !!(connectivity?.ok && !daemonRunning);
+    const extensionFlaky = !!(connectivity?.ok && daemonRunning && !extensionConnected);
+    const sessions = opts.sessions && health.state === 'ready'
         ? await listSessions()
         : undefined;
     const issues = [];
-    if (!status.running) {
+    if (daemonFlaky) {
+        issues.push('Daemon connectivity is unstable. The live browser test succeeded, but the daemon was no longer running immediately afterward.\n' +
+            'This usually means the daemon crashed or exited right after serving the live probe.');
+    }
+    else if (!daemonRunning) {
         issues.push('Daemon is not running. It should start automatically when you run an opencli browser command.');
     }
-    if (status.running && !status.extensionConnected) {
+    if (extensionFlaky) {
+        issues.push('Extension connection is unstable. The live browser test succeeded, but the daemon reported the extension disconnected immediately afterward.\n' +
+            'This usually means the Browser Bridge service worker is reconnecting slowly or Chrome suspended it.');
+    }
+    else if (daemonRunning && !extensionConnected) {
         issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
             'Please install the opencli Browser Bridge extension:\n' +
             '  1. Download from https://github.com/jackwener/opencli/releases\n' +
@@ -64,19 +79,22 @@ export async function runBrowserDoctor(opts = {}) {
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
-    if (status.extensionVersion && opts.cliVersion) {
-        const extMajor = status.extensionVersion.split('.')[0];
+    const extensionVersion = health.status?.extensionVersion;
+    if (extensionVersion && opts.cliVersion) {
+        const extMajor = extensionVersion.split('.')[0];
         const cliMajor = opts.cliVersion.split('.')[0];
         if (extMajor !== cliMajor) {
-            issues.push(`Extension major version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
+            issues.push(`Extension major version mismatch: extension v${extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
                 '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
         }
     }
     return {
         cliVersion: opts.cliVersion,
-        daemonRunning: status.running,
-        extensionConnected: status.extensionConnected,
-        extensionVersion: status.extensionVersion,
+        daemonRunning,
+        daemonFlaky,
+        extensionConnected,
+        extensionFlaky,
+        extensionVersion,
         connectivity,
         sessions,
         issues,
@@ -85,12 +103,22 @@ export async function runBrowserDoctor(opts = {}) {
 export function renderBrowserDoctorReport(report) {
     const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`) + chalk.dim(` (${getRuntimeLabel()})`), ''];
     // Daemon status
-    const daemonIcon = report.daemonRunning ? chalk.green('[OK]') : chalk.red('[MISSING]');
-    lines.push(`${daemonIcon} Daemon: ${report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running'}`);
+    const daemonIcon = report.daemonFlaky
+        ? chalk.yellow('[WARN]')
+        : report.daemonRunning ? chalk.green('[OK]') : chalk.red('[MISSING]');
+    const daemonLabel = report.daemonFlaky
+        ? 'unstable (running during live check, then stopped)'
+        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running';
+    lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
-    const extIcon = report.extensionConnected ? chalk.green('[OK]') : chalk.yellow('[MISSING]');
+    const extIcon = report.extensionFlaky
+        ? chalk.yellow('[WARN]')
+        : report.extensionConnected ? chalk.green('[OK]') : chalk.yellow('[MISSING]');
     const extVersion = report.extensionVersion ? chalk.dim(` (v${report.extensionVersion})`) : '';
-    lines.push(`${extIcon} Extension: ${report.extensionConnected ? 'connected' : 'not connected'}${extVersion}`);
+    const extLabel = report.extensionFlaky
+        ? 'unstable (connected during live check, then disconnected)'
+        : report.extensionConnected ? 'connected' : 'not connected';
+    lines.push(`${extIcon} Extension: ${extLabel}${extVersion}`);
     // Connectivity
     if (report.connectivity) {
         const connIcon = report.connectivity.ok ? chalk.green('[OK]') : chalk.red('[FAIL]');

package/dist/src/doctor.test.js

@@ -1,14 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockCheckDaemonStatus, mockListSessions, mockConnect, mockClose } = vi.hoisted(() => ({
-    mockCheckDaemonStatus: vi.fn(),
+const { mockGetDaemonHealth, mockListSessions, mockConnect, mockClose } = vi.hoisted(() => ({
+    mockGetDaemonHealth: vi.fn(),
     mockListSessions: vi.fn(),
     mockConnect: vi.fn(),
     mockClose: vi.fn(),
 }));
-vi.mock('./browser/discover.js', () => ({
-    checkDaemonStatus: mockCheckDaemonStatus,
-}));
 vi.mock('./browser/daemon-client.js', () => ({
+    getDaemonHealth: mockGetDaemonHealth,
     listSessions: mockListSessions,
 }));
 vi.mock('./browser/index.js', () => ({
@@ -69,23 +67,98 @@ describe('doctor report rendering', () => {
         }));
         expect(text).toContain('[SKIP] Connectivity: skipped (--no-live)');
     });
-    it('reports consistent status when live check auto-starts the daemon', async () => {
-        // checkDaemonStatus is called twice: once for auto-start check, once for final status.
-        // First call: daemon not running (triggers auto-start attempt)
-        mockCheckDaemonStatus.mockResolvedValueOnce({ running: false, extensionConnected: false });
-        // Auto-start attempt via BrowserBridge.connect fails
+    it('renders unstable extension state when live connectivity and status disagree', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            extensionConnected: true,
+            extensionFlaky: true,
+            connectivity: { ok: true, durationMs: 1234 },
+            issues: ['Extension connection is unstable.'],
+        }));
+        expect(text).toContain('[WARN] Extension: unstable');
+        expect(text).toContain('Extension connection is unstable.');
+    });
+    it('renders unstable daemon state when live connectivity and status disagree', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: false,
+            daemonFlaky: true,
+            extensionConnected: false,
+            connectivity: { ok: true, durationMs: 1234 },
+            issues: ['Daemon connectivity is unstable.'],
+        }));
+        expect(text).toContain('[WARN] Daemon: unstable');
+        expect(text).toContain('Daemon connectivity is unstable.');
+    });
+    it('reports daemon not running when no-live and auto-start fails', async () => {
+        // no-live mode: getDaemonHealth called twice (initial check + final status)
+        // Initial: stopped → triggers auto-start attempt
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
+        // Auto-start fails
         mockConnect.mockRejectedValueOnce(new Error('Could not start daemon'));
-        // Second call: daemon still not running after failed auto-start
-        mockCheckDaemonStatus.mockResolvedValueOnce({ running: false, extensionConnected: false });
+        // Final: still stopped
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
         const report = await runBrowserDoctor({ live: false });
-        // Status reflects daemon not running
         expect(report.daemonRunning).toBe(false);
         expect(report.extensionConnected).toBe(false);
-        // checkDaemonStatus called twice (initial + final)
-        expect(mockCheckDaemonStatus).toHaveBeenCalledTimes(2);
-        // Should report daemon not running
+        expect(mockGetDaemonHealth).toHaveBeenCalledTimes(2);
         expect(report.issues).toEqual(expect.arrayContaining([
             expect.stringContaining('Daemon is not running'),
         ]));
     });
+    it('reports flapping when live check succeeds but final status shows extension disconnected', async () => {
+        // Live check succeeds
+        mockConnect.mockResolvedValueOnce({
+            evaluate: vi.fn().mockResolvedValue(2),
+        });
+        mockClose.mockResolvedValueOnce(undefined);
+        // After live check, getDaemonHealth shows no-extension
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
+        const report = await runBrowserDoctor({ live: true });
+        expect(report.daemonRunning).toBe(true);
+        expect(report.extensionConnected).toBe(false);
+        expect(report.extensionFlaky).toBe(true);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Extension connection is unstable'),
+        ]));
+    });
+    it('reports daemon flapping when live check succeeds but daemon disappears afterward', async () => {
+        // Live check succeeds
+        mockConnect.mockResolvedValueOnce({
+            evaluate: vi.fn().mockResolvedValue(2),
+        });
+        mockClose.mockResolvedValueOnce(undefined);
+        // After live check, getDaemonHealth shows stopped
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
+        const report = await runBrowserDoctor({ live: true });
+        expect(report.daemonRunning).toBe(false);
+        expect(report.daemonFlaky).toBe(true);
+        expect(report.extensionConnected).toBe(false);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Daemon connectivity is unstable'),
+        ]));
+    });
+    it('uses the fast default timeout for live connectivity checks', async () => {
+        let timeoutSeen;
+        mockConnect.mockImplementationOnce(async (opts) => {
+            timeoutSeen = opts?.timeout;
+            return {
+                evaluate: vi.fn().mockResolvedValue(2),
+            };
+        });
+        mockClose.mockResolvedValueOnce(undefined);
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'ready', status: { extensionConnected: true } });
+        await runBrowserDoctor({ live: true });
+        expect(timeoutSeen).toBe(8);
+    });
+    it('skips auto-start in no-live mode when daemon is already running', async () => {
+        // no-live mode but daemon already running (no-extension)
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
+        // Final status: same
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
+        const report = await runBrowserDoctor({ live: false });
+        // Should NOT have tried auto-start since daemon was already running
+        expect(mockConnect).not.toHaveBeenCalled();
+        expect(report.daemonRunning).toBe(true);
+        expect(report.extensionConnected).toBe(false);
+    });
 });

package/dist/src/download/index.d.ts

@@ -52,7 +52,7 @@ export declare function ytdlpDownload(url: string, destPath: string, options?: Y
 /**
  * Save document content to file.
  */
-export declare function saveDocument(content: string, destPath: string, format?: 'json' | 'markdown' | 'html' | 'text', metadata?: Record<string, any>): Promise<{
+export declare function saveDocument(content: string, destPath: string, format?: 'json' | 'markdown' | 'html' | 'text', metadata?: Record<string, unknown>): Promise<{
     success: boolean;
     size: number;
     error?: string;

package/dist/src/engine.test.js

@@ -127,8 +127,7 @@ describe('discoverPlugins', () => {
         }
         catch { }
     });
-    it('discovers YAML plugins from ~/.opencli/plugins/', async () => {
-        // Create a simple YAML adapter in the plugins directory
+    it('ignores YAML files in plugin directories (YAML format removed)', async () => {
         await fs.promises.mkdir(testPluginDir, { recursive: true });
         await fs.promises.writeFile(yamlPath, `
 site: __test-plugin__
@@ -136,25 +135,17 @@ name: greeting
 description: Test plugin greeting
 strategy: public
 browser: false
-
-pipeline:
-  - evaluate: "() => [{ message: 'hello from plugin' }]"
-
-columns: [message]
 `);
         await discoverPlugins();
         const registry = getRegistry();
         const cmd = registry.get('__test-plugin__/greeting');
-        expect(cmd).toBeDefined();
-        expect(cmd.site).toBe('__test-plugin__');
-        expect(cmd.name).toBe('greeting');
-        expect(cmd.description).toBe('Test plugin greeting');
+        expect(cmd).toBeUndefined();
     });
     it('handles non-existent plugins directory gracefully', async () => {
         // discoverPlugins should not throw if ~/.opencli/plugins/ does not exist
         await expect(discoverPlugins()).resolves.not.toThrow();
     });
-    it('discovers YAML plugins from symlinked plugin directories', async () => {
+    it('ignores YAML files in symlinked plugin directories (YAML format removed)', async () => {
         await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
         await fs.promises.mkdir(symlinkTargetDir, { recursive: true });
         await fs.promises.writeFile(path.join(symlinkTargetDir, 'hello.yaml'), `
@@ -163,17 +154,11 @@ name: hello
 description: Test plugin greeting via symlink
 strategy: public
 browser: false
-
-pipeline:
-  - evaluate: "() => [{ message: 'hello from symlink plugin' }]"
-
-columns: [message]
 `);
         await fs.promises.symlink(symlinkTargetDir, symlinkPluginDir, 'dir');
         await discoverPlugins();
         const cmd = getRegistry().get('__test-plugin-symlink__/hello');
-        expect(cmd).toBeDefined();
-        expect(cmd.description).toBe('Test plugin greeting via symlink');
+        expect(cmd).toBeUndefined();
     });
     it('skips broken plugin symlinks without throwing', async () => {
         await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });

package/dist/src/execution.js

@@ -12,12 +12,11 @@
 import { Strategy, getRegistry, fullName } from './registry.js';
 import { pathToFileURL } from 'node:url';
 import { executePipeline } from './pipeline/index.js';
-import { AdapterLoadError, ArgumentError, BrowserConnectError, CommandExecutionError, getErrorMessage } from './errors.js';
+import { AdapterLoadError, ArgumentError, CommandExecutionError, getErrorMessage } from './errors.js';
 import { isDiagnosticEnabled, collectDiagnostic, emitDiagnostic } from './diagnostic.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
-import { checkDaemonStatus } from './browser/discover.js';
 import { log } from './logger.js';
 import { isElectronApp } from './electron-apps.js';
 import { probeCDP, resolveElectronEndpoint } from './launcher.js';
@@ -149,17 +148,6 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                     cdpEndpoint = await resolveElectronEndpoint(cmd.site);
                 }
             }
-            else {
-                // Browser Bridge: fail-fast when daemon is up but extension is missing.
-                // 300ms timeout avoids a full 2s wait on cold-start.
-                const status = await checkDaemonStatus({ timeout: 300 });
-                if (status.running && !status.extensionConnected) {
-                    throw new BrowserConnectError('Browser Bridge extension not connected', 'Install the Browser Bridge:\n' +
-                        '  1. Download: https://github.com/jackwener/opencli/releases\n' +
-                        '  2. In Chrome or Chromium, open chrome://extensions → Developer Mode → Load unpacked\n' +
-                        '  Then run: opencli doctor');
-                }
-            }
             ensureRequiredEnv(cmd);
             const BrowserFactory = getBrowserFactory(cmd.site);
             result = await browserSession(BrowserFactory, async (page) => {

package/dist/src/explore.js

@@ -257,7 +257,7 @@ export async function exploreUrl(url, opts) {
     return browserSession(opts.BrowserFactory, async (page) => {
         return runWithTimeout((async () => {
             // Step 1: Navigate
-            await page.startNetworkCapture?.();
+            await page.startNetworkCapture?.().catch(() => { });
             await page.goto(url);
             await page.wait(waitSeconds);
             // Step 2: Auto-scroll to trigger lazy loading intelligently