remnote-bridge 0.1.11 → 0.1.12

package/dist/cli/commands/search.js

@@ -4,9 +4,75 @@
  * 在知识库中按文本搜索 Rem。
  * - --limit N 结果数量上限（默认 20）
  * - --json 结构化 JSON 输出
+ *
+ * 配置驱动：检查 addons.remnote-rag.enabled 决定是否使用 RAG 语义搜索。
+ * 已启用且已安装时使用 RAG，否则降级到 SDK 搜索。
+ */
+import { execFile } from 'node:child_process';
+import { sendDaemonRequest } from '../daemon/send-request.js';
+import { loadConfig } from '../config.js';
+import { jsonOutput, handleCommandError } from '../utils/output.js';
+const RAG_TIMEOUT_MS = 10_000;
+/**
+ * 尝试通过 remnote-rag 子进程进行语义搜索（配置驱动）。
+ *
+ * 1. 检查 addons.remnote-rag.enabled — 未启用则跳过
+ * 2. remnote-rag 从 ~/.remnote-bridge/addons/remnote-rag/config.json 读取配置
+ * 3. 未安装（ENOENT）、超时、JSON 解析失败、ok:false 均返回 null（静默降级）
  */
-import { sendDaemonRequest, DaemonNotRunningError, DaemonUnreachableError } from '../daemon/send-request.js';
-import { jsonOutput } from '../utils/output.js';
+async function tryRagSearch(query, numResults) {
+    const config = loadConfig();
+    const ragConfig = config.addons?.['remnote-rag'];
+    if (!ragConfig?.enabled) {
+        return null;
+    }
+    const jsonPayload = JSON.stringify({ query, numResults });
+    const args = ['search', '--json', jsonPayload];
+    try {
+        const stdout = await new Promise((resolve, reject) => {
+            execFile('remnote-rag', args, {
+                timeout: RAG_TIMEOUT_MS,
+                maxBuffer: 5 * 1024 * 1024,
+            }, (error, stdout) => {
+                if (error) {
+                    // execFile 的 error 对象包含 stdout，尝试从中提取 RAG 的诊断信息
+                    const output = (stdout ?? '').trim();
+                    if (output) {
+                        try {
+                            const errData = JSON.parse(output);
+                            if (errData?.error) {
+                                reject(new Error(`remnote-rag: ${errData.error}`));
+                                return;
+                            }
+                        }
+                        catch {
+                            // stdout 不是有效 JSON，忽略
+                        }
+                    }
+                    reject(error);
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+        const parsed = JSON.parse(stdout);
+        if (typeof parsed !== 'object' || parsed === null || !('ok' in parsed) || !('results' in parsed)) {
+            return null;
+        }
+        const result = parsed;
+        if (!result.ok || !Array.isArray(result.results)) {
+            return null;
+        }
+        return result;
+    }
+    catch (err) {
+        // 静默降级，但保留诊断信息到 stderr 供调试
+        if (err instanceof Error && err.message.startsWith('remnote-rag:')) {
+            process.stderr.write(`[search] RAG 降级: ${err.message}\n`);
+        }
+        return null;
+    }
+}
 export async function searchCommand(query, options = {}) {
     const { json } = options;
     const numResults = options.limit !== undefined ? parseInt(options.limit, 10) : undefined;
@@ -21,34 +87,44 @@ export async function searchCommand(query, options = {}) {
         process.exitCode = 1;
         return;
     }
+    // 尝试 RAG 语义搜索
+    const ragResult = await tryRagSearch(query, numResults ?? 20);
+    if (ragResult !== null) {
+        if (json) {
+            jsonOutput({ ok: true, command: 'search', data: { query, ...ragResult, source: 'rag' } });
+        }
+        else {
+            if (ragResult.results.length === 0) {
+                console.log(`未找到与 "${query}" 相关的结果 (RAG)`);
+            }
+            else {
+                console.log(`搜索 "${query}"，找到 ${ragResult.totalFound} 条结果 (RAG 语义搜索)：\n`);
+                for (const item of ragResult.results) {
+                    const docTag = item.isDocument ? ' [Doc]' : '';
+                    const typeTag = item.type !== 'default' ? ` [${item.type}]` : '';
+                    const path = item.ancestorPath.length > 0 ? ` (${item.ancestorPath.join(' > ')})` : '';
+                    const score = ` [${(item.score * 100).toFixed(0)}%]`;
+                    console.log(`  [${item.remId}]${docTag}${typeTag}${score} ${item.text}${path}`);
+                    if (item.backText) {
+                        console.log(`    → ${item.backText}`);
+                    }
+                }
+            }
+        }
+        return;
+    }
+    // 降级到 SDK 搜索
     let result;
     try {
         result = await sendDaemonRequest('search', { query, numResults });
     }
     catch (err) {
-        if (err instanceof DaemonNotRunningError || err instanceof DaemonUnreachableError) {
-            if (json) {
-                jsonOutput({ ok: false, command: 'search', 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: 'search', error: errorMsg });
-        }
-        else {
-            console.error(`错误: ${errorMsg}`);
-        }
-        process.exitCode = 1;
+        handleCommandError(err, 'search', json);
         return;
     }
     const data = result;
     if (json) {
-        jsonOutput({ ok: true, command: 'search', data });
+        jsonOutput({ ok: true, command: 'search', data: { ...data, source: 'sdk' } });
     }
     else {
         if (data.results.length === 0) {

package/dist/cli/config.js

@@ -1,11 +1,22 @@
 /**
  * 配置加载
  *
- * 从项目根目录读取 .remnote-bridge.json，合并默认值。
+ * 从 ~/.remnote-bridge/config.json 读取全局配置，合并默认值。
  * 文件不存在时使用全部默认值，不报错。
+ *
+ * 端口字段由 slots.json 管理，不再出现在配置文件中。
+ * BridgeConfig 仍保留端口字段（填充默认值），供旧代码兼容。
  */
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
+// ── 全局目录 ──
+/** ~/.remnote-bridge/ — 所有运行时文件的根目录 */
+export const GLOBAL_DIR = path.join(os.homedir(), '.remnote-bridge');
+/** 确保全局目录和 instances/ 子目录存在 */
+export function ensureGlobalDir() {
+    fs.mkdirSync(path.join(GLOBAL_DIR, 'instances'), { recursive: true });
+}
 export const DEFAULT_DEFAULTS = {
     maxNodes: 200,
     maxSiblings: 20,
@@ -20,37 +31,14 @@ export const DEFAULT_DEFAULTS = {
     searchNumResults: 20,
 };
 export const DEFAULT_CONFIG = {
-    wsPort: 3002,
-    devServerPort: 8080,
-    configPort: 3003,
+    wsPort: 29100,
+    devServerPort: 29101,
+    configPort: 29102,
     daemonTimeoutMinutes: 30,
     defaults: { ...DEFAULT_DEFAULTS },
 };
-const CONFIG_FILENAME = '.remnote-bridge.json';
-function isValidPort(value) {
-    return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 65535;
-}
-/**
- * 查找项目根目录（monorepo 根：包含 .git 目录的最近祖先）
- *
- * 从 startDir 向上查找 .git 目录，找到即返回。
- * 到达文件系统根仍未找到时回退到 cwd。
- */
-export function findProjectRoot(startDir = process.cwd()) {
-    let dir = path.resolve(startDir);
-    while (true) {
-        // 优先匹配 .git 目录（monorepo 根标识）
-        if (fs.existsSync(path.join(dir, '.git'))) {
-            return dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir) {
-            // 到达文件系统根，回退到 cwd
-            return process.cwd();
-        }
-        dir = parent;
-    }
-}
+const CONFIG_FILENAME = 'config.json';
+const LEGACY_CONFIG_FILENAME = '.remnote-bridge.json';
 function isPositiveNumber(value) {
     return typeof value === 'number' && value > 0;
 }
@@ -75,65 +63,153 @@ function mergeDefaults(parsed) {
         searchNumResults: isPositiveNumber(parsed.searchNumResults) ? parsed.searchNumResults : DEFAULT_DEFAULTS.searchNumResults,
     };
 }
+function mergeAddons(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return undefined;
+    const result = {};
+    for (const [name, raw] of Object.entries(parsed)) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const obj = raw;
+        result[name] = {
+            enabled: typeof obj.enabled === 'boolean' ? obj.enabled : false,
+        };
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
 /**
- * 加载配置。不存在时返回默认值。
+ * 解析配置 JSON（不含端口字段）。端口由 slots.json 管理，此处填充默认值。
  */
-export function loadConfig(projectRoot) {
-    const root = projectRoot ?? findProjectRoot();
-    const configPath = path.join(root, CONFIG_FILENAME);
-    if (!fs.existsSync(configPath)) {
-        return { ...DEFAULT_CONFIG, defaults: { ...DEFAULT_DEFAULTS } };
-    }
-    try {
-        const raw = fs.readFileSync(configPath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        const config = {
-            wsPort: isValidPort(parsed.wsPort) ? parsed.wsPort : DEFAULT_CONFIG.wsPort,
-            devServerPort: isValidPort(parsed.devServerPort) ? parsed.devServerPort : DEFAULT_CONFIG.devServerPort,
-            configPort: isValidPort(parsed.configPort) ? parsed.configPort : DEFAULT_CONFIG.configPort,
-            daemonTimeoutMinutes: typeof parsed.daemonTimeoutMinutes === 'number' && parsed.daemonTimeoutMinutes > 0
-                ? parsed.daemonTimeoutMinutes
-                : DEFAULT_CONFIG.daemonTimeoutMinutes,
-            defaults: mergeDefaults(parsed.defaults),
-        };
-        // 端口冲突校验
-        const ports = [config.wsPort, config.devServerPort, config.configPort];
-        if (new Set(ports).size !== ports.length) {
-            throw new Error('wsPort, devServerPort, configPort must be different');
+function parseConfig(raw) {
+    const parsed = JSON.parse(raw);
+    return {
+        // 端口填充默认值（实际使用 slots 分配的端口）
+        wsPort: DEFAULT_CONFIG.wsPort,
+        devServerPort: DEFAULT_CONFIG.devServerPort,
+        configPort: DEFAULT_CONFIG.configPort,
+        daemonTimeoutMinutes: typeof parsed.daemonTimeoutMinutes === 'number' && parsed.daemonTimeoutMinutes > 0
+            ? parsed.daemonTimeoutMinutes
+            : DEFAULT_CONFIG.daemonTimeoutMinutes,
+        defaults: mergeDefaults(parsed.defaults),
+        addons: mergeAddons(parsed.addons),
+    };
+}
+/**
+ * 全局配置文件路径 (~/.remnote-bridge/config.json)
+ * @param configDir 可选，覆盖全局目录（测试用）
+ */
+export function configFilePath(configDir) {
+    return path.join(configDir ?? GLOBAL_DIR, CONFIG_FILENAME);
+}
+/**
+ * 加载配置。从 ~/.remnote-bridge/config.json 读取。
+ * 不存在时返回默认值。
+ * @param configDir 可选，覆盖全局目录（测试用）
+ */
+export function loadConfig(configDir) {
+    const globalPath = configFilePath(configDir);
+    // 全局配置存在 → 直接读取
+    if (fs.existsSync(globalPath)) {
+        try {
+            return parseConfig(fs.readFileSync(globalPath, 'utf-8'));
+        }
+        catch {
+            return { ...DEFAULT_CONFIG, defaults: { ...DEFAULT_DEFAULTS } };
         }
-        return config;
     }
-    catch {
-        // 配置文件损坏时使用默认值
+    // 尝试从旧项目根迁移（仅在使用默认全局目录时）
+    if (configDir)
         return { ...DEFAULT_CONFIG, defaults: { ...DEFAULT_DEFAULTS } };
+    const legacyPath = findLegacyConfigPath();
+    if (legacyPath) {
+        try {
+            const config = parseConfig(fs.readFileSync(legacyPath, 'utf-8'));
+            // 迁移到全局（去掉端口字段）
+            ensureGlobalDir();
+            saveConfig(globalPath, config);
+            return config;
+        }
+        catch {
+            // 迁移失败，使用默认值
+        }
     }
+    return { ...DEFAULT_CONFIG, defaults: { ...DEFAULT_DEFAULTS } };
 }
 /**
- * 获取配置文件路径
- */
-export function configFilePath(projectRoot) {
-    const root = projectRoot ?? findProjectRoot();
-    return path.join(root, CONFIG_FILENAME);
-}
-/**
- * 原子写入配置文件（写临时文件 → rename）
+ * 原子写入配置文件（写临时文件 → rename）。
+ * 只写非端口字段。
  */
 export function saveConfig(filePath, config) {
+    ensureGlobalDir();
+    // 持久化时去掉端口字段（端口由 slots.json 管理）
+    const persisted = {
+        daemonTimeoutMinutes: config.daemonTimeoutMinutes,
+        defaults: config.defaults,
+        ...(config.addons ? { addons: config.addons } : {}),
+    };
     const tmpPath = filePath + '.tmp.' + process.pid;
-    fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    fs.writeFileSync(tmpPath, JSON.stringify(persisted, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
     fs.renameSync(tmpPath, filePath);
 }
+// ── 旧配置迁移辅助 ──
 /**
- * PID 文件路径
+ * 查找项目根目录（monorepo 根：包含 .git 目录的最近祖先）。
+ * 仅用于旧配置迁移，不再作为实例标识。
  */
-export function pidFilePath(projectRoot) {
-    const root = projectRoot ?? findProjectRoot();
-    return path.join(root, '.remnote-bridge.pid');
+export function findProjectRoot(startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.git'))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return process.cwd();
+        }
+        dir = parent;
+    }
 }
 /**
- * 日志文件路径
+ * 查找旧的项目根配置文件路径（.remnote-bridge.json）。
+ * 存在时返回路径，不存在返回 null。
  */
-export function logFilePath(projectRoot) {
-    const root = projectRoot ?? findProjectRoot();
-    return path.join(root, '.remnote-bridge.log');
+function findLegacyConfigPath() {
+    try {
+        const root = findProjectRoot();
+        const legacyPath = path.join(root, LEGACY_CONFIG_FILENAME);
+        return fs.existsSync(legacyPath) ? legacyPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Addon 独立配置 ──
+/** addon 数据根目录 ~/.remnote-bridge/addons/<name>/ */
+export function addonDataDir(name) {
+    return path.join(GLOBAL_DIR, 'addons', name);
+}
+/** addon 配置文件路径 ~/.remnote-bridge/addons/<name>/config.json */
+export function addonConfigPath(name) {
+    return path.join(addonDataDir(name), 'config.json');
+}
+/** 读取 addon 配置 JSON（文件不存在返回 null） */
+export function loadAddonConfig(name) {
+    const p = addonConfigPath(name);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 保存 addon 配置 JSON（原子写入） */
+export function saveAddonConfig(name, data) {
+    const dir = addonDataDir(name);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, 'config.json');
+    const tmpPath = filePath + '.tmp.' + process.pid;
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
+    fs.renameSync(tmpPath, filePath);
 }

package/dist/cli/daemon/daemon.js

@@ -7,6 +7,10 @@
  * 3. 写入 PID 文件
  * 4. 管理自动超时关闭
  * 5. 通过 IPC 向父进程发送 ready 信号
+ *
+ * 端口来源：env SLOT_WS_PORT / SLOT_DEV_PORT / SLOT_CONFIG_PORT
+ * 实例标识：env REMNOTE_BRIDGE_INSTANCE
+ * 日志/PID：~/.remnote-bridge/instances/N.*
  */
 import path from 'path';
 import fs from 'fs';
@@ -16,16 +20,27 @@ import { DevServerManager } from './dev-server.js';
 import { StaticServer } from './static-server.js';
 import { HeadlessBrowserManager } from './headless-browser.js';
 import { writePid, removePid } from './pid.js';
-import { loadConfig, pidFilePath, logFilePath, findProjectRoot } from '../config.js';
+import { instancePidPath, instanceLogPath } from './registry.js';
+import { loadConfig, ensureGlobalDir } from '../config.js';
 let shutdownInProgress = false;
 async function main() {
-    const projectRoot = findProjectRoot();
-    let config = loadConfig(projectRoot);
-    const pidPath = pidFilePath(projectRoot);
-    const logPath = logFilePath(projectRoot);
+    // 从环境变量获取槽位信息
+    const slotIndex = parseInt(process.env.SLOT_INDEX ?? '', 10);
+    const wsPort = parseInt(process.env.SLOT_WS_PORT ?? '', 10);
+    const devServerPort = parseInt(process.env.SLOT_DEV_PORT ?? '', 10);
+    const configPort = parseInt(process.env.SLOT_CONFIG_PORT ?? '', 10);
+    const instanceId = process.env.REMNOTE_BRIDGE_INSTANCE ?? 'default';
+    if (isNaN(slotIndex) || isNaN(wsPort) || isNaN(devServerPort) || isNaN(configPort)) {
+        console.error('守护进程缺少必要的环境变量 (SLOT_INDEX, SLOT_WS_PORT, SLOT_DEV_PORT, SLOT_CONFIG_PORT)');
+        process.exit(1);
+    }
+    let config = loadConfig();
+    ensureGlobalDir();
+    const pidPath = instancePidPath(slotIndex);
+    const logPath = instanceLogPath(slotIndex);
     // 日志写入文件（追加模式，保留前次会话日志）
     const logStream = fs.createWriteStream(logPath, { flags: 'a' });
-    logStream.write(`\n${'='.repeat(60)}\n[${new Date().toISOString()}] 守护进程启动 (PID: ${process.pid})\n${'='.repeat(60)}\n`);
+    logStream.write(`\n${'='.repeat(60)}\n[${new Date().toISOString()}] 守护进程启动 (PID: ${process.pid}, instance: ${instanceId}, slot: ${slotIndex})\n${'='.repeat(60)}\n`);
     function log(message, level = 'info') {
         const timestamp = new Date().toISOString();
         const line = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
@@ -50,8 +65,9 @@ async function main() {
     // 创建 WS Server（抽取为函数，供软重启复用）
     function createServer(cfg) {
         const srv = new BridgeServer({
-            port: cfg.wsPort,
+            port: wsPort,
             host: '127.0.0.1',
+            slotIndex,
             onLog: log,
             getTimeoutRemaining,
             defaults: cfg.defaults,
@@ -95,19 +111,18 @@ async function main() {
         catch (err) {
             log(`旧 WS Server 关闭失败: ${err}`, 'error');
         }
-        config = loadConfig(projectRoot);
+        config = loadConfig();
         timeoutMs = config.daemonTimeoutMinutes * 60 * 1000;
         server = createServer(config);
         await server.start();
-        log(`新 WS Server 已启动 (端口 ${config.wsPort})`);
+        log(`新 WS Server 已启动 (端口 ${wsPort})`);
         resetTimeout();
         log('软重启完成');
     }
     // 启动 ConfigServer
     const configServer = new ConfigServer({
-        port: config.configPort,
+        port: configPort,
         host: '127.0.0.1',
-        projectRoot,
         onRestart: reload,
         onLog: log,
     });
@@ -134,7 +149,7 @@ async function main() {
     const pluginServer = devMode
         ? new DevServerManager({
             pluginDir,
-            port: config.devServerPort,
+            port: devServerPort,
             onLog: log,
             onExit: (code) => {
                 if (!shutdownInProgress && code !== 0) {
@@ -145,7 +160,7 @@ async function main() {
         })
         : new StaticServer({
             distDir,
-            port: config.devServerPort,
+            port: devServerPort,
             onLog: log,
         });
     async function shutdown() {
@@ -197,7 +212,7 @@ async function main() {
     process.on('SIGINT', shutdown);
     try {
         await server.start();
-        log(`WS Server 已启动 (端口 ${config.wsPort})`);
+        log(`WS Server 已启动 (端口 ${wsPort})`);
     }
     catch (err) {
         log(`WS Server 启动失败: ${err}`, 'error');
@@ -206,7 +221,7 @@ async function main() {
     }
     try {
         await configServer.start();
-        log(`ConfigServer 已启动 (端口 ${config.configPort})`);
+        log(`ConfigServer 已启动 (端口 ${configPort})`);
     }
     catch (err) {
         log(`ConfigServer 启动失败: ${err}`, 'warn');
@@ -214,7 +229,7 @@ async function main() {
     }
     try {
         await pluginServer.start();
-        log(`${pluginServerLabel} 已启动 (端口 ${config.devServerPort})`);
+        log(`${pluginServerLabel} 已启动 (端口 ${devServerPort})`);
     }
     catch (err) {
         log(`${pluginServerLabel} 启动失败: ${err}`, 'error');
@@ -222,12 +237,59 @@ async function main() {
         process.send?.({ type: 'error', message: `${pluginServerLabel} 启动失败: ${err}` });
         process.exit(1);
     }
-    // 写入 PID 文件
-    writePid(pidPath, process.pid);
+    // 取实际绑定的端口（可能与 env 传入的不同，若原端口被占用则 OS 自动分配）
+    const actualWsPort = server.actualPort;
+    const actualConfigPort = configServer.actualPort;
+    // StaticServer 有 actualPort；DevServerManager 通过 spawn 无法获取，用 env 值
+    const actualDevPort = 'actualPort' in pluginServer
+        ? pluginServer.actualPort
+        : devServerPort;
+    // Headless 模式：关键端口不允许回退（Plugin 无法发现新端口）
+    if (headlessMode) {
+        if (actualWsPort !== wsPort) {
+            log(`Headless 模式下 WS 端口被占用（${wsPort} → ${actualWsPort}），终止启动`, 'error');
+            await server.stop();
+            await configServer.stop();
+            await pluginServer.stop();
+            process.send?.({
+                type: 'error',
+                message: `Headless 模式不支持端口回退：WS 端口 ${wsPort} 被占用。请释放端口或修改配置后重试`,
+            });
+            process.exit(1);
+        }
+        if (actualDevPort !== devServerPort) {
+            log(`Headless 模式下 Plugin 服务端口被占用（${devServerPort} → ${actualDevPort}），终止启动`, 'error');
+            await server.stop();
+            await configServer.stop();
+            await pluginServer.stop();
+            process.send?.({
+                type: 'error',
+                message: `Headless 模式不支持端口回退：Plugin 服务端口 ${devServerPort} 被占用。请释放端口或修改配置后重试`,
+            });
+            process.exit(1);
+        }
+    }
+    // 设置 discovery 数据（供 Plugin 通过 /api/discovery 自动发现端口）
+    if (pluginServer instanceof StaticServer) {
+        pluginServer.setDiscovery({
+            wsPort: actualWsPort,
+            configPort: actualConfigPort,
+            instance: instanceId,
+            slotIndex,
+        });
+        log(`Discovery 端点已就绪 (wsPort=${actualWsPort}, configPort=${actualConfigPort}, instance=${instanceId}, slotIndex=${slotIndex})`);
+    }
+    // 写入 PID 文件（JSON 格式，使用实际端口）
+    writePid(pidPath, {
+        pid: process.pid,
+        slotIndex,
+        instance: instanceId,
+        wsPort: actualWsPort,
+        devServerPort: actualDevPort,
+        configPort: actualConfigPort,
+    });
     log(`PID 文件已写入: ${pidPath} (PID: ${process.pid})`);
     // 启动 Headless Chrome（如果启用）
-    // headless Chrome 加载 RemNote 本身（不是 plugin 静态文件），
-    // RemNote 会自动加载已配置的 dev plugin（从 localhost:8080）
     if (headlessMode) {
         const remNoteUrl = 'https://www.remnote.com';
         headlessBrowser = new HeadlessBrowserManager({
@@ -247,19 +309,37 @@ async function main() {
     }
     // 启动超时计时器
     resetTimeout();
-    // 通知父进程就绪
+    // 通知父进程就绪（使用实际端口）
     process.send?.({
         type: 'ready',
-        wsPort: config.wsPort,
-        devServerPort: config.devServerPort,
-        configPort: config.configPort,
+        wsPort: actualWsPort,
+        devServerPort: actualDevPort,
+        configPort: actualConfigPort,
         pid: process.pid,
         headless: headlessMode,
+        slotIndex,
+        instance: instanceId,
     });
     // 断开 IPC 通道（让父进程可以退出）
     if (process.channel) {
         process.channel.unref();
     }
+    // 自动安装已启用的 addon（非阻塞，不影响启动速度）
+    import('../addon/addon-manager.js').then(({ AddonManager }) => {
+        const addonManager = new AddonManager(config);
+        return addonManager.ensureEnabledAddons(log);
+    }).then((addonResults) => {
+        for (const r of addonResults) {
+            if (r.action === 'installed') {
+                log(`[addon] ${r.name} 已自动安装`);
+            }
+            else if (r.action === 'failed') {
+                log(`[addon] ${r.name} 自动安装失败: ${r.error}`, 'warn');
+            }
+        }
+    }).catch((err) => {
+        log(`[addon] 自动安装检查失败: ${err}`, 'warn');
+    });
 }
 main().catch((err) => {
     console.error('守护进程启动失败:', err);

package/dist/cli/daemon/dev-server.js

@@ -61,7 +61,15 @@ export class DevServerManager {
         // shell: true 确保 Windows 上能找到 npm.cmd
         this.child = spawn('npm', ['run', 'dev'], {
             cwd: pluginDir,
-            env: { ...process.env, PORT: String(port) },
+            env: {
+                ...process.env,
+                PORT: String(port),
+                // 供 webpack devServer.setupMiddlewares 劫持 /api/discovery
+                DISCOVERY_WS_PORT: process.env.SLOT_WS_PORT ?? '',
+                DISCOVERY_CONFIG_PORT: process.env.SLOT_CONFIG_PORT ?? '',
+                DISCOVERY_INSTANCE: process.env.REMNOTE_BRIDGE_INSTANCE ?? '',
+                DISCOVERY_SLOT_INDEX: process.env.SLOT_INDEX ?? '',
+            },
             stdio: 'pipe',
             shell: true,
         });