@sovovs/bycli 2.1.12 → 2.1.14

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

@@ -87,6 +87,27 @@ export interface BrowserProfileStatus {
     pending: number;
     lastSeenAt?: number;
 }
+export type DaemonStatusProbe = {
+    kind: 'status';
+    status: DaemonStatus;
+} | {
+    kind: 'stopped';
+} | {
+    kind: 'timeout';
+} | {
+    kind: 'http_error';
+    statusCode: number;
+} | {
+    kind: 'invalid_response';
+} | {
+    kind: 'config_error';
+} | {
+    kind: 'network_error';
+};
+export declare function probeDaemonStatus(opts?: {
+    timeout?: number;
+    contextId?: string;
+}): Promise<DaemonStatusProbe>;
 export declare function fetchDaemonStatus(opts?: {
     timeout?: number;
     contextId?: string;

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

@@ -3,12 +3,10 @@
  *
  * Provides a typed send() function that posts a Command and returns a Result.
  */
-import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { sleep } from '../utils.js';
+import { resolveDaemonPort } from './daemon-config.js';
 import { classifyBrowserError } from './errors.js';
 import { resolveProfileContextId } from './profile.js';
-const DAEMON_PORT = parseInt(process.env.BYCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
 const BYCLI_HEADERS = { 'X-byCLI': '1' };
 let _idCounter = 0;
 function generateId() {
@@ -24,32 +22,69 @@ export class BrowserCommandError extends Error {
         this.name = 'BrowserCommandError';
     }
 }
-async function requestDaemon(pathname, init) {
+async function consumeDaemonResponse(pathname, init, consume, port) {
     const { timeout = 2000, headers, ...rest } = init ?? {};
+    const portResolution = port === undefined ? resolveDaemonPort() : { ok: true, port };
+    if (!portResolution.ok)
+        throw new Error('Invalid BYCLI_DAEMON_PORT configuration');
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeout);
     try {
-        return await fetch(`${DAEMON_URL}${pathname}`, {
+        const response = await fetch(`http://127.0.0.1:${portResolution.port}${pathname}`, {
             ...rest,
             headers: { ...BYCLI_HEADERS, ...headers },
             signal: controller.signal,
         });
+        return await consume(response);
     }
     finally {
         clearTimeout(timer);
     }
 }
-export async function fetchDaemonStatus(opts) {
+async function requestDaemon(pathname, init) {
+    return consumeDaemonResponse(pathname, init, async (response) => response);
+}
+function errorCode(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const candidate = error;
+    if (typeof candidate.code === 'string')
+        return candidate.code;
+    return errorCode(candidate.cause);
+}
+export async function probeDaemonStatus(opts) {
+    const portResolution = resolveDaemonPort();
+    if (!portResolution.ok)
+        return { kind: 'config_error' };
     try {
         const params = opts?.contextId ? `?contextId=${encodeURIComponent(opts.contextId)}` : '';
-        const res = await requestDaemon(`/status${params}`, { timeout: opts?.timeout ?? 2000 });
-        if (!res.ok)
-            return null;
-        return await res.json();
+        return await consumeDaemonResponse(`/status${params}`, { timeout: opts?.timeout ?? 2000 }, async (res) => {
+            if (!res.ok)
+                return { kind: 'http_error', statusCode: res.status };
+            try {
+                return { kind: 'status', status: await res.json() };
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === 'AbortError')
+                    throw error;
+                return { kind: 'invalid_response' };
+            }
+        }, portResolution.port);
     }
-    catch {
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError')
+            return { kind: 'timeout' };
+        if (errorCode(error) === 'ECONNREFUSED')
+            return { kind: 'stopped' };
+        return { kind: 'network_error' };
+    }
+}
+export async function fetchDaemonStatus(opts) {
+    const result = await probeDaemonStatus(opts);
+    if (result.kind !== 'status') {
         return null;
     }
+    return result.status;
 }
 /**
  * Unified daemon health check — single entry point for all status queries.

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

@@ -0,0 +1,9 @@
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+export type DaemonPortResolution = {
+    ok: true;
+    port: number;
+} | {
+    ok: false;
+    port: typeof DEFAULT_DAEMON_PORT;
+};
+export declare function resolveDaemonPort(raw?: string | undefined): DaemonPortResolution;

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

@@ -0,0 +1,12 @@
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+export function resolveDaemonPort(raw = process.env.BYCLI_DAEMON_PORT) {
+    if (raw === undefined)
+        return { ok: true, port: DEFAULT_DAEMON_PORT };
+    if (!/^\d+$/.test(raw))
+        return { ok: false, port: DEFAULT_DAEMON_PORT };
+    const port = Number(raw);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        return { ok: false, port: DEFAULT_DAEMON_PORT };
+    }
+    return { ok: true, port };
+}

package/dist/src/cli.js

@@ -2958,7 +2958,9 @@ cli({
     daemonCmd
         .command('status')
         .description('Show daemon status')
-        .action(async () => { await daemonStatus(); });
+        .option('--json', 'Output stable machine-readable JSON')
+        .option('--verbose', 'Include process and profile diagnostics in JSON output')
+        .action(async (opts) => { await daemonStatus(opts); });
     daemonCmd
         .command('stop')
         .description('Stop the daemon')

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

@@ -0,0 +1,60 @@
+import type { DaemonStatusProbe } from '../browser/daemon-client.js';
+export declare const DAEMON_STATUS_SCHEMA_VERSION: "1.0";
+export type DaemonStatusState = 'stopped' | 'daemon_stale' | 'extension_disconnected' | 'profile_required' | 'profile_disconnected' | 'ready' | 'degraded';
+export interface DaemonStatusIssue {
+    code: string;
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    remediation?: {
+        type: 'command';
+        command: string[];
+    };
+}
+export interface DaemonStatusReport {
+    schemaVersion: typeof DAEMON_STATUS_SCHEMA_VERSION;
+    command: 'daemon.status';
+    ok: boolean;
+    state: DaemonStatusState;
+    cli: {
+        version: string;
+    };
+    daemon: {
+        state: 'stopped' | 'running' | 'unknown';
+        version: string | null;
+        port: number;
+        stale: boolean;
+        pid?: number;
+        uptimeSeconds?: number;
+        memoryMB?: number;
+    };
+    extension: {
+        state: 'unknown' | 'disconnected' | 'connected';
+        version: string | null;
+        compatibility: 'unknown' | 'compatible' | 'incompatible';
+    };
+    profiles: {
+        connectedCount: number;
+        selectionRequired: boolean;
+        selectedContextId?: string | null;
+        items?: Array<{
+            contextId: string;
+            alias?: string;
+            selected: boolean;
+            extensionVersion: string | null;
+        }>;
+    };
+    issues: DaemonStatusIssue[];
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface DaemonStatusReportOptions {
+    cliVersion: string;
+    port: number;
+    verbose?: boolean;
+    /** Profile aliases in the persisted alias -> contextId form. */
+    profileAliases?: Record<string, string>;
+}
+export declare function buildDaemonStatusErrorReport(options: DaemonStatusReportOptions, code: string, message: string): DaemonStatusReport;
+export declare function buildDaemonStatusReport(probe: DaemonStatusProbe, options: DaemonStatusReportOptions): DaemonStatusReport;

package/dist/src/commands/daemon-status.js

@@ -0,0 +1,195 @@
+import { isDaemonStale } from '../browser/daemon-version.js';
+import { satisfiesRange } from '../plugin-manifest.js';
+export const DAEMON_STATUS_SCHEMA_VERSION = '1.0';
+function baseReport(options) {
+    return {
+        schemaVersion: DAEMON_STATUS_SCHEMA_VERSION,
+        command: 'daemon.status',
+        ok: true,
+        state: 'stopped',
+        cli: { version: options.cliVersion },
+        daemon: { state: 'stopped', version: null, port: options.port, stale: false },
+        extension: { state: 'unknown', version: null, compatibility: 'unknown' },
+        profiles: { connectedCount: 0, selectionRequired: false },
+        issues: [],
+    };
+}
+function failureReport(options, code, message) {
+    const result = baseReport(options);
+    result.ok = false;
+    result.state = 'degraded';
+    result.daemon.state = 'unknown';
+    result.error = { code, message };
+    return result;
+}
+export function buildDaemonStatusErrorReport(options, code, message) {
+    return failureReport(options, code, message);
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isOptionalBoolean(value) {
+    return value === undefined || typeof value === 'boolean';
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isProfileStatus(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const profile = value;
+    return typeof profile.contextId === 'string'
+        && typeof profile.extensionConnected === 'boolean'
+        && isFiniteNumber(profile.pending)
+        && isOptionalString(profile.extensionVersion)
+        && isOptionalString(profile.extensionCompatRange);
+}
+function isDaemonStatus(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const status = value;
+    return status.ok === true
+        && isFiniteNumber(status.pid)
+        && isFiniteNumber(status.uptime)
+        && typeof status.extensionConnected === 'boolean'
+        && isFiniteNumber(status.pending)
+        && isFiniteNumber(status.memoryMB)
+        && isFiniteNumber(status.port)
+        && isOptionalString(status.daemonVersion)
+        && isOptionalString(status.extensionVersion)
+        && isOptionalString(status.extensionCompatRange)
+        && isOptionalString(status.contextId)
+        && isOptionalBoolean(status.profileRequired)
+        && isOptionalBoolean(status.profileDisconnected)
+        && (status.profiles === undefined
+            || (Array.isArray(status.profiles) && status.profiles.every(isProfileStatus)));
+}
+function compatibilityOf(status, cliVersion) {
+    if (!status.extensionConnected || !status.extensionVersion || !status.extensionCompatRange) {
+        return 'unknown';
+    }
+    return satisfiesRange(cliVersion, status.extensionCompatRange) ? 'compatible' : 'incompatible';
+}
+function aliasForContextId(aliases, contextId) {
+    return Object.entries(aliases).find(([, id]) => id === contextId)?.[0];
+}
+function probeFailure(probe) {
+    switch (probe.kind) {
+        case 'timeout':
+            return { code: 'daemon_status_timeout', message: 'Timed out while requesting daemon status.' };
+        case 'http_error':
+            return { code: 'daemon_http_error', message: `Daemon status request failed with HTTP ${probe.statusCode}.` };
+        case 'invalid_response':
+            return { code: 'invalid_daemon_response', message: 'The daemon returned an invalid status response.' };
+        case 'config_error':
+            return { code: 'invalid_daemon_config', message: 'BYCLI_DAEMON_PORT must be an integer from 1 to 65535.' };
+        case 'network_error':
+            return { code: 'daemon_unreachable', message: 'The daemon status endpoint could not be reached.' };
+    }
+}
+export function buildDaemonStatusReport(probe, options) {
+    if (probe.kind === 'stopped')
+        return baseReport(options);
+    if (probe.kind !== 'status') {
+        const failure = probeFailure(probe);
+        return failureReport(options, failure.code, failure.message);
+    }
+    if (!isDaemonStatus(probe.status)) {
+        return failureReport(options, 'invalid_daemon_response', 'The daemon returned an invalid status response.');
+    }
+    const status = probe.status;
+    const result = baseReport(options);
+    const stale = isDaemonStale(status, options.cliVersion);
+    const compatibility = compatibilityOf(status, options.cliVersion);
+    const connectedProfiles = status.profiles?.filter((profile) => profile.extensionConnected) ?? [];
+    result.daemon = {
+        state: 'running',
+        version: status.daemonVersion ?? null,
+        port: status.port,
+        stale,
+        ...(options.verbose && {
+            pid: status.pid,
+            uptimeSeconds: status.uptime,
+            memoryMB: status.memoryMB,
+        }),
+    };
+    result.extension = {
+        state: status.extensionConnected ? 'connected' : 'disconnected',
+        version: status.extensionVersion ?? null,
+        compatibility,
+    };
+    result.profiles = {
+        connectedCount: connectedProfiles.length,
+        selectionRequired: status.profileRequired === true,
+        ...(options.verbose && {
+            selectedContextId: status.contextId ?? null,
+            items: (status.profiles ?? []).map((profile) => {
+                const alias = aliasForContextId(options.profileAliases ?? {}, profile.contextId);
+                return {
+                    contextId: profile.contextId,
+                    ...(alias !== undefined && { alias }),
+                    selected: profile.contextId === status.contextId,
+                    extensionVersion: profile.extensionVersion ?? null,
+                };
+            }),
+        }),
+    };
+    if (stale) {
+        result.issues.push({
+            code: 'daemon_stale',
+            severity: 'warning',
+            message: 'The daemon version does not match the CLI version.',
+            remediation: { type: 'command', command: ['bycli', 'daemon', 'restart'] },
+        });
+    }
+    if (!status.extensionConnected) {
+        result.issues.push({
+            code: 'extension_disconnected',
+            severity: 'warning',
+            message: 'The Browser Bridge extension is not connected.',
+        });
+    }
+    else if (!status.extensionVersion) {
+        result.issues.push({
+            code: 'extension_version_missing',
+            severity: 'warning',
+            message: 'The connected Browser Bridge extension did not report its version.',
+        });
+    }
+    if (compatibility === 'incompatible') {
+        result.issues.push({
+            code: 'extension_incompatible',
+            severity: 'warning',
+            message: 'The CLI version is incompatible with the Browser Bridge extension.',
+        });
+    }
+    if (status.profileRequired) {
+        result.issues.push({
+            code: 'profile_selection_required',
+            severity: 'warning',
+            message: 'Multiple Browser Bridge profiles are connected and no profile is selected.',
+            remediation: { type: 'command', command: ['bycli', 'profile', 'list'] },
+        });
+    }
+    if (status.profileDisconnected) {
+        result.issues.push({
+            code: 'selected_profile_disconnected',
+            severity: 'warning',
+            message: 'The selected Browser Bridge profile is disconnected.',
+            remediation: { type: 'command', command: ['bycli', 'profile', 'list'] },
+        });
+    }
+    if (stale)
+        result.state = 'daemon_stale';
+    else if (status.profileRequired)
+        result.state = 'profile_required';
+    else if (status.profileDisconnected)
+        result.state = 'profile_disconnected';
+    else if (!status.extensionConnected)
+        result.state = 'extension_disconnected';
+    else if (compatibility === 'incompatible')
+        result.state = 'degraded';
+    else
+        result.state = 'ready';
+    return result;
+}

package/dist/src/commands/daemon-status.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -4,6 +4,12 @@
  *   bycli daemon stop   — graceful shutdown
  *   bycli daemon restart — graceful shutdown, then start a fresh daemon
  */
-export declare function daemonStatus(): Promise<void>;
+export interface DaemonStatusOptions {
+    json?: boolean;
+    verbose?: boolean;
+    /** Pre-validated fast-path usage failure; keeps --json output machine-readable. */
+    usageError?: string;
+}
+export declare function daemonStatus(options?: DaemonStatusOptions): Promise<void>;
 export declare function daemonStop(): Promise<void>;
 export declare function daemonRestart(): Promise<void>;

package/dist/src/commands/daemon.js

@@ -4,13 +4,57 @@
  *   bycli daemon stop   — graceful shutdown
  *   bycli daemon restart — graceful shutdown, then start a fresh daemon
  */
-import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
+import { fetchDaemonStatus, probeDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
+import { resolveDaemonPort } from '../browser/daemon-config.js';
 import { restartDaemon } from '../browser/daemon-lifecycle.js';
+import { loadProfileConfig } from '../browser/profile.js';
 import { formatDuration } from '../download/progress.js';
+import { EXIT_CODES } from '../errors.js';
 import { log } from '../logger.js';
 import { PKG_VERSION } from '../version.js';
 import { formatDaemonVersion, isDaemonStale } from '../browser/daemon-version.js';
-export async function daemonStatus() {
+import { buildDaemonStatusErrorReport, buildDaemonStatusReport } from './daemon-status.js';
+function configuredDaemonPort() {
+    return resolveDaemonPort().port;
+}
+function jsonStatusExitCode(errorCode) {
+    if (!errorCode)
+        return EXIT_CODES.SUCCESS;
+    if (errorCode === 'daemon_status_timeout')
+        return EXIT_CODES.TEMPFAIL;
+    if (errorCode === 'invalid_daemon_response' || errorCode === 'invalid_daemon_config') {
+        return EXIT_CODES.CONFIG_ERROR;
+    }
+    return EXIT_CODES.GENERIC_ERROR;
+}
+export async function daemonStatus(options = {}) {
+    if (options.verbose && !options.json) {
+        console.error('Error: --verbose requires --json.');
+        process.exitCode = EXIT_CODES.USAGE_ERROR;
+        return;
+    }
+    if (options.json) {
+        if (options.usageError) {
+            const report = buildDaemonStatusErrorReport({
+                cliVersion: PKG_VERSION,
+                port: configuredDaemonPort(),
+            }, 'invalid_arguments', options.usageError);
+            console.log(JSON.stringify(report));
+            process.exitCode = EXIT_CODES.USAGE_ERROR;
+            return;
+        }
+        const probe = await probeDaemonStatus();
+        const profileConfig = loadProfileConfig();
+        const report = buildDaemonStatusReport(probe, {
+            cliVersion: PKG_VERSION,
+            port: configuredDaemonPort(),
+            verbose: options.verbose,
+            profileAliases: profileConfig.aliases,
+        });
+        console.log(JSON.stringify(report));
+        process.exitCode = jsonStatusExitCode(report.error?.code);
+        return;
+    }
     const status = await fetchDaemonStatus();
     if (!status) {
         console.log('Daemon: not running');

package/dist/src/main-daemon-status.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/main.js

@@ -39,6 +39,29 @@ if (typeof globalThis.Bun === 'undefined' && !isSupportedNodeVersion(process.ver
     ].join('\n'));
     process.exit(EXIT_CODES.CONFIG_ERROR);
 }
+// Fast path: passive machine-readable daemon status. Keep this before discovery,
+// hooks, proxy installation, and update checks so stdout/stderr remain API-safe
+// and the only network operation is the loopback daemon status request.
+const daemonStatusArgs = argv.slice(2);
+if (argv[0] === 'daemon'
+    && argv[1] === 'status'
+    && daemonStatusArgs.includes('--json')) {
+    const unsupportedArgs = daemonStatusArgs.filter((arg) => arg !== '--json' && arg !== '--verbose');
+    const { daemonStatus } = await import('./commands/daemon.js');
+    await daemonStatus({
+        json: true,
+        verbose: daemonStatusArgs.includes('--verbose'),
+        ...(unsupportedArgs.length > 0 && {
+            usageError: `Unsupported daemon status argument(s): ${unsupportedArgs.join(', ')}`,
+        }),
+    });
+    // console.log() may still be buffered when stdout is piped. An empty queued
+    // write completes only after the preceding JSON line has drained.
+    await new Promise((resolve, reject) => {
+        process.stdout.write('', (error) => error ? reject(error) : resolve());
+    });
+    process.exit(process.exitCode ?? EXIT_CODES.SUCCESS);
+}
 // Fast path: --version (only when it's the top-level intent, not passed to a subcommand)
 // e.g. `bycli --version` or `bycli -V`, but NOT `bycli gh --version`
 if (argv[0] === '--version' || argv[0] === '-V') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.12",
+  "version": "2.1.14",
   "publishConfig": {
     "access": "public"
   },
@@ -90,7 +90,7 @@
   "dependencies": {
     "@mozilla/readability": "^0.6.0",
     "@sovovs/bycli-recorder-core": "^0.1.0",
-    "@sovovs/wechat-article-crawler": "^1.1.0",
+    "@sovovs/wechat-article-crawler": "^1.1.3",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
     "js-yaml": "^4.1.0",

package/scripts/check-package-install.mjs

@@ -59,14 +59,14 @@ try {
     project, 'node_modules/@sovovs/bycli/package.json',
   ), 'utf8'));
   assert.equal(mainManifest.dependencies?.['@sovovs/bycli-recorder-core'], '^0.1.0');
-  assert.equal(mainManifest.dependencies?.['@sovovs/wechat-article-crawler'], '^1.1.0');
+  assert.equal(mainManifest.dependencies?.['@sovovs/wechat-article-crawler'], '^1.1.3');
 
   const coreDirectory = join(project, 'node_modules/@sovovs/bycli-recorder-core');
   const crawlerDirectoryInstalled = join(project, 'node_modules/@sovovs/wechat-article-crawler');
   const crawlerManifest = JSON.parse(readFileSync(
     join(crawlerDirectoryInstalled, 'package.json'), 'utf8',
   ));
-  assert.equal(crawlerManifest.version, '1.1.2');
+  assert.equal(crawlerManifest.version, '1.1.3');
   const projectRequire = createRequire(join(project, 'package.json'));
   const crawlerEntry = projectRequire.resolve('@sovovs/wechat-article-crawler');
   const crawlerModule = await import(pathToFileURL(crawlerEntry).href);

package/scripts/recorder.sh

@@ -1,186 +0,0 @@
-#!/usr/bin/env bash
-# 录制三端管理脚本
-#   daemon : 浏览器底座(19825),由 bycli 管理;扩展连这口
-#   be     : Recorder Local Service(19826),同源托管真实工作台 UI(dashboard/dist)
-#   web    : Umi dev server(8000),mock 模式,仅前端开发用(无真实录制)
-#
-# 用法:
-#   scripts/recorder.sh start   [daemon|be|all]       # 默认=真实录制环境(daemon+be,自动停 mock)
-#   scripts/recorder.sh start   --mock                # 仅此参数才起 mock 前端(web :8000,假数据)
-#   scripts/recorder.sh stop    [daemon|be|web|all]
-#   scripts/recorder.sh restart [daemon|be|vnc|all]   # restart all=daemon+be(不含 mock);改了 .env/dist 后用;vnc=删旧容器换新镜像
-#   scripts/recorder.sh status                        # 看三端
-#   scripts/recorder.sh build   [core|be|ui|ext|all] # 重建 dist(改源码后;all 含扩展,需手动重载)
-#
-# 真实录制(带 LLM)启动:scripts/recorder.sh start   → 打开 http://127.0.0.1:19826/workbench
-#
-# embedded_iframe 录制模式(P2,公开站页内嵌入;**本机默认开**):起 be 默认带 flag——
-#   EMBEDDED=0 scripts/recorder.sh start              # 显式关闭页内嵌入模式
-#   IFRAME_FRAME_SRC=https://juejin.cn scripts/recorder.sh restart be   # 只放该 origin(hardened)
-#   inline env 经 `env VAR=…` 注入,优先级高于 --env-file(.env 不覆盖已存在的 process env)。
-#
-# vnc 录制模式(容器内 Chromium+扩展+daemon,noVNC 投画面;**本机默认开**,需 podman + 镜像):
-#   scripts/recorder.sh build vnc                     # 构建容器镜像 bycli-verify:latest(需先 build ext + npm run build)
-#   scripts/recorder.sh restart vnc                   # 重启镜像:删旧容器(bycli-vnc),be 下次 bind 用新镜像重建(改镜像后用)
-#   VNC=0 scripts/recorder.sh restart be              # 显式关闭 vnc 模式
-#   选 VNC 模式后 be 自动 podman run 起容器、前端 iframe 投 noVNC 画面;录的数据走容器网关→be→合成链。
-set -uo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-RUN="$ROOT/.recorder-run"; mkdir -p "$RUN"
-DAEMON_PORT=19825; BE_PORT=19826; WEB_PORT=8000
-
-port_pid() { lsof -ti "tcp:$1" -sTCP:LISTEN 2>/dev/null | head -1; }
-alive()    { [ -n "${1:-}" ] && kill -0 "$1" 2>/dev/null; }
-
-# ───────────────────────── daemon(交给 bycli 管) ─────────────────────────
-need_bycli() { command -v bycli >/dev/null || { echo "✗ bycli 不在 PATH(在仓库根 npm link)"; return 1; }; }
-daemon_start()   { need_bycli || return 1; bycli daemon start   2>&1 | tail -1; }
-daemon_stop()    { need_bycli && { bycli daemon stop 2>&1 | tail -1; } || true; }
-daemon_restart() { need_bycli || return 1; bycli daemon restart 2>&1 | tail -1; }
-daemon_status()  { local p; p="$(port_pid $DAEMON_PORT)"; [ -n "$p" ] && echo "● daemon  RUNNING  :$DAEMON_PORT  pid=$p" || echo "○ daemon  stopped  :$DAEMON_PORT"; }
-
-# ───────────────────────── vnc(podman 容器,be 自动编排) ────────────────
-# 容器名与 vncOrchestrator.ts 保持一致(BYCLI_VNC_CONTAINER 覆盖,默认 bycli-vnc)。
-VNC_CONTAINER="${BYCLI_VNC_CONTAINER:-bycli-vnc}"
-VNC_IMAGE="${BYCLI_VNC_IMAGE:-bycli-verify:latest}"
-need_podman() { command -v podman >/dev/null || { echo "✗ podman 不在 PATH(VNC 模式需 podman)"; return 1; }; }
-# 重启镜像:删旧容器,be 下次 bind 时用当前镜像重建(build vnc 换镜像后调用)。
-vnc_restart() {
-  need_podman || return 1
-  [ -n "$(podman images -q "$VNC_IMAGE" 2>/dev/null)" ] || { echo "✗ 镜像 $VNC_IMAGE 不存在 → scripts/recorder.sh build vnc"; return 1; }
-  if [ -n "$(podman ps -aq -f "name=^${VNC_CONTAINER}$" 2>/dev/null)" ]; then
-    podman rm -f "$VNC_CONTAINER" >/dev/null 2>&1 && echo "✓ 已删旧容器 $VNC_CONTAINER(be 下次 bind 用新镜像 $VNC_IMAGE 重建)"
-  else
-    echo "○ 容器 $VNC_CONTAINER 未运行(be 下次 bind 会用新镜像 $VNC_IMAGE 新建)"
-  fi
-}
-vnc_stop() {
-  need_podman || return 1
-  if [ -n "$(podman ps -aq -f "name=^${VNC_CONTAINER}$" 2>/dev/null)" ]; then
-    podman rm -f "$VNC_CONTAINER" >/dev/null 2>&1 && echo "✓ vnc 容器 $VNC_CONTAINER 已删"
-  else echo "○ vnc 容器未运行"; fi
-}
-vnc_status() {
-  command -v podman >/dev/null || { echo "○ vnc     (podman 未装)"; return; }
-  local st; st="$(podman inspect "$VNC_CONTAINER" --format '{{.State.Status}}' 2>/dev/null)"
-  [ -n "$st" ] && echo "● vnc     $st  container=$VNC_CONTAINER  image=$VNC_IMAGE" || echo "○ vnc     no container  ($VNC_CONTAINER)"
-}
-
-# ───────────────────────── be(node 进程,PID 文件) ──────────────────────
-be_start() {
-  [ -f "$ROOT/dashboard-be/dist/server.js" ] || { echo "✗ be 未构建 → scripts/recorder.sh build be"; return 1; }
-  [ -f "$ROOT/dashboard-be/.env" ]           || { echo "✗ 缺 dashboard-be/.env → cp dashboard-be/.env.example dashboard-be/.env 并填值"; return 1; }
-  [ -d "$ROOT/dashboard/dist" ]              || echo "⚠ dashboard/dist 不存在,be 将 API-only(无 UI)→ scripts/recorder.sh build ui"
-  if [ -n "$(port_pid $BE_PORT)" ]; then echo "● be 已在 :$BE_PORT(先 stop/restart)"; return 0; fi
-  # embedded_iframe 模式(P2):EMBEDDED=1 → 注入 flag 开 frame-src + 前端模式选项。
-  # 经 `env VAR=…` 内联注入,优先级高于 --env-file(.env 不覆盖已存在的 process env)。
-  # 三种录制模式默认全开(本机录制工作台);显式 EMBEDDED=0 / VNC=0 可单独关。
-  # 注:只在本机 be 启动注入,不动 recorder-core 的 fail-closed 发布默认(全局 CSP 安全底线不变)。
-  local envv=()
-  if [ "${EMBEDDED:-1}" = 1 ]; then
-    envv+=(FEATURE_EMBEDDED_IFRAME_RECORDING=1)
-    [ -n "${IFRAME_FRAME_SRC:-}" ] && envv+=("RECORDER_IFRAME_FRAME_SRC=$IFRAME_FRAME_SRC")
-    echo "  ⚙ embedded_iframe 模式 ON${IFRAME_FRAME_SRC:+(frame-src=$IFRAME_FRAME_SRC)}"
-  fi
-  if [ "${VNC:-1}" = 1 ]; then
-    envv+=(FEATURE_VNC_RECORDING=1)
-    echo "  ⚙ vnc 容器模式 ON(be 自动 podman run bycli-verify:latest;需先 build vnc)"
-  fi
-  ( cd "$ROOT" && nohup env ${envv[@]+"${envv[@]}"} node --env-file=dashboard-be/.env dashboard-be/dist/server.js >"$RUN/be.log" 2>&1 & echo $! >"$RUN/be.pid" )
-  sleep 1; be_status; echo "  日志: $RUN/be.log"
-}
-be_stop() {
-  # 端口权威:pid 文件 + 实际占 19826 的进程都杀(防重复实例残留)
-  local stopped=0 pf; pf="$(cat "$RUN/be.pid" 2>/dev/null)"
-  for pid in "$pf" "$(port_pid $BE_PORT)"; do
-    if alive "$pid"; then kill "$pid" 2>/dev/null; echo "✓ be 已停(pid=$pid)"; stopped=1; fi
-  done
-  [ "$stopped" = 0 ] && echo "○ be 未运行"
-  rm -f "$RUN/be.pid"
-}
-be_restart() { be_stop; sleep 1; be_start; }
-be_status()  { local p; p="$(port_pid $BE_PORT)"; [ -n "$p" ] && echo "● be      RUNNING  http://127.0.0.1:$BE_PORT/workbench  pid=$p" || echo "○ be      stopped  :$BE_PORT"; }
-
-# ───────────────────────── web(Umi dev,mock) ───────────────────────────
-web_start() {
-  if [ -n "$(port_pid $WEB_PORT)" ]; then echo "● web 已在 :$WEB_PORT"; return 0; fi
-  ( cd "$ROOT/dashboard" && nohup npm run dev >"$RUN/web.log" 2>&1 & echo $! >"$RUN/web.pid" )
-  echo "✓ web 启动中(mock,http://127.0.0.1:$WEB_PORT)  日志: $RUN/web.log"
-}
-web_stop() {
-  local pid; pid="$(cat "$RUN/web.pid" 2>/dev/null)"; [ -z "$pid" ] && pid="$(port_pid $WEB_PORT)"
-  if alive "$pid"; then pkill -P "$pid" 2>/dev/null; kill "$pid" 2>/dev/null; echo "✓ web 已停"; else echo "○ web 未运行"; fi
-  rm -f "$RUN/web.pid"
-}
-web_restart() { web_stop; sleep 1; web_start; }
-web_status()  { local p; p="$(port_pid $WEB_PORT)"; [ -n "$p" ] && echo "● web     RUNNING  http://127.0.0.1:$WEB_PORT (mock)  pid=$p" || echo "○ web     stopped  :$WEB_PORT (mock dev)"; }
-
-# ───────────────────────── build ────────────────────────────────────────
-do_build() {
-  case "${1:-all}" in
-    core) npm --prefix "$ROOT/packages/recorder-core" run build ;;
-    be)   npm --prefix "$ROOT/dashboard-be" run build ;;
-    ui)   ( cd "$ROOT/dashboard" && npm run build ) ;;
-    ext)  ( cd "$ROOT/extension" && npm run build ) ;;
-    vnc)  # VNC 录制模式容器镜像(Chromium+扩展+daemon+x11vnc+websockify+网关);be 起容器时复用 bycli-verify:latest。
-          command -v podman >/dev/null || { echo "✗ podman 不在 PATH(VNC 模式需 podman)"; return 1; }
-          [ -f "$ROOT/extension/dist/background.js" ] || { echo "✗ 扩展未构建 → scripts/recorder.sh build ext"; return 1; }
-          [ -f "$ROOT/dist/src/daemon.js" ]            || { echo "✗ dist 未构建 → npm run build"; return 1; }
-          echo "▶ 构建 VNC 容器镜像 bycli-verify:latest(首次装 chromium 较慢)…"
-          ( cd "$ROOT" && podman build -f podman-verify/Dockerfile -t bycli-verify:latest . ) ;;
-    all)  npm --prefix "$ROOT/packages/recorder-core" run build \
-            && npm --prefix "$ROOT/dashboard-be" run build \
-            && ( cd "$ROOT/dashboard" && npm run build ) \
-            && ( cd "$ROOT/extension" && npm run build ) \
-            && echo "↻ 扩展已重建 → chrome://extensions 重载 byCLI(确认版本号刷新)" ;;
-    *) echo "build: core|be|ui|ext|vnc|all"; return 1 ;;
-  esac
-}
-
-# ───────────────────────── dispatch ─────────────────────────────────────
-action="${1:-}"; shift || true
-case "$action" in
-  start)
-    # mock 仅在显式 --mock 时启动;其余参数视作服务名
-    mock=0; svcs=()
-    for a in "$@"; do if [ "$a" = "--mock" ]; then mock=1; else svcs+=("$a"); fi; done
-    if [ "$mock" = 1 ]; then
-      echo "▶ 启动【mock 前端】(web :$WEB_PORT,假数据,无真实录制)"
-      web_start
-    elif [ ${#svcs[@]} -eq 0 ]; then
-      # 默认 = 真实录制环境:停掉 mock web(防 :8000 误测)→ 起 daemon + be
-      echo "▶ 启动【真实录制环境】(daemon + be);mock web 若在跑将被停掉以免混淆"
-      [ -n "$(port_pid $WEB_PORT)" ] && web_stop
-      daemon_start; be_start
-      echo; echo "✅ 真实录制 → http://127.0.0.1:$BE_PORT/workbench(mock 需 start --mock)"
-    else
-      [ "${svcs[0]}" = "all" ] && svcs=(daemon be)
-      for t in "${svcs[@]}"; do
-        case "$t" in
-          daemon|be) "${t}_start" ;;
-          web) echo "✗ web 是 mock,请用:scripts/recorder.sh start --mock" ;;
-          *) echo "未知服务: $t(daemon|be|all,mock 用 --mock)" ;;
-        esac
-      done
-    fi ;;
-  stop|restart)
-    # all 语义:restart 只起真实环境(daemon+be,不复活 mock,与 start 默认一致);
-    #          stop 则全停(含 mock web,teardown)。mock 启停一律显式 web/--mock。
-    if [ $# -eq 0 ]; then targets=(daemon be)
-    elif [ "${1:-}" = all ]; then
-      [ "$action" = stop ] && targets=(daemon be web) || targets=(daemon be)
-    else targets=("$@"); fi
-    [ "$action" = stop ] && targets=($(printf '%s\n' "${targets[@]}" | tail -r 2>/dev/null || printf '%s\n' "${targets[@]}"))
-    for t in "${targets[@]}"; do
-      case "$t" in daemon|be|web|vnc) "${t}_${action}" ;; *) echo "未知服务: $t(daemon|be|web|vnc|all)";; esac
-    done ;;
-  status)
-    daemon_status; be_status; web_status; vnc_status ;;
-  build)
-    do_build "${1:-all}" ;;
-  ""|-h|--help|help)
-    awk 'NR>1 && /^#/{sub(/^# ?/,"");print;next} NR>1{exit}' "${BASH_SOURCE[0]}" ;;
-  *)
-    echo "未知命令: $action(start|stop|restart|status|build)"; exit 1 ;;
-esac