remnote-bridge 0.1.10 → 0.1.12

package/dist/cli/commands/connect.js

@@ -5,6 +5,7 @@
  * - 已在运行 → 打印提示，退出码 0
  * - stale PID → 清理后正常启动
  * - 启动失败 → 退出码 1
+ * - 槽位满载 → 报错，退出码 1
  *
  * 默认使用静态文件服务器 serve 预构建 plugin。
  * --dev 模式使用 webpack-dev-server（支持 HMR）。
@@ -12,8 +13,8 @@
 import path from 'path';
 import fs from 'fs';
 import { fork } from 'child_process';
-import { loadConfig, pidFilePath, findProjectRoot } from '../config.js';
-import { checkDaemon } from '../daemon/pid.js';
+import { loadConfig, ensureGlobalDir } from '../config.js';
+import { resolveInstanceId, loadRegistry, saveRegistry, cleanStaleSlots, findSlotByInstance, allocateSlot, releaseSlot, formatSlotsFullError, } from '../daemon/registry.js';
 import { getSetupDonePath, cleanupOrphanChrome } from '../daemon/headless-browser.js';
 import { jsonOutput } from '../utils/output.js';
 function isDaemonMessage(msg) {
@@ -23,12 +24,13 @@ function isDaemonMessage(msg) {
 }
 export async function connectCommand(options = {}) {
     const { json } = options;
-    const projectRoot = findProjectRoot();
-    const config = loadConfig(projectRoot);
-    const pidPath = pidFilePath(projectRoot);
+    const instanceId = resolveInstanceId(options.instance);
+    const config = loadConfig();
+    ensureGlobalDir();
+    // headless 从全局参数 / 环境变量读取（preAction 已同步到 env）
+    const headless = process.env.REMNOTE_HEADLESS === '1';
     // headless 前置检查
-    if (options.headless) {
-        // 清理上次可能残留的孤儿 Chrome 进程
+    if (headless) {
         cleanupOrphanChrome(json ? undefined : (msg) => console.log(msg));
         const setupDonePath = getSetupDonePath();
         if (!fs.existsSync(setupDonePath)) {
@@ -43,52 +45,74 @@ export async function connectCommand(options = {}) {
             return;
         }
     }
-    // 检查是否已在运行
-    const status = checkDaemon(pidPath);
-    if (status.running) {
+    // 加载注册表并清理 stale 槽位
+    const registry = loadRegistry();
+    cleanStaleSlots(registry);
+    // 检查当前 instance 是否已在运行
+    const existing = findSlotByInstance(registry, instanceId);
+    if (existing) {
         if (json) {
             jsonOutput({
                 ok: true, command: 'connect', alreadyRunning: true,
-                pid: status.pid, wsPort: config.wsPort, devServerPort: config.devServerPort,
+                instance: instanceId,
+                pid: existing.pid, wsPort: existing.wsPort, devServerPort: existing.devServerPort,
+                configPort: existing.configPort, slotIndex: existing.index,
             });
         }
         else {
-            console.log(`守护进程已在运行（PID: ${status.pid}）`);
+            console.log(`守护进程已在运行（PID: ${existing.pid}，实例: ${instanceId}，槽位: ${existing.index}）`);
         }
         process.exitCode = 0;
         return;
     }
+    // 分配空闲槽位（先用 pid=0 占位，daemon ready 后更新）
+    const slot = allocateSlot(registry, instanceId, 0);
+    if (!slot) {
+        const error = formatSlotsFullError(registry);
+        if (json) {
+            jsonOutput({ ok: false, command: 'connect', error: '已达最大实例数上限（4），无可用槽位' });
+        }
+        else {
+            console.error(error);
+        }
+        process.exitCode = 1;
+        return;
+    }
     // fork 守护进程
     const daemonScriptJs = path.resolve(import.meta.dirname, '..', 'daemon', 'daemon.js');
     const daemonScriptTs = path.resolve(import.meta.dirname, '..', 'daemon', 'daemon.ts');
     let scriptPath;
     let execArgv = [];
-    // 判断是 ts 开发模式还是 js 构建后模式
     if (fs.existsSync(daemonScriptJs)) {
         scriptPath = daemonScriptJs;
     }
     else {
         scriptPath = daemonScriptTs;
-        // 继承父进程的 tsx loader 参数（排除 --eval 相关项）
         execArgv = process.execArgv.filter((arg) => !arg.startsWith('--eval') && !arg.includes('const '));
     }
+    // 保存预分配端口（用于后续比较是否发生回退）
+    const originalWsPort = slot.wsPort;
+    const originalDevPort = slot.devServerPort;
     if (!json) {
-        console.log('正在启动守护进程...');
+        console.log(`正在启动守护进程（实例: ${instanceId}，槽位: ${slot.index}）...`);
     }
     const child = fork(scriptPath, [], {
         detached: true,
         stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
-        cwd: projectRoot,
         execArgv,
         env: {
             ...process.env,
             REMNOTE_BRIDGE_DEV: options.dev ? '1' : '0',
-            ...(options.headless ? { REMNOTE_HEADLESS: '1' } : {}),
+            ...(headless ? { REMNOTE_HEADLESS: '1' } : {}),
             ...(options.remoteDebuggingPort ? { REMNOTE_HEADLESS_REMOTE_PORT: String(options.remoteDebuggingPort) } : {}),
+            SLOT_INDEX: String(slot.index),
+            SLOT_WS_PORT: String(slot.wsPort),
+            SLOT_DEV_PORT: String(slot.devServerPort),
+            SLOT_CONFIG_PORT: String(slot.configPort),
+            REMNOTE_BRIDGE_INSTANCE: instanceId,
         },
     });
     // 等待就绪信号，超时 60 秒
-    // 首次启动可能需要安装 remnote-plugin 依赖（npm install），在 Windows 上可能需要较长时间
     const ready = await new Promise((resolve) => {
         const timeout = setTimeout(() => {
             resolve(null);
@@ -113,37 +137,41 @@ export async function connectCommand(options = {}) {
     // 断开与子进程的连接（让 CLI 进程可以退出）
     child.unref();
     child.disconnect?.();
-    if (!ready) {
-        if (json) {
-            jsonOutput({ ok: false, command: 'connect', error: '守护进程启动超时（60 秒）' });
-        }
-        else {
-            console.error('守护进程启动超时（60 秒）');
-        }
-        process.exitCode = 1;
-        return;
-    }
-    if (ready.type === 'error') {
+    if (!ready || ready.type === 'error') {
+        // 启动失败，释放槽位
+        releaseSlot(registry, instanceId);
+        const errorMsg = !ready
+            ? '守护进程启动超时（60 秒）'
+            : ready.message;
         if (json) {
-            jsonOutput({ ok: false, command: 'connect', error: ready.message });
+            jsonOutput({ ok: false, command: 'connect', error: errorMsg });
         }
         else {
-            console.error(`守护进程启动失败: ${ready.message}`);
+            console.error(`守护进程启动失败: ${errorMsg}`);
         }
         process.exitCode = 1;
         return;
     }
+    // 更新注册表中的 PID 和实际端口（可能与预分配不同，若原端口被占用则 OS 自动分配）
+    slot.pid = ready.pid;
+    slot.wsPort = ready.wsPort;
+    slot.devServerPort = ready.devServerPort;
+    slot.configPort = ready.configPort;
+    saveRegistry(registry);
+    const portChanged = ready.wsPort !== originalWsPort || ready.devServerPort !== originalDevPort;
     if (json) {
         jsonOutput({
             ok: true, command: 'connect', alreadyRunning: false,
+            instance: instanceId,
             pid: ready.pid, wsPort: ready.wsPort, devServerPort: ready.devServerPort,
-            configPort: ready.configPort,
+            configPort: ready.configPort, slotIndex: slot.index,
             timeoutMinutes: config.daemonTimeoutMinutes,
             headless: ready.headless ?? false,
+            portChanged,
         });
     }
     else {
-        console.log(`守护进程已启动（PID: ${ready.pid}）`);
+        console.log(`守护进程已启动（PID: ${ready.pid}，实例: ${instanceId}）`);
         console.log(`  WS Server:         ws://127.0.0.1:${ready.wsPort}`);
         console.log(`  Plugin 服务:       http://localhost:${ready.devServerPort}`);
         console.log(`  配置页面:          http://127.0.0.1:${ready.configPort}`);
@@ -151,6 +179,17 @@ export async function connectCommand(options = {}) {
             console.log(`  Headless Chrome:   已启动（自动加载 Plugin）`);
         }
         console.log(`  超时: ${config.daemonTimeoutMinutes} 分钟无 CLI 交互后自动关闭`);
+        // 端口变更提示（标准模式）
+        if (ready.wsPort !== originalWsPort) {
+            console.log('');
+            console.log(`⚠ WS 端口被占用，已回退到 ${ready.wsPort}（Plugin 将自动发现新端口）`);
+        }
+        if (ready.devServerPort !== originalDevPort) {
+            console.log('');
+            console.log(`⚠ Plugin 服务端口被占用，已回退到 ${ready.devServerPort}`);
+            console.log('  请在 RemNote 中更新 Native Plugin URL 为:');
+            console.log(`    http://localhost:${ready.devServerPort}`);
+        }
     }
     process.exitCode = 0;
 }

package/dist/cli/commands/disconnect.js

@@ -5,40 +5,43 @@
  * - 守护进程运行中 → 发送 SIGTERM，等待退出
  * - 守护进程未运行 → 打印提示，退出码 0
  */
-import { pidFilePath, findProjectRoot } from '../config.js';
-import { checkDaemon, removePid } from '../daemon/pid.js';
+import { resolveInstanceId, loadRegistry, cleanStaleSlots, findSlotByInstance, releaseSlot, instancePidPath, } from '../daemon/registry.js';
+import { removePid } from '../daemon/pid.js';
 import { cleanupOrphanChrome } from '../daemon/headless-browser.js';
 import { jsonOutput } from '../utils/output.js';
 const WAIT_TIMEOUT_MS = 10_000;
 const POLL_INTERVAL_MS = 200;
 export async function disconnectCommand(options = {}) {
     const { json } = options;
-    const projectRoot = findProjectRoot();
-    const pidPath = pidFilePath(projectRoot);
-    const status = checkDaemon(pidPath);
-    if (!status.running) {
+    const instanceId = resolveInstanceId(options.instance);
+    const registry = loadRegistry();
+    cleanStaleSlots(registry);
+    const entry = findSlotByInstance(registry, instanceId);
+    if (!entry) {
         if (json) {
-            jsonOutput({ ok: true, command: 'disconnect', wasRunning: false });
+            jsonOutput({ ok: true, command: 'disconnect', wasRunning: false, instance: instanceId });
         }
         else {
-            console.log('守护进程未在运行');
+            console.log(`守护进程未在运行（实例: ${instanceId}）`);
         }
         process.exitCode = 0;
         return;
     }
-    const pid = status.pid;
+    const pid = entry.pid;
+    const pidPath = instancePidPath(entry.index);
     if (!json) {
-        console.log(`正在停止守护进程（PID: ${pid}）...`);
+        console.log(`正在停止守护进程（PID: ${pid}，实例: ${instanceId}）...`);
     }
     // 发送 SIGTERM
     try {
         process.kill(pid, 'SIGTERM');
     }
-    catch (err) {
+    catch {
         // 进程可能已经退出
         removePid(pidPath);
+        releaseSlot(registry, instanceId);
         if (json) {
-            jsonOutput({ ok: true, command: 'disconnect', wasRunning: true, pid, forced: false });
+            jsonOutput({ ok: true, command: 'disconnect', wasRunning: true, instance: instanceId, pid, forced: false });
         }
         else {
             console.log('守护进程已停止');
@@ -50,10 +53,10 @@ export async function disconnectCommand(options = {}) {
     const exited = await waitForExit(pid, WAIT_TIMEOUT_MS);
     if (exited) {
         removePid(pidPath);
-        // 清理可能残留的孤儿 headless Chrome
+        releaseSlot(registry, instanceId);
         cleanupOrphanChrome(json ? undefined : (msg) => console.log(msg));
         if (json) {
-            jsonOutput({ ok: true, command: 'disconnect', wasRunning: true, pid, forced: false });
+            jsonOutput({ ok: true, command: 'disconnect', wasRunning: true, instance: instanceId, pid, forced: false });
         }
         else {
             console.log('守护进程已停止');
@@ -68,10 +71,10 @@ export async function disconnectCommand(options = {}) {
             // 可能已退出
         }
         removePid(pidPath);
-        // daemon 被强杀后 Chrome 更可能成为孤儿，务必清理
+        releaseSlot(registry, instanceId);
         cleanupOrphanChrome(json ? undefined : (msg) => console.log(msg));
         if (json) {
-            jsonOutput({ ok: true, command: 'disconnect', wasRunning: true, pid, forced: true });
+            jsonOutput({ ok: true, command: 'disconnect', wasRunning: true, instance: instanceId, pid, forced: true });
         }
         else {
             console.error(`守护进程未在 ${WAIT_TIMEOUT_MS / 1000} 秒内退出，尝试强制终止...`);
@@ -85,9 +88,7 @@ function waitForExit(pid, timeoutMs) {
         const start = Date.now();
         const check = () => {
             try {
-                // kill(pid, 0) 不发信号，只检查进程是否存在
                 process.kill(pid, 0);
-                // 进程仍在运行
                 if (Date.now() - start >= timeoutMs) {
                     resolve(false);
                 }
@@ -96,7 +97,6 @@ function waitForExit(pid, timeoutMs) {
                 }
             }
             catch {
-                // 进程已退出
                 resolve(true);
             }
         };

package/dist/cli/commands/edit-rem.js

@@ -5,8 +5,8 @@
  * 三道防线保证安全：缓存存在性、并发检测、精确匹配。
  * - 退出码：0 成功 / 1 业务错误 / 2 守护进程不可达
  */
-import { sendDaemonRequest, DaemonNotRunningError, DaemonUnreachableError } from '../daemon/send-request.js';
-import { jsonOutput } from '../utils/output.js';
+import { sendDaemonRequest } from '../daemon/send-request.js';
+import { jsonOutput, handleCommandError } from '../utils/output.js';
 export async function editRemCommand(remId, options) {
     const { json, oldStr, newStr } = options;
     let result;
@@ -14,35 +14,7 @@ export async function editRemCommand(remId, options) {
         result = await sendDaemonRequest('edit_rem', { remId, oldStr, newStr });
     }
     catch (err) {
-        if (err instanceof DaemonNotRunningError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'edit-rem', error: err.message });
-            }
-            else {
-                console.error(`错误: ${err.message}`);
-            }
-            process.exitCode = 2;
-            return;
-        }
-        if (err instanceof DaemonUnreachableError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'edit-rem', error: err.message });
-            }
-            else {
-                console.error(`错误: ${err.message}`);
-            }
-            process.exitCode = 2;
-            return;
-        }
-        // 业务错误（防线拒绝、Plugin 未连接等）
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        if (json) {
-            jsonOutput({ ok: false, command: 'edit-rem', error: errorMsg });
-        }
-        else {
-            console.error(`错误: ${errorMsg}`);
-        }
-        process.exitCode = 1;
+        handleCommandError(err, 'edit-rem', json);
         return;
     }
     const editResult = result;

package/dist/cli/commands/edit-tree.js

@@ -6,8 +6,8 @@
  * - --json 结构化 JSON 输出
  * - 退出码：0 成功 / 1 业务错误 / 2 守护进程不可达
  */
-import { sendDaemonRequest, DaemonNotRunningError, DaemonUnreachableError } from '../daemon/send-request.js';
-import { jsonOutput } from '../utils/output.js';
+import { sendDaemonRequest } from '../daemon/send-request.js';
+import { jsonOutput, handleCommandError } from '../utils/output.js';
 export async function editTreeCommand(remId, options) {
     const { json, oldStr, newStr } = options;
     let result;
@@ -15,24 +15,7 @@ export async function editTreeCommand(remId, options) {
         result = await sendDaemonRequest('edit_tree', { remId, oldStr, newStr });
     }
     catch (err) {
-        if (err instanceof DaemonNotRunningError || err instanceof DaemonUnreachableError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'edit-tree', error: err.message });
-            }
-            else {
-                console.error(`错误: ${err.message}`);
-            }
-            process.exitCode = 2;
-            return;
-        }
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        if (json) {
-            jsonOutput({ ok: false, command: 'edit-tree', error: errorMsg });
-        }
-        else {
-            console.error(`错误: ${errorMsg}`);
-        }
-        process.exitCode = 1;
+        handleCommandError(err, 'edit-tree', json);
         return;
     }
     const data = result;

package/dist/cli/commands/health.js

@@ -6,12 +6,12 @@
  * - 部分不健康 → 退出码 1
  * - 守护进程不可达 → 退出码 2
  */
-import { findProjectRoot, pidFilePath } from '../config.js';
-import { checkDaemon } from '../daemon/pid.js';
+import { resolveInstanceId, loadRegistry, cleanStaleSlots, findSlotByInstance, } from '../daemon/registry.js';
 import { sendDaemonRequest } from '../daemon/send-request.js';
 import { jsonOutput } from '../utils/output.js';
 export async function healthCommand(options = {}) {
     const { json, diagnose, reload } = options;
+    const instanceId = resolveInstanceId(options.instance);
     // --diagnose 和 --reload 不能同时使用
     if (diagnose && reload) {
         const error = '--diagnose 和 --reload 不能同时使用';
@@ -24,21 +24,22 @@ export async function healthCommand(options = {}) {
         process.exitCode = 1;
         return;
     }
-    const projectRoot = findProjectRoot();
-    const pidPath = pidFilePath(projectRoot);
-    // 先检查 PID 文件
-    const daemonStatus = checkDaemon(pidPath);
-    if (!daemonStatus.running) {
+    // 通过注册表检查 daemon 是否运行
+    const registry = loadRegistry();
+    cleanStaleSlots(registry);
+    const entry = findSlotByInstance(registry, instanceId);
+    if (!entry) {
         if (json) {
             jsonOutput({
                 ok: false, command: 'health', exitCode: 2,
+                instance: instanceId,
                 daemon: { running: false },
                 plugin: { connected: false },
                 sdk: { ready: false },
             });
         }
         else {
-            console.log('❌ 守护进程  未运行');
+            console.log(`❌ 守护进程  未运行（实例: ${instanceId}）`);
             console.log('❌ Plugin    未连接');
             console.log('❌ SDK       不可用');
             console.log('\n提示: 执行 `remnote-bridge connect` 启动守护进程');
@@ -49,7 +50,7 @@ export async function healthCommand(options = {}) {
     // --diagnose 模式
     if (diagnose) {
         try {
-            const result = await sendDaemonRequest('diagnose');
+            const result = await sendDaemonRequest('diagnose', {}, { instance: options.instance });
             if (!result) {
                 const error = '非 headless 模式，不支持 --diagnose';
                 if (json) {
@@ -62,7 +63,7 @@ export async function healthCommand(options = {}) {
                 return;
             }
             if (json) {
-                jsonOutput({ ok: true, command: 'health', mode: 'diagnose', ...result });
+                jsonOutput({ ok: true, command: 'health', mode: 'diagnose', instance: instanceId, ...result });
             }
             else {
                 console.log('=== Headless Chrome 诊断 ===');
@@ -84,7 +85,6 @@ export async function healthCommand(options = {}) {
                         console.log(`  ${err}`);
                     }
                 }
-                // 排查建议
                 if (!result.headless.chromeConnected) {
                     console.log('\n排查建议: Chrome 已断开，尝试 `health --reload` 重载');
                 }
@@ -111,9 +111,9 @@ export async function healthCommand(options = {}) {
     // --reload 模式
     if (reload) {
         try {
-            const result = await sendDaemonRequest('headless_reload');
+            const result = await sendDaemonRequest('headless_reload', {}, { instance: options.instance });
             if (json) {
-                jsonOutput({ ok: result.ok, command: 'health', mode: 'reload', error: result.error });
+                jsonOutput({ ok: result.ok, command: 'health', mode: 'reload', instance: instanceId, error: result.error });
             }
             else {
                 if (result.ok) {
@@ -140,14 +140,15 @@ export async function healthCommand(options = {}) {
     // 通过 WS 连接守护进程获取状态
     let status;
     try {
-        status = await sendDaemonRequest('get_status');
+        status = await sendDaemonRequest('get_status', {}, { instance: options.instance });
     }
     catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
         if (json) {
             jsonOutput({
                 ok: false, command: 'health', exitCode: 2,
-                daemon: { running: true, pid: daemonStatus.pid, reachable: false },
+                instance: instanceId,
+                daemon: { running: true, pid: entry.pid, reachable: false },
                 plugin: { connected: false },
                 sdk: { ready: false },
                 error: errorMsg,
@@ -168,7 +169,8 @@ export async function healthCommand(options = {}) {
     if (json) {
         jsonOutput({
             ok: allHealthy, command: 'health', exitCode,
-            daemon: { running: true, pid: daemonStatus.pid, reachable: true, uptime: status.uptime },
+            instance: instanceId, slotIndex: entry.index,
+            daemon: { running: true, pid: entry.pid, reachable: true, uptime: status.uptime },
             plugin: { connected: status.pluginConnected },
             sdk: { ready: status.sdkReady },
             timeoutRemaining: status.timeoutRemaining,
@@ -176,7 +178,7 @@ export async function healthCommand(options = {}) {
         });
     }
     else {
-        console.log(`✅ 守护进程  运行中（PID: ${daemonStatus.pid}，已运行 ${formatUptime(status.uptime)}）`);
+        console.log(`✅ 守护进程  运行中（PID: ${entry.pid}，实例: ${instanceId}，槽位: ${entry.index}，已运行 ${formatUptime(status.uptime)}）`);
         if (status.pluginConnected) {
             console.log('✅ Plugin    已连接');
         }
@@ -189,7 +191,6 @@ export async function healthCommand(options = {}) {
         else {
             console.log('❌ SDK       未就绪');
         }
-        // Headless Chrome 状态行
         if (status.headless) {
             const h = status.headless;
             const icon = h.status === 'running' ? '✅' : '❌';

package/dist/cli/commands/read-context.js

@@ -7,10 +7,11 @@
  * - --depth N 展开深度（默认 3，仅 page 模式）
  * - --max-nodes N 全局节点上限（默认 200）
  * - --max-siblings N 每个父节点下展示的 children 上限（默认 20）
+ * - --focus-rem-id <remId> 指定鱼眼中心 Rem ID（仅 focus 模式，默认使用当前焦点）
  * - --json 结构化 JSON 输出
  */
-import { sendDaemonRequest, DaemonNotRunningError, DaemonUnreachableError } from '../daemon/send-request.js';
-import { jsonOutput } from '../utils/output.js';
+import { sendDaemonRequest } from '../daemon/send-request.js';
+import { jsonOutput, handleCommandError } from '../utils/output.js';
 export async function readContextCommand(options = {}) {
     const { json } = options;
     const mode = options.mode || 'focus';
@@ -42,29 +43,13 @@ export async function readContextCommand(options = {}) {
     }
     let result;
     try {
-        result = await sendDaemonRequest('read_context', {
-            mode, ancestorLevels, depth, maxNodes, maxSiblings,
-        });
+        const reqPayload = { mode, ancestorLevels, depth, maxNodes, maxSiblings };
+        if (options.focusRemId)
+            reqPayload.focusRemId = options.focusRemId;
+        result = await sendDaemonRequest('read_context', reqPayload);
     }
     catch (err) {
-        if (err instanceof DaemonNotRunningError || err instanceof DaemonUnreachableError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'read-context', error: err.message });
-            }
-            else {
-                console.error(`错误: ${err.message}`);
-            }
-            process.exitCode = 2;
-            return;
-        }
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        if (json) {
-            jsonOutput({ ok: false, command: 'read-context', error: errorMsg });
-        }
-        else {
-            console.error(`错误: ${errorMsg}`);
-        }
-        process.exitCode = 1;
+        handleCommandError(err, 'read-context', json);
         return;
     }
     const data = result;

package/dist/cli/commands/read-globe.js

@@ -7,8 +7,8 @@
  * - --max-siblings N 每个父节点下展示的 children 上限（默认 20）
  * - --json 结构化 JSON 输出
  */
-import { sendDaemonRequest, DaemonNotRunningError, DaemonUnreachableError } from '../daemon/send-request.js';
-import { jsonOutput } from '../utils/output.js';
+import { sendDaemonRequest } from '../daemon/send-request.js';
+import { jsonOutput, handleCommandError } from '../utils/output.js';
 export async function readGlobeCommand(options = {}) {
     const { json } = options;
     const depth = options.depth !== undefined ? parseInt(options.depth, 10) : undefined;
@@ -30,24 +30,7 @@ export async function readGlobeCommand(options = {}) {
         result = await sendDaemonRequest('read_globe', { depth, maxNodes, maxSiblings });
     }
     catch (err) {
-        if (err instanceof DaemonNotRunningError || err instanceof DaemonUnreachableError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'read-globe', error: err.message });
-            }
-            else {
-                console.error(`错误: ${err.message}`);
-            }
-            process.exitCode = 2;
-            return;
-        }
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        if (json) {
-            jsonOutput({ ok: false, command: 'read-globe', error: errorMsg });
-        }
-        else {
-            console.error(`错误: ${errorMsg}`);
-        }
-        process.exitCode = 1;
+        handleCommandError(err, 'read-globe', json);
         return;
     }
     const data = result;

package/dist/cli/commands/read-rem.js

@@ -7,8 +7,8 @@
  * - --fields 指定输出字段子集
  * - 退出码：0 成功 / 1 业务错误 / 2 守护进程不可达
  */
-import { sendDaemonRequest, DaemonNotRunningError, DaemonUnreachableError } from '../daemon/send-request.js';
-import { jsonOutput } from '../utils/output.js';
+import { sendDaemonRequest } from '../daemon/send-request.js';
+import { jsonOutput, handleCommandError } from '../utils/output.js';
 export async function readRemCommand(remId, options = {}) {
     const { json, fields, full, includePowerup } = options;
     // 构造 payload
@@ -27,35 +27,7 @@ export async function readRemCommand(remId, options = {}) {
         result = await sendDaemonRequest('read_rem', payload);
     }
     catch (err) {
-        if (err instanceof DaemonNotRunningError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'read-rem', error: err.message });
-            }
-            else {
-                console.error(`错误: ${err.message}`);
-            }
-            process.exitCode = 2;
-            return;
-        }
-        if (err instanceof DaemonUnreachableError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'read-rem', error: err.message });
-            }
-            else {
-                console.error(`错误: ${err.message}`);
-            }
-            process.exitCode = 2;
-            return;
-        }
-        // 业务错误（Rem not found, Plugin 未连接等）
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        if (json) {
-            jsonOutput({ ok: false, command: 'read-rem', error: errorMsg });
-        }
-        else {
-            console.error(`错误: ${errorMsg}`);
-        }
-        process.exitCode = 1;
+        handleCommandError(err, 'read-rem', json);
         return;
     }
     const data = result;