@jackwener/opencli 1.7.9 → 1.7.10

package/cli-manifest.json

@@ -8692,6 +8692,33 @@
     "modulePath": "imdb/trending.js",
     "sourceFile": "imdb/trending.js"
   },
+  {
+    "site": "instagram",
+    "name": "collection-create",
+    "description": "Create a new Instagram saved-posts collection (folder)",
+    "domain": "www.instagram.com",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "name",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "Name of the collection to create"
+      }
+    ],
+    "columns": [
+      "status",
+      "collectionId",
+      "collectionName",
+      "mediaCount"
+    ],
+    "type": "js",
+    "modulePath": "instagram/collection-create.js",
+    "sourceFile": "instagram/collection-create.js",
+    "navigateBefore": "https://www.instagram.com"
+  },
   {
     "site": "instagram",
     "name": "comment",
@@ -9078,7 +9105,7 @@
   {
     "site": "instagram",
     "name": "saved",
-    "description": "Get your saved Instagram posts",
+    "description": "Get your saved Instagram posts (optionally from a specific collection)",
     "domain": "www.instagram.com",
     "strategy": "cookie",
     "browser": true,
@@ -9089,6 +9116,12 @@
         "default": 20,
         "required": false,
         "help": "Number of saved posts"
+      },
+      {
+        "name": "collection",
+        "type": "str",
+        "required": false,
+        "help": "Collection name (case-insensitive). Omit for the default \"All posts\" feed."
       }
     ],
     "columns": [

package/clis/instagram/collection-create.js

@@ -0,0 +1,57 @@
+import { cli } from '@jackwener/opencli/registry';
+cli({
+    site: 'instagram',
+    name: 'collection-create',
+    description: 'Create a new Instagram saved-posts collection (folder)',
+    domain: 'www.instagram.com',
+    args: [
+        {
+            name: 'name',
+            required: true,
+            positional: true,
+            help: 'Name of the collection to create',
+        },
+    ],
+    columns: ['status', 'collectionId', 'collectionName', 'mediaCount'],
+    pipeline: [
+        { navigate: 'https://www.instagram.com' },
+        { evaluate: `(async () => {
+  const name = \${{ args.name | json }};
+  if (!name || !String(name).trim()) {
+    throw new Error('Collection name cannot be empty');
+  }
+  const trimmed = String(name).trim();
+  const csrf = document.cookie.match(/csrftoken=([^;]+)/)?.[1] || '';
+  if (!csrf) {
+    throw new Error('csrftoken cookie missing - make sure you are logged in to Instagram');
+  }
+  const fd = new FormData();
+  fd.append('name', trimmed);
+  fd.append('module_name', 'collection_create');
+  const res = await fetch('https://www.instagram.com/api/v1/collections/create/', {
+    method: 'POST',
+    credentials: 'include',
+    headers: {
+      'X-IG-App-ID': '936619743392459',
+      'X-CSRFToken': csrf,
+    },
+    body: fd,
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error('Failed to create collection: HTTP ' + res.status + (body ? ' - ' + body.slice(0, 200) : ''));
+  }
+  const d = await res.json();
+  if (d?.status && d.status !== 'ok') {
+    throw new Error('Instagram returned non-ok status: ' + JSON.stringify(d).slice(0, 300));
+  }
+  return [{
+    status: 'Created',
+    collectionId: String(d?.collection_id ?? ''),
+    collectionName: String(d?.collection_name ?? trimmed),
+    mediaCount: d?.collection_media_count ?? 0,
+  }];
+})()
+` },
+    ],
+});

package/clis/instagram/saved.js

@@ -2,23 +2,37 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'instagram',
     name: 'saved',
-    description: 'Get your saved Instagram posts',
+    description: 'Get your saved Instagram posts (optionally from a specific collection)',
     domain: 'www.instagram.com',
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Number of saved posts' },
+        { name: 'collection', help: 'Collection name (case-insensitive). Omit for the default "All posts" feed.' },
     ],
     columns: ['index', 'user', 'caption', 'likes', 'comments', 'type'],
     pipeline: [
         { navigate: 'https://www.instagram.com' },
         { evaluate: `(async () => {
   const limit = \${{ args.limit }};
-  const res = await fetch(
-    'https://www.instagram.com/api/v1/feed/saved/posts/',
-    {
-      credentials: 'include',
-      headers: { 'X-IG-App-ID': '936619743392459' }
+  const collectionArg = \${{ args.collection | json }};
+  const headers = { 'X-IG-App-ID': '936619743392459' };
+  const opts = { credentials: 'include', headers };
+
+  let endpoint = 'https://www.instagram.com/api/v1/feed/saved/posts/';
+  if (collectionArg && String(collectionArg).trim()) {
+    const wanted = String(collectionArg).trim().toLowerCase();
+    const listRes = await fetch('https://www.instagram.com/api/v1/collections/list/?collection_types=%5B%22MEDIA%22%2C%22ALL_MEDIA_AUTO_COLLECTION%22%5D', opts);
+    if (!listRes.ok) throw new Error('Failed to list collections: HTTP ' + listRes.status + ' - make sure you are logged in to Instagram');
+    const listData = await listRes.json();
+    const collections = listData?.items || [];
+    const match = collections.find((c) => String(c?.collection_name || '').trim().toLowerCase() === wanted);
+    if (!match) {
+      const names = collections.map((c) => c?.collection_name).filter(Boolean);
+      throw new Error('Collection not found: ' + collectionArg + '. Available: ' + (names.length ? names.join(', ') : '(none)'));
     }
-  );
+    endpoint = 'https://www.instagram.com/api/v1/feed/collection/' + encodeURIComponent(match.collection_id) + '/posts/';
+  }
+
+  const res = await fetch(endpoint, opts);
   if (!res.ok) throw new Error('HTTP ' + res.status + ' - make sure you are logged in to Instagram');
   const data = await res.json();
   return (data?.items || []).slice(0, limit).map((item, i) => {

package/dist/src/browser/bridge.d.ts

@@ -20,8 +20,6 @@ export declare class BrowserBridge implements IBrowserFactory {
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;
-    /** Poll until daemon is fully stopped (port released). */
-    private _waitForDaemonStop;
     /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
     private _pollUntilReady;
 }

package/dist/src/browser/bridge.js

@@ -1,16 +1,13 @@
 /**
  * Browser session manager — auto-spawns daemon and provides IPage.
  */
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
 import { Page } from './page.js';
 import { getDaemonHealth, requestDaemonShutdown } from './daemon-client.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { BrowserConnectError } from '../errors.js';
 import { PKG_VERSION } from '../version.js';
 import { resolveProfileContextId } from './profile.js';
+import { resolveDaemonLaunchSpec, spawnDaemonProcess, waitForDaemonStop } from './daemon-lifecycle.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
@@ -82,7 +79,7 @@ export class BrowserBridge {
                     process.stderr.write(`⚠️  Stale daemon detected (${reason}). Restarting...\n`);
                 }
                 const shutdownAccepted = await requestDaemonShutdown();
-                const portReleased = shutdownAccepted && await this._waitForDaemonStop(3000);
+                const portReleased = shutdownAccepted && await waitForDaemonStop(3000);
                 if (!portReleased) {
                     // Stale daemon replacement failed — don't blindly spawn on an occupied port
                     throw new BrowserConnectError('Stale daemon could not be replaced', `A stale daemon (${reason}) is running but did not shut down.\n` +
@@ -115,24 +112,10 @@ export class BrowserBridge {
             }
         }
         // No daemon — spawn one
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const parentDir = path.resolve(__dirname, '..');
-        const daemonTs = path.join(parentDir, 'daemon.ts');
-        const daemonJs = path.join(parentDir, 'daemon.js');
-        const isTs = fs.existsSync(daemonTs);
-        const daemonPath = isTs ? daemonTs : daemonJs;
         if (process.env.OPENCLI_VERBOSE || process.stderr.isTTY) {
             process.stderr.write('⏳ Starting daemon...\n');
         }
-        const spawnArgs = isTs
-            ? [process.execPath, '--import', 'tsx/esm', daemonPath]
-            : [process.execPath, daemonPath];
-        this._daemonProc = spawn(spawnArgs[0], spawnArgs.slice(1), {
-            detached: true,
-            stdio: 'ignore',
-            env: { ...process.env },
-        });
-        this._daemonProc.unref();
+        this._daemonProc = spawnDaemonProcess();
         // Wait for daemon + extension
         if (await this._pollUntilReady(timeoutMs, contextId))
             return;
@@ -152,18 +135,7 @@ export class BrowserBridge {
                 '  1. Download: https://github.com/jackwener/opencli/releases\n' +
                 '  2. Open chrome://extensions → Developer Mode → Load unpacked', 'extension-not-connected');
         }
-        throw new BrowserConnectError('Failed to start opencli daemon', `Try running manually:\n  node ${daemonPath}\nMake sure port ${DEFAULT_DAEMON_PORT} is available.`, 'daemon-not-running');
-    }
-    /** Poll until daemon is fully stopped (port released). */
-    async _waitForDaemonStop(timeoutMs) {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, 200));
-            const h = await getDaemonHealth();
-            if (h.state === 'stopped')
-                return true;
-        }
-        return false;
+        throw new BrowserConnectError('Failed to start opencli daemon', `Try running manually:\n  node ${resolveDaemonLaunchSpec().scriptPath}\nMake sure port ${DEFAULT_DAEMON_PORT} is available.`, 'daemon-not-running');
     }
     /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
     async _pollUntilReady(timeoutMs, contextId) {

package/dist/src/browser/daemon-lifecycle.d.ts

@@ -0,0 +1,23 @@
+import { type ChildProcess } from 'node:child_process';
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+import { type DaemonStatus } from './daemon-client.js';
+export interface DaemonLaunchSpec {
+    binary: string;
+    args: string[];
+    scriptPath: string;
+}
+export interface DaemonRestartResult {
+    previousStatus: DaemonStatus | null;
+    status: DaemonStatus | null;
+    stopped: boolean;
+    spawned: boolean;
+}
+export declare function resolveDaemonLaunchSpec(): DaemonLaunchSpec;
+export declare function spawnDaemonProcess(): ChildProcess;
+export declare function waitForDaemonStop(timeoutMs: number): Promise<boolean>;
+export declare function waitForDaemonStatus(timeoutMs: number): Promise<DaemonStatus | null>;
+export declare function restartDaemon(opts?: {
+    stopTimeoutMs?: number;
+    startTimeoutMs?: number;
+}): Promise<DaemonRestartResult>;
+export { DEFAULT_DAEMON_PORT };

package/dist/src/browser/daemon-lifecycle.js

@@ -0,0 +1,67 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+import { fetchDaemonStatus, getDaemonHealth, requestDaemonShutdown } from './daemon-client.js';
+export function resolveDaemonLaunchSpec() {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const parentDir = path.resolve(__dirname, '..');
+    const daemonTs = path.join(parentDir, 'daemon.ts');
+    const daemonJs = path.join(parentDir, 'daemon.js');
+    const isTs = fs.existsSync(daemonTs);
+    const scriptPath = isTs ? daemonTs : daemonJs;
+    return {
+        binary: process.execPath,
+        args: isTs ? ['--import', 'tsx/esm', scriptPath] : [scriptPath],
+        scriptPath,
+    };
+}
+export function spawnDaemonProcess() {
+    const launch = resolveDaemonLaunchSpec();
+    const proc = spawn(launch.binary, launch.args, {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env },
+    });
+    proc.unref();
+    return proc;
+}
+export async function waitForDaemonStop(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        await sleep(200);
+        const h = await getDaemonHealth();
+        if (h.state === 'stopped')
+            return true;
+    }
+    return false;
+}
+export async function waitForDaemonStatus(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const status = await fetchDaemonStatus({ timeout: Math.min(1000, Math.max(100, deadline - Date.now())) });
+        if (status)
+            return status;
+        await sleep(200);
+    }
+    return null;
+}
+export async function restartDaemon(opts = {}) {
+    const previousStatus = await fetchDaemonStatus();
+    let stopped = previousStatus === null;
+    if (previousStatus) {
+        const shutdownAccepted = await requestDaemonShutdown();
+        stopped = shutdownAccepted && await waitForDaemonStop(opts.stopTimeoutMs ?? 3000);
+        if (!stopped) {
+            return { previousStatus, status: previousStatus, stopped: false, spawned: false };
+        }
+    }
+    spawnDaemonProcess();
+    const status = await waitForDaemonStatus(opts.startTimeoutMs ?? 5000);
+    return { previousStatus, status, stopped, spawned: true };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export { DEFAULT_DAEMON_PORT };

package/dist/src/browser/daemon-version.d.ts

@@ -0,0 +1,4 @@
+import type { DaemonStatus } from './daemon-client.js';
+export declare function isDaemonStale(status: Pick<DaemonStatus, 'daemonVersion'> | null | undefined, cliVersion?: string): boolean;
+export declare function formatDaemonVersion(status: Pick<DaemonStatus, 'daemonVersion'> | null | undefined): string;
+export declare function staleDaemonIssue(status: Pick<DaemonStatus, 'daemonVersion'> | null | undefined, cliVersion: string): string;

package/dist/src/browser/daemon-version.js

@@ -0,0 +1,12 @@
+export function isDaemonStale(status, cliVersion) {
+    if (!status || !cliVersion)
+        return false;
+    return !status.daemonVersion || status.daemonVersion !== cliVersion;
+}
+export function formatDaemonVersion(status) {
+    return status?.daemonVersion ? `v${status.daemonVersion}` : 'version unknown';
+}
+export function staleDaemonIssue(status, cliVersion) {
+    return `Stale daemon detected: daemon ${formatDaemonVersion(status)} != CLI v${cliVersion}.\n` +
+        '  Run: opencli daemon restart';
+}

package/dist/src/cli.js

@@ -29,10 +29,11 @@ import { parseFilter, shapeMatchesFilter } from './browser/shape-filter.js';
 import { buildHtmlTreeJs } from './browser/html-tree.js';
 import { buildExtractHtmlJs, runExtractFromHtml } from './browser/extract.js';
 import { analyzeSite } from './browser/analyze.js';
-import { daemonStatus, daemonStop } from './commands/daemon.js';
+import { daemonRestart, daemonStatus, daemonStop } from './commands/daemon.js';
 import { log } from './logger.js';
 import { bindTab, BrowserCommandError, fetchDaemonStatus, sendCommand } from './browser/daemon-client.js';
 import { aliasForContextId, loadProfileConfig, renameProfile, resolveProfileContextId, setDefaultProfile } from './browser/profile.js';
+import { formatDaemonVersion, isDaemonStale } from './browser/daemon-version.js';
 const CLI_FILE = fileURLToPath(import.meta.url);
 const DEFAULT_BROWSER_WORKSPACE = 'browser:default';
 const DEFAULT_BOUND_WORKSPACE = 'bound:default';
@@ -1772,6 +1773,7 @@ cli({
         .option('--update-fixture', 'Overwrite an existing fixture with one derived from current output')
         .option('--no-fixture', 'Ignore any fixture file for this run (no value-level validation)')
         .option('--strict-memory', 'Fail (not just warn) when ~/.opencli/sites/<site>/endpoints.json or notes.md is missing')
+        .option('--trace <mode>', 'Trace capture for the adapter subprocess: off, on, retain-on-failure', 'off')
         .description('Execute an adapter and validate output; uses fixture at ~/.opencli/sites/<site>/verify/<cmd>.json when present')
         .action(async (name, opts = {}) => {
         try {
@@ -1809,10 +1811,11 @@ cli({
             const cliArgs = expandFixtureArgs(fixtureArgs);
             if (cliArgs.length === 0 && hasLimitArg)
                 cliArgs.push('--limit', '3');
-            const argDisplay = cliArgs.join(' ');
+            const traceArgs = opts.trace && opts.trace !== 'off' ? ['--trace', opts.trace] : [];
+            const argDisplay = [...cliArgs, ...traceArgs].join(' ');
             const invocation = resolveBrowserVerifyInvocation();
             // Always request JSON so we can validate structurally.
-            const execArgs = [...invocation.args, site, command, ...cliArgs, '--format', 'json'];
+            const execArgs = [...invocation.args, site, command, ...cliArgs, ...traceArgs, '--format', 'json'];
             let rawJson;
             try {
                 rawJson = execFileSync(invocation.binary, execArgs, {
@@ -2232,6 +2235,11 @@ cli({
             console.log(styleText('yellow', 'Daemon is not running. Run opencli doctor after opening Chrome.'));
             return;
         }
+        if (isDaemonStale(status, PKG_VERSION) || !Array.isArray(status.profiles)) {
+            console.log(styleText('yellow', `Daemon ${formatDaemonVersion(status)} is stale for CLI v${PKG_VERSION}.`));
+            console.log(styleText('dim', 'Run: opencli daemon restart'));
+            return;
+        }
         if (profiles.length === 0) {
             console.log(styleText('yellow', 'No Browser Bridge profiles connected.'));
             console.log(styleText('dim', 'Open a Chrome profile with the OpenCLI extension installed, then run opencli profile list again.'));
@@ -2301,6 +2309,10 @@ cli({
         .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();
     const externalCmd = program

package/dist/src/cli.test.js

@@ -4,11 +4,13 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { BrowserCommandError } from './browser/daemon-client.js';
 import { TargetError } from './browser/target-errors.js';
-const { mockBrowserConnect, mockBrowserClose, mockBindTab, mockSendCommand, browserState, } = vi.hoisted(() => ({
+import { PKG_VERSION } from './version.js';
+const { mockBrowserConnect, mockBrowserClose, mockBindTab, mockSendCommand, mockExecFileSync, browserState, } = vi.hoisted(() => ({
     mockBrowserConnect: vi.fn(),
     mockBrowserClose: vi.fn(),
     mockBindTab: vi.fn(),
     mockSendCommand: vi.fn(),
+    mockExecFileSync: vi.fn(),
     browserState: { page: null },
 }));
 vi.mock('./browser/index.js', () => {
@@ -28,6 +30,13 @@ vi.mock('./browser/daemon-client.js', async () => {
         sendCommand: mockSendCommand,
     };
 });
+vi.mock('node:child_process', async () => {
+    const actual = await vi.importActual('node:child_process');
+    return {
+        ...actual,
+        execFileSync: mockExecFileSync,
+    };
+});
 import { createProgram, findPackageRoot, normalizeVerifyRows, renderVerifyPreview, resolveBrowserVerifyInvocation, selectFreshByTimestamp } from './cli.js';
 describe('resolveBrowserVerifyInvocation', () => {
     it('prefers the built entry declared in package metadata', () => {
@@ -109,6 +118,91 @@ describe('selectFreshByTimestamp', () => {
         expect(rolled.lastSeenTs).toBe(3);
     });
 });
+describe('browser verify', () => {
+    beforeEach(() => {
+        process.exitCode = undefined;
+        mockExecFileSync.mockReset().mockReturnValue('[]');
+    });
+    it('passes --trace through to the adapter subprocess', async () => {
+        const originalHome = process.env.HOME;
+        const originalUserProfile = process.env.USERPROFILE;
+        const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-browser-verify-trace-'));
+        process.env.HOME = fakeHome;
+        process.env.USERPROFILE = fakeHome;
+        try {
+            const adapterDir = path.join(fakeHome, '.opencli', 'clis', 'hn');
+            fs.mkdirSync(adapterDir, { recursive: true });
+            fs.writeFileSync(path.join(adapterDir, 'top.js'), 'export default {};\n', 'utf-8');
+            const program = createProgram('', '');
+            await program.parseAsync(['node', 'opencli', 'browser', 'verify', 'hn/top', '--no-fixture', '--trace', 'retain-on-failure']);
+            expect(mockExecFileSync).toHaveBeenCalledTimes(1);
+            const [, execArgs] = mockExecFileSync.mock.calls[0];
+            expect(execArgs.slice(-6)).toEqual(['hn', 'top', '--trace', 'retain-on-failure', '--format', 'json']);
+        }
+        finally {
+            if (originalHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = originalHome;
+            if (originalUserProfile === undefined)
+                delete process.env.USERPROFILE;
+            else
+                process.env.USERPROFILE = originalUserProfile;
+            fs.rmSync(fakeHome, { recursive: true, force: true });
+        }
+    });
+});
+describe('profile list', () => {
+    const stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    beforeEach(() => {
+        process.exitCode = undefined;
+        stdoutSpy.mockClear();
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    it('reports stale daemon instead of no profiles when status lacks profile support', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                ok: true,
+                pid: 123,
+                uptime: 1,
+                daemonVersion: '1.7.6',
+                extensionConnected: true,
+                extensionVersion: '1.0.3',
+                pending: 0,
+                memoryMB: 20,
+                port: 19825,
+            }),
+        });
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'profile', 'list']);
+        const output = stdoutSpy.mock.calls.flat().join('\n');
+        expect(output).toContain('stale');
+        expect(output).toContain('opencli daemon restart');
+        expect(output).not.toContain('No Browser Bridge profiles connected');
+    });
+    it('keeps the empty profile message for current daemon status with no profiles', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                ok: true,
+                pid: 123,
+                uptime: 1,
+                daemonVersion: PKG_VERSION,
+                extensionConnected: false,
+                profiles: [],
+                pending: 0,
+                memoryMB: 20,
+                port: 19825,
+            }),
+        });
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'opencli', 'profile', 'list']);
+        const output = stdoutSpy.mock.calls.flat().join('\n');
+        expect(output).toContain('No Browser Bridge profiles connected');
+        expect(output).not.toContain('opencli daemon restart');
+    });
+});
 describe('browser tab targeting commands', () => {
     const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
     const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);

package/dist/src/commands/daemon.d.ts

@@ -2,6 +2,8 @@
  * CLI commands for daemon lifecycle:
  *   opencli daemon status — show daemon state
  *   opencli daemon stop   — graceful shutdown
+ *   opencli daemon restart — graceful shutdown, then start a fresh daemon
  */
 export declare function daemonStatus(): Promise<void>;
 export declare function daemonStop(): Promise<void>;
+export declare function daemonRestart(): Promise<void>;

package/dist/src/commands/daemon.js

@@ -2,11 +2,15 @@
  * CLI commands for daemon lifecycle:
  *   opencli daemon status — show daemon state
  *   opencli daemon stop   — graceful shutdown
+ *   opencli daemon restart — graceful shutdown, then start a fresh daemon
  */
 import { styleText } from 'node:util';
 import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
+import { restartDaemon } from '../browser/daemon-lifecycle.js';
 import { formatDuration } from '../download/progress.js';
 import { log } from '../logger.js';
+import { PKG_VERSION } from '../version.js';
+import { formatDaemonVersion, isDaemonStale } from '../browser/daemon-version.js';
 export async function daemonStatus() {
     const status = await fetchDaemonStatus();
     if (!status) {
@@ -18,7 +22,10 @@ export async function daemonStatus() {
         : status.extensionVersion
             ? `${styleText('green', 'connected')} ${styleText('dim', `(v${status.extensionVersion})`)}`
             : `${styleText('yellow', 'connected')} ${styleText('dim', '(version unknown)')}`;
-    console.log(`Daemon: ${styleText('green', 'running')} (PID ${status.pid})`);
+    const daemonVersion = formatDaemonVersion(status);
+    const stale = isDaemonStale(status, PKG_VERSION);
+    console.log(`Daemon: ${stale ? styleText('yellow', 'stale') : styleText('green', 'running')} (PID ${status.pid})`);
+    console.log(`Version: ${daemonVersion}${stale ? styleText('yellow', ` (CLI v${PKG_VERSION}; run: opencli daemon restart)`) : ''}`);
     console.log(`Uptime: ${formatDuration(Math.round(status.uptime * 1000))}`);
     console.log(`Extension: ${extensionLabel}`);
     if (status.profiles && status.profiles.length > 0) {
@@ -45,3 +52,31 @@ export async function daemonStop() {
         process.exitCode = 1;
     }
 }
+export async function daemonRestart() {
+    const before = await fetchDaemonStatus();
+    if (before?.profiles && before.profiles.length > 0) {
+        log.warn(`Restarting daemon will disconnect ${before.profiles.length} browser profile(s); the extension should reconnect automatically.`);
+    }
+    const result = await restartDaemon();
+    if (!result.stopped) {
+        log.error('Failed to stop daemon before restart.');
+        process.exitCode = 1;
+        return;
+    }
+    if (!result.status) {
+        log.error('Daemon restart timed out before the new daemon reported status.');
+        process.exitCode = 1;
+        return;
+    }
+    const action = result.previousStatus ? 'restarted' : 'started';
+    const version = formatDaemonVersion(result.status);
+    log.success(`Daemon ${action} on port ${result.status.port} (${version}).`);
+    if (result.status.extensionConnected) {
+        const profiles = result.status.profiles?.length ?? 0;
+        const profileText = profiles > 0 ? `; profiles connected: ${profiles}` : '';
+        log.status(`Extension connected${profileText}.`);
+    }
+    else {
+        log.warn('Daemon is running, but the Browser Bridge extension has not connected yet.');
+    }
+}

package/dist/src/commands/daemon.test.js

@@ -1,13 +1,18 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const { fetchDaemonStatusMock, requestDaemonShutdownMock, } = vi.hoisted(() => ({
+const { fetchDaemonStatusMock, requestDaemonShutdownMock, restartDaemonMock, } = vi.hoisted(() => ({
     fetchDaemonStatusMock: vi.fn(),
     requestDaemonShutdownMock: vi.fn(),
+    restartDaemonMock: vi.fn(),
 }));
 vi.mock('../browser/daemon-client.js', () => ({
     fetchDaemonStatus: fetchDaemonStatusMock,
     requestDaemonShutdown: requestDaemonShutdownMock,
 }));
-import { daemonStatus, daemonStop } from './daemon.js';
+vi.mock('../browser/daemon-lifecycle.js', () => ({
+    restartDaemon: restartDaemonMock,
+}));
+import { daemonRestart, daemonStatus, daemonStop } from './daemon.js';
+import { PKG_VERSION } from '../version.js';
 describe('daemonStatus', () => {
     let stdoutSpy;
     beforeEach(() => {
@@ -28,6 +33,7 @@ describe('daemonStatus', () => {
             ok: true,
             pid: 12345,
             uptime: 3661,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             extensionVersion: '1.6.8',
             pending: 0,
@@ -37,6 +43,7 @@ describe('daemonStatus', () => {
         await daemonStatus();
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining(`v${PKG_VERSION}`));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('v1.6.8'));
@@ -48,6 +55,7 @@ describe('daemonStatus', () => {
             ok: true,
             pid: 99,
             uptime: 120,
+            daemonVersion: PKG_VERSION,
             extensionConnected: false,
             pending: 0,
             memoryMB: 32,
@@ -61,6 +69,7 @@ describe('daemonStatus', () => {
             ok: true,
             pid: 99,
             uptime: 120,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             extensionVersion: undefined,
             pending: 0,
@@ -91,6 +100,7 @@ describe('daemonStop', () => {
             ok: true,
             pid: 12345,
             uptime: 100,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             pending: 0,
             memoryMB: 50,
@@ -106,6 +116,7 @@ describe('daemonStop', () => {
             ok: true,
             pid: 12345,
             uptime: 100,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             pending: 0,
             memoryMB: 50,
@@ -116,3 +127,93 @@ describe('daemonStop', () => {
         expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
     });
 });
+describe('daemonRestart', () => {
+    let stderrSpy;
+    beforeEach(() => {
+        stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+        restartDaemonMock.mockReset();
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        process.exitCode = undefined;
+    });
+    it('restarts a running daemon and reports the new version', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: '1.7.6',
+            extensionConnected: true,
+            profiles: [{ contextId: 'work', extensionConnected: true, pending: 0 }],
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: { daemonVersion: '1.7.6' },
+            stopped: true,
+            spawned: true,
+            status: {
+                ok: true,
+                pid: 12346,
+                uptime: 1,
+                daemonVersion: PKG_VERSION,
+                extensionConnected: true,
+                profiles: [{ contextId: 'work', extensionConnected: true, pending: 0 }],
+                pending: 0,
+                memoryMB: 51,
+                port: 19825,
+            },
+        });
+        await daemonRestart();
+        expect(restartDaemonMock).toHaveBeenCalledTimes(1);
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('will disconnect 1 browser profile'));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon restarted on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Extension connected; profiles connected: 1'));
+    });
+    it('starts a new daemon when none was running', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: null,
+            stopped: true,
+            spawned: true,
+            status: {
+                ok: true,
+                pid: 12346,
+                uptime: 1,
+                daemonVersion: PKG_VERSION,
+                extensionConnected: false,
+                pending: 0,
+                memoryMB: 51,
+                port: 19825,
+            },
+        });
+        await daemonRestart();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon started on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('extension has not connected yet'));
+    });
+    it('reports failure when the daemon cannot stop', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: '1.7.6',
+            extensionConnected: true,
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: { daemonVersion: '1.7.6' },
+            status: { daemonVersion: '1.7.6' },
+            stopped: false,
+            spawned: false,
+        });
+        await daemonRestart();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon before restart'));
+        expect(process.exitCode).toBe(1);
+    });
+});

package/dist/src/doctor.d.ts

@@ -20,6 +20,7 @@ export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
     daemonFlaky?: boolean;
+    daemonStale?: boolean;
     daemonVersion?: string;
     extensionConnected: boolean;
     extensionFlaky?: boolean;

package/dist/src/doctor.js

@@ -11,6 +11,7 @@ import { getErrorMessage } from './errors.js';
 import { getRuntimeLabel } from './runtime-detect.js';
 import { getCachedLatestExtensionVersion } from './update-check.js';
 import { aliasForContextId, loadProfileConfig } from './browser/profile.js';
+import { formatDaemonVersion, isDaemonStale, staleDaemonIssue } from './browser/daemon-version.js';
 const DOCTOR_LIVE_TIMEOUT_SECONDS = 8;
 /** Parse a semver string into [major, minor, patch]. Returns null on invalid input. */
 function parseSemver(v) {
@@ -90,6 +91,7 @@ export async function runBrowserDoctor(opts = {}) {
     const extensionConnected = health.state === 'ready';
     const daemonFlaky = !!(connectivity?.ok && !daemonRunning);
     const extensionFlaky = !!(connectivity?.ok && daemonRunning && !extensionConnected);
+    const daemonStale = isDaemonStale(health.status, opts.cliVersion);
     const profiles = health.status?.profiles;
     let sessions;
     if (opts.sessions) {
@@ -113,6 +115,9 @@ export async function runBrowserDoctor(opts = {}) {
     else if (!daemonRunning) {
         issues.push('Daemon is not running. It should start automatically when you run an opencli browser command.');
     }
+    if (daemonStale && opts.cliVersion) {
+        issues.push(staleDaemonIssue(health.status, opts.cliVersion));
+    }
     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.');
@@ -127,24 +132,12 @@ export async function runBrowserDoctor(opts = {}) {
                 '  Open that Chrome profile and make sure the OpenCLI extension is enabled.');
         }
         else {
-            const daemonVersion = health.status?.daemonVersion;
-            const isStale = opts.cliVersion && (!daemonVersion || daemonVersion !== opts.cliVersion);
-            if (isStale) {
-                const reason = daemonVersion
-                    ? `daemon v${daemonVersion} ≠ CLI v${opts.cliVersion}`
-                    : `daemon predates version reporting, CLI is v${opts.cliVersion}`;
-                issues.push(`Stale daemon detected: ${reason}.\n` +
-                    'The daemon was started by an older CLI version and may have missed the extension registration.\n' +
-                    '  Quick fix: opencli daemon stop && opencli doctor');
-            }
-            else {
-                issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
-                    'If the extension is already installed, try: opencli daemon stop && opencli doctor\n' +
-                    'If the extension is not installed:\n' +
-                    '  1. Download from https://github.com/jackwener/opencli/releases\n' +
-                    '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
-                    '  3. Click "Load unpacked" → select the extension folder');
-            }
+            issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
+                'If the extension is already installed, try: opencli daemon restart\n' +
+                'If the extension is not installed:\n' +
+                '  1. Download from https://github.com/jackwener/opencli/releases\n' +
+                '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
+                '  3. Click "Load unpacked" → select the extension folder');
         }
     }
     if (extensionConnected && !extensionVersion) {
@@ -182,6 +175,7 @@ export async function runBrowserDoctor(opts = {}) {
         cliVersion: opts.cliVersion,
         daemonRunning,
         daemonFlaky,
+        daemonStale,
         daemonVersion: health.status?.daemonVersion,
         extensionConnected,
         extensionFlaky,
@@ -198,10 +192,16 @@ export function renderBrowserDoctorReport(report) {
     // Daemon status
     const daemonIcon = report.daemonFlaky
         ? styleText('yellow', '[WARN]')
-        : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
+        : report.daemonStale
+            ? styleText('yellow', '[WARN]')
+            : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
     const daemonLabel = report.daemonFlaky
         ? 'unstable (running during live check, then stopped)'
-        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` + (report.daemonVersion ? ` (v${report.daemonVersion})` : '') : 'not running';
+        : report.daemonRunning
+            ? `running on port ${DEFAULT_DAEMON_PORT} (${report.daemonStale
+                ? `${formatDaemonVersion(report)}, stale; CLI v${report.cliVersion ?? 'unknown'}`
+                : formatDaemonVersion(report)})`
+            : 'not running';
     lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
     const extIcon = report.extensionFlaky || (report.extensionConnected && !report.extensionVersion)

package/dist/src/doctor.test.js

@@ -23,15 +23,32 @@ describe('doctor report rendering', () => {
     });
     it('renders OK-style report when daemon and extension connected', () => {
         const text = strip(renderBrowserDoctorReport({
+            cliVersion: '1.7.9',
             daemonRunning: true,
+            daemonVersion: '1.7.9',
             extensionConnected: true,
             extensionVersion: '1.6.8',
             issues: [],
         }));
         expect(text).toContain('[OK] Daemon: running on port 19825');
+        expect(text).toContain('(v1.7.9)');
         expect(text).toContain('[OK] Extension: connected (v1.6.8)');
         expect(text).toContain('Everything looks good!');
     });
+    it('renders a warning when daemon version is stale', () => {
+        const text = strip(renderBrowserDoctorReport({
+            cliVersion: '1.7.9',
+            daemonRunning: true,
+            daemonVersion: '1.7.6',
+            daemonStale: true,
+            extensionConnected: true,
+            extensionVersion: '1.0.3',
+            issues: ['Stale daemon detected: daemon v1.7.6 != CLI v1.7.9.\n  Run: opencli daemon restart'],
+        }));
+        expect(text).toContain('[WARN] Daemon: running on port 19825 (v1.7.6, stale; CLI v1.7.9)');
+        expect(text).toContain('Run: opencli daemon restart');
+        expect(text).not.toContain('Everything looks good!');
+    });
     it('renders MISSING when daemon not running', () => {
         const text = strip(renderBrowserDoctorReport({
             daemonRunning: false,
@@ -238,6 +255,24 @@ describe('doctor report rendering', () => {
             expect.stringContaining('did not report a version'),
         ]));
     });
+    it('reports an issue when daemon version differs from CLI version', async () => {
+        const status = {
+            state: 'ready',
+            status: {
+                daemonVersion: '1.7.6',
+                extensionConnected: true,
+                extensionVersion: '1.0.3',
+            },
+        };
+        mockGetDaemonHealth
+            .mockResolvedValueOnce(status)
+            .mockResolvedValueOnce(status);
+        const report = await runBrowserDoctor({ live: false, cliVersion: '1.7.9' });
+        expect(report.daemonStale).toBe(true);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Stale daemon detected: daemon v1.7.6 != CLI v1.7.9'),
+        ]));
+    });
     it('reports profile-required when multiple profiles are connected without a selection', async () => {
         const status = {
             state: 'profile-required',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.9",
+  "version": "1.7.10",
   "publishConfig": {
     "access": "public"
   },