remnote-bridge 0.1.7 → 0.1.9

package/dist/cli/daemon/headless-browser.js

@@ -0,0 +1,291 @@
+/**
+ * Headless Chrome 浏览器管理器
+ *
+ * 在 daemon 中启动 headless Chrome 加载 RemNote Plugin 页面，
+ * 实现无 GUI 环境下的全自动连接。
+ *
+ * 属于进程管理层（daemon/），与 static-server.ts、dev-server.ts 平级。
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+// ── 工具函数（setup 命令复用） ──
+/**
+ * 按平台自动检测 Chrome/Chromium 路径。
+ * 返回 null 表示未找到。
+ */
+export function findChromePath() {
+    const platform = os.platform();
+    const candidates = [];
+    if (platform === 'darwin') {
+        candidates.push('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium', '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary');
+    }
+    else if (platform === 'win32') {
+        const programFiles = process.env['PROGRAMFILES'] || 'C:\\Program Files';
+        const programFilesX86 = process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)';
+        const localAppData = process.env['LOCALAPPDATA'] || '';
+        candidates.push(path.join(programFiles, 'Google', 'Chrome', 'Application', 'chrome.exe'), path.join(programFilesX86, 'Google', 'Chrome', 'Application', 'chrome.exe'), path.join(localAppData, 'Google', 'Chrome', 'Application', 'chrome.exe'));
+    }
+    else {
+        // Linux
+        candidates.push('/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser', '/snap/bin/chromium');
+    }
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * 检测是否有桌面环境（GUI）。
+ * macOS/Windows 始终返回 true，Linux 检查 DISPLAY/WAYLAND_DISPLAY。
+ */
+export function hasDisplay() {
+    const platform = os.platform();
+    if (platform === 'darwin' || platform === 'win32')
+        return true;
+    return !!(process.env['DISPLAY'] || process.env['WAYLAND_DISPLAY']);
+}
+/**
+ * 返回 headless Chrome 的默认 profile 目录。
+ */
+export function getDefaultProfileDir() {
+    return path.join(os.homedir(), '.remnote-bridge', 'chrome-profile');
+}
+/**
+ * 返回 setup 完成标记文件路径。
+ */
+export function getSetupDonePath() {
+    return path.join(getDefaultProfileDir(), '.setup-done');
+}
+const MAX_AUTO_RELOAD = 5;
+const AUTO_RELOAD_DELAY_MS = 10_000;
+const CONSOLE_ERROR_BUFFER_SIZE = 20;
+export class HeadlessBrowserManager {
+    browser = null;
+    page = null;
+    status = 'stopped';
+    reloadCount = 0;
+    lastError = null;
+    consoleErrors = [];
+    options;
+    autoReloadTimer = null;
+    constructor(options) {
+        this.options = options;
+    }
+    log(message, level = 'info') {
+        this.options.onLog?.(message, level);
+    }
+    /**
+     * 启动 headless Chrome，打开 RemNote Plugin 页面。
+     * 不等待 Plugin WS 连接建立——Plugin 自行连接，health 检测状态。
+     */
+    async start() {
+        this.status = 'starting';
+        this.log('[headless] 正在启动 Chrome...');
+        const chromePath = this.options.chromePath ?? findChromePath();
+        if (!chromePath) {
+            this.status = 'crashed';
+            this.lastError = '未找到 Chrome/Chromium，请通过 --chrome-path 指定路径';
+            throw new Error(this.lastError);
+        }
+        const userDataDir = this.options.userDataDir ?? getDefaultProfileDir();
+        fs.mkdirSync(userDataDir, { recursive: true });
+        try {
+            // 动态 import puppeteer-core（避免未安装时报错）
+            const puppeteer = await import('puppeteer-core');
+            const launchOptions = {
+                executablePath: chromePath,
+                headless: 'shell',
+                userDataDir,
+                args: [
+                    '--no-first-run',
+                    '--no-default-browser-check',
+                    '--disable-gpu',
+                    '--disable-dev-shm-usage',
+                ],
+            };
+            if (this.options.remoteDebuggingPort) {
+                launchOptions.args.push(`--remote-debugging-port=${this.options.remoteDebuggingPort}`);
+            }
+            this.browser = await puppeteer.default.launch(launchOptions);
+            this.page = await this.browser.newPage();
+            // console 监控：仅收集 error 级别
+            this.page.on('console', (msg) => {
+                if (msg.type() === 'error') {
+                    const text = `[${new Date().toISOString()}] ${msg.text()}`;
+                    this.consoleErrors.push(text);
+                    if (this.consoleErrors.length > CONSOLE_ERROR_BUFFER_SIZE) {
+                        this.consoleErrors.shift();
+                    }
+                }
+            });
+            // 页面崩溃/关闭 → 自动恢复
+            this.page.on('close', () => {
+                if (this.status === 'running') {
+                    this.log('[headless] 页面意外关闭，将尝试自动恢复', 'warn');
+                    this.scheduleAutoReload();
+                }
+            });
+            this.browser.on('disconnected', () => {
+                if (this.status === 'running' || this.status === 'reloading') {
+                    this.log('[headless] Chrome 进程断开', 'warn');
+                    this.status = 'crashed';
+                    this.lastError = 'Chrome 进程断开';
+                    this.browser = null;
+                    this.page = null;
+                }
+            });
+            // 导航到 RemNote Plugin 页面
+            await this.page.goto(this.options.remNoteUrl, {
+                waitUntil: 'domcontentloaded',
+                timeout: 60_000,
+            });
+            this.status = 'running';
+            this.log(`[headless] Chrome 已启动，页面: ${this.options.remNoteUrl}`);
+        }
+        catch (err) {
+            this.status = 'crashed';
+            this.lastError = err instanceof Error ? err.message : String(err);
+            this.log(`[headless] 启动失败: ${this.lastError}`, 'error');
+            // 尝试清理
+            try {
+                await this.browser?.close();
+            }
+            catch { /* ignore */ }
+            this.browser = null;
+            this.page = null;
+            throw err;
+        }
+    }
+    /**
+     * 关闭 Chrome 和页面。
+     */
+    async stop() {
+        if (this.autoReloadTimer) {
+            clearTimeout(this.autoReloadTimer);
+            this.autoReloadTimer = null;
+        }
+        this.status = 'stopped';
+        this.log('[headless] 正在关闭 Chrome...');
+        try {
+            if (this.page) {
+                await this.page.close().catch(() => { });
+                this.page = null;
+            }
+            if (this.browser) {
+                await this.browser.close().catch(() => { });
+                this.browser = null;
+            }
+        }
+        catch (err) {
+            this.log(`[headless] 关闭时出错: ${err}`, 'warn');
+        }
+        this.log('[headless] Chrome 已关闭');
+    }
+    /**
+     * 获取诊断信息。
+     */
+    getDiagnostics() {
+        return {
+            status: this.status,
+            chromeConnected: this.browser !== null && this.browser.connected,
+            pageUrl: this.page?.url() ?? null,
+            reloadCount: this.reloadCount,
+            lastError: this.lastError,
+            recentConsoleErrors: [...this.consoleErrors],
+        };
+    }
+    /**
+     * 截图当前页面，返回截图文件路径。
+     */
+    async takeScreenshot() {
+        if (!this.page)
+            return null;
+        const dir = path.join(os.homedir(), '.remnote-bridge');
+        fs.mkdirSync(dir, { recursive: true });
+        const filePath = path.join(dir, `headless-screenshot-${Date.now()}.png`);
+        try {
+            await this.page.screenshot({ path: filePath, fullPage: true });
+            this.log(`[headless] 截图已保存: ${filePath}`);
+            return filePath;
+        }
+        catch (err) {
+            this.log(`[headless] 截图失败: ${err}`, 'warn');
+            return null;
+        }
+    }
+    /**
+     * 手动重载页面（重置 reloadCount）。
+     */
+    async manualReload() {
+        this.log('[headless] 手动重载...');
+        this.reloadCount = 0;
+        await this.doReload();
+    }
+    scheduleAutoReload() {
+        if (this.reloadCount >= MAX_AUTO_RELOAD) {
+            this.status = 'crashed';
+            this.lastError = `自动恢复次数已达上限 (${MAX_AUTO_RELOAD})`;
+            this.log(`[headless] ${this.lastError}`, 'error');
+            return;
+        }
+        this.autoReloadTimer = setTimeout(async () => {
+            this.autoReloadTimer = null;
+            try {
+                await this.doReload();
+            }
+            catch (err) {
+                this.log(`[headless] 自动恢复失败: ${err}`, 'error');
+            }
+        }, AUTO_RELOAD_DELAY_MS);
+    }
+    async doReload() {
+        this.status = 'reloading';
+        this.reloadCount++;
+        try {
+            // 如果浏览器已断开，需要重新启动
+            if (!this.browser || !this.browser.connected) {
+                this.log('[headless] 浏览器已断开，重新启动...', 'warn');
+                this.browser = null;
+                this.page = null;
+                await this.start();
+                return;
+            }
+            // 关闭旧页面，创建新页面
+            if (this.page) {
+                await this.page.close().catch(() => { });
+            }
+            this.page = await this.browser.newPage();
+            // 重新注册 console 监控
+            this.page.on('console', (msg) => {
+                if (msg.type() === 'error') {
+                    const text = `[${new Date().toISOString()}] ${msg.text()}`;
+                    this.consoleErrors.push(text);
+                    if (this.consoleErrors.length > CONSOLE_ERROR_BUFFER_SIZE) {
+                        this.consoleErrors.shift();
+                    }
+                }
+            });
+            this.page.on('close', () => {
+                if (this.status === 'running') {
+                    this.log('[headless] 页面意外关闭，将尝试自动恢复', 'warn');
+                    this.scheduleAutoReload();
+                }
+            });
+            await this.page.goto(this.options.remNoteUrl, {
+                waitUntil: 'domcontentloaded',
+                timeout: 60_000,
+            });
+            this.status = 'running';
+            this.lastError = null;
+            this.log(`[headless] 重载完成 (第 ${this.reloadCount} 次)`);
+        }
+        catch (err) {
+            this.status = 'crashed';
+            this.lastError = err instanceof Error ? err.message : String(err);
+            this.log(`[headless] 重载失败: ${this.lastError}`, 'error');
+            throw err;
+        }
+    }
+}

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

@@ -0,0 +1,84 @@
+/**
+ * 轻量静态文件服务器
+ *
+ * 用 Node.js 内置 http 模块 serve remnote-plugin/dist/ 目录。
+ * 替代 webpack-dev-server，用于非开发模式（预构建 plugin）。
+ */
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'application/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.ico': 'image/x-icon',
+};
+export class StaticServer {
+    server = null;
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        const { distDir, port, onLog } = this.options;
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                // CORS headers（与 webpack.config.js 一致）
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Headers', 'baggage, sentry-trace');
+                // OPTIONS preflight
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                const urlPath = req.url?.split('?')[0] || '/';
+                const filePath = path.resolve(distDir, urlPath === '/' ? 'index.html' : '.' + urlPath);
+                // 防止目录遍历（resolve 规范化后，确保仍在 distDir + sep 下）
+                const safePrefix = distDir.endsWith(path.sep) ? distDir : distDir + path.sep;
+                if (!filePath.startsWith(safePrefix) && filePath !== distDir) {
+                    res.writeHead(403);
+                    res.end('Forbidden');
+                    return;
+                }
+                fs.readFile(filePath, (err, data) => {
+                    if (err) {
+                        res.writeHead(404);
+                        res.end('Not Found');
+                        return;
+                    }
+                    const ext = path.extname(filePath);
+                    const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+                    res.writeHead(200, { 'Content-Type': contentType });
+                    res.end(data);
+                });
+            });
+            this.server.on('error', (err) => {
+                onLog?.(`[static-server] 启动失败: ${err.message}`, 'error');
+                reject(err);
+            });
+            this.server.listen(port, '127.0.0.1', () => {
+                onLog?.(`[static-server] 已启动 http://127.0.0.1:${port} (serving ${distDir})`, 'info');
+                resolve();
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close(() => {
+                this.server = null;
+                resolve();
+            });
+        });
+    }
+    isRunning() {
+        return this.server !== null && this.server.listening;
+    }
+}

package/dist/cli/main.js

@@ -4,8 +4,10 @@
  *
  * 伞命令：CLI 命令 + mcp 子命令 + install 子命令。
  */
+import { createRequire } from 'module';
 import { Command } from 'commander';
 import { connectCommand } from './commands/connect.js';
+import { setupCommand } from './commands/setup.js';
 import { healthCommand } from './commands/health.js';
 import { disconnectCommand } from './commands/disconnect.js';
 import { readRemCommand } from './commands/read-rem.js';
@@ -17,6 +19,8 @@ import { readContextCommand } from './commands/read-context.js';
 import { searchCommand } from './commands/search.js';
 import { installSkillCommand, installSkillCopyCommand } from './commands/install-skill.js';
 import { cleanCommand } from './commands/clean.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
 const program = new Command();
 /**
  * --json 模式下解析 JSON 输入参数。
@@ -54,21 +58,33 @@ function parseJsonInput(command, jsonStr, requiredFields = []) {
 program
     .name('remnote-bridge')
     .description('RemNote Bridge — CLI + MCP Server + Plugin')
-    .version('0.1.6')
+    .version(version)
     .option('--json', '以 JSON 格式输出（适用于程序化调用）');
 program
-    .command('connect')
-    .description('启动守护进程（WS Server + webpack-dev-server），等待 Plugin 连接')
+    .command('setup')
+    .description('启动 Chrome 让用户登录 RemNote（headless 模式前置步骤）')
     .action(async () => {
     const { json } = program.opts();
-    await connectCommand({ json });
+    await setupCommand({ json });
+});
+program
+    .command('connect')
+    .description('启动守护进程，等待 Plugin 连接')
+    .option('--dev', '开发模式：使用 webpack-dev-server（支持 HMR）')
+    .option('--headless', '无头模式：自动启动 headless Chrome 加载 Plugin（需先 setup）')
+    .option('--remote-debugging-port <port>', 'Chrome 远程调试端口（仅 --headless）', parseInt)
+    .action(async (cmdOpts) => {
+    const { json } = program.opts();
+    await connectCommand({ json, dev: cmdOpts.dev, headless: cmdOpts.headless, remoteDebuggingPort: cmdOpts.remoteDebuggingPort });
 });
 program
     .command('health')
     .description('检查守护进程、Plugin 连接和 SDK 状态')
-    .action(async () => {
+    .option('--diagnose', '诊断 headless Chrome（截图 + 状态 + console 错误）')
+    .option('--reload', '重载 headless Chrome 页面')
+    .action(async (cmdOpts) => {
     const { json } = program.opts();
-    await healthCommand({ json });
+    await healthCommand({ json, diagnose: cmdOpts.diagnose, reload: cmdOpts.reload });
 });
 program
     .command('disconnect')

package/dist/cli/server/ws-server.js

@@ -49,6 +49,9 @@ export class BridgeServer {
             pongTimeoutMs: config.pongTimeoutMs ?? 10_000,
             onLog: config.onLog,
             getTimeoutRemaining: config.getTimeoutRemaining,
+            getHeadlessStatus: config.getHeadlessStatus,
+            diagnoseHeadless: config.diagnoseHeadless,
+            reloadHeadless: config.reloadHeadless,
         };
         this.defaults = config.defaults ?? DEFAULT_DEFAULTS;
         const defaults = this.defaults;
@@ -200,6 +203,59 @@ export class BridgeServer {
             ws.send(JSON.stringify(response));
             return;
         }
+        // diagnose：headless 诊断（不需要 Plugin）
+        if (request.action === 'diagnose') {
+            if (!this.config.diagnoseHeadless) {
+                const response = {
+                    id: request.id,
+                    error: '非 headless 模式，不支持 diagnose',
+                };
+                ws.send(JSON.stringify(response));
+                return;
+            }
+            try {
+                const diagResult = await this.config.diagnoseHeadless();
+                if (diagResult) {
+                    // 补充 pluginConnected 和 sdkReady
+                    diagResult.pluginConnected = this.pluginSocket?.readyState === WebSocket.OPEN;
+                    diagResult.sdkReady = this.pluginSdkReady;
+                }
+                const response = { id: request.id, result: diagResult };
+                ws.send(JSON.stringify(response));
+            }
+            catch (err) {
+                const response = {
+                    id: request.id,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+                ws.send(JSON.stringify(response));
+            }
+            return;
+        }
+        // headless_reload：重载 headless Chrome 页面（不需要 Plugin）
+        if (request.action === 'headless_reload') {
+            if (!this.config.reloadHeadless) {
+                const response = {
+                    id: request.id,
+                    error: '非 headless 模式，不支持 reload',
+                };
+                ws.send(JSON.stringify(response));
+                return;
+            }
+            try {
+                const reloadResult = await this.config.reloadHeadless();
+                const response = { id: request.id, result: reloadResult };
+                ws.send(JSON.stringify(response));
+            }
+            catch (err) {
+                const response = {
+                    id: request.id,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+                ws.send(JSON.stringify(response));
+            }
+            return;
+        }
         // 以下 action 都需要 Plugin 连接
         if (!this.pluginSocket || this.pluginSocket.readyState !== WebSocket.OPEN) {
             const response = {
@@ -325,11 +381,16 @@ export class BridgeServer {
     }
     /** 获取当前状态（timeoutRemaining 通过构造时注入的回调获取） */
     getStatus() {
-        return {
+        const result = {
             pluginConnected: this.pluginSocket?.readyState === WebSocket.OPEN,
             sdkReady: this.pluginSdkReady,
             uptime: Math.floor((Date.now() - this.startTime) / 1000),
             timeoutRemaining: this.config.getTimeoutRemaining?.() ?? 0,
         };
+        const headlessStatus = this.config.getHeadlessStatus?.();
+        if (headlessStatus) {
+            result.headless = headlessStatus;
+        }
+        return result;
     }
 }

package/dist/mcp/daemon-client.js

@@ -46,8 +46,11 @@ export class CliError extends Error {
  */
 export async function callCli(command, payload, options) {
     const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    // 构造参数列表：--json <command> [jsonStr]
+    // 构造参数列表：--json <command> [flags...] [jsonStr]
     const args = ['--json', command];
+    if (options?.flags) {
+        args.push(...options.flags);
+    }
     if (payload !== undefined) {
         args.push(JSON.stringify(payload));
     }

package/dist/mcp/instructions.js

@@ -85,6 +85,8 @@ RemNote 的格式设置（标题、高亮、代码等）会注入隐藏的系统
 
 所有操作都依赖一个活跃的会话。会话 = 守护进程的生命周期。
 
+### 标准模式（需要用户配合）
+
 \\\`\\\`\\\`
 connect → 启动 daemon（幂等，重复调用安全）
   ↓
@@ -97,6 +99,52 @@ health → 确认三层就绪（daemon / Plugin / SDK）
 disconnect → 关闭 daemon，清空所有缓存
 \\\`\\\`\\\`
 
+### Headless 模式（自动连接）
+
+标准模式每次 connect 后都需要用户手动操作 RemNote。Headless 模式通过 setup（一次性）+ headless Chrome 实现自动连接，后续 connect 无需用户介入。
+
+**⚠️ 模式选择建议**：日常使用推荐**标准模式**。Headless 模式下 Chrome 在后台运行，**无法感知用户正在 RemNote 中浏览和操作的界面**（\\\`read_context\\\` 返回的是 headless Chrome 的上下文，而非用户的浏览器）。只有在全自动化场景（CI/CD、定时任务、批量操作等无需与用户界面交互的场景）才建议使用 Headless 模式。
+
+#### 首次使用（setup）
+
+\\\`setup\\\` 会弹出 Chrome 窗口，用户需要完成两件事：
+1. **登录 RemNote**
+2. **配置 dev plugin**：插件图标 → 开发你的插件 → 填入 \\\`http://localhost:8080\\\`
+
+完成后**彻底退出 Chrome**（macOS 必须 Cmd+Q，仅关窗口不够）。
+
+**你必须这样与用户交互**：
+1. 调用 \\\`setup\\\`
+2. 立即告知用户：
+   "已打开 Chrome 浏览器。请完成以下操作：
+    1. 登录 RemNote
+    2. 在 RemNote 中配置开发插件：点击左下角插件图标 → 开发你的插件 → 输入 http://localhost:8080
+    3. 完成后彻底退出 Chrome（macOS 请按 Cmd+Q）"
+3. 等待 \\\`setup\\\` 返回（阻塞，最长 10 分钟）
+4. 成功 → 进入下一步 \\\`connect(headless=true)\\\`
+
+setup 只需执行一次。之后每次连接直接用 \\\`connect(headless=true)\\\`。
+
+#### 后续使用
+
+\\\`\\\`\\\`
+connect(headless=true) → 启动 daemon + headless Chrome 自动加载 RemNote 和 Plugin
+  ↓
+health → 等待三层就绪（Plugin 需要 10-30 秒连接，可多次轮询）
+  ↓
+业务操作（read / search / edit）
+  ↓
+disconnect → 关闭 daemon + headless Chrome，清空所有缓存
+\\\`\\\`\\\`
+
+**无需任何用户操作**——headless Chrome 在后台自动完成登录和 Plugin 加载。
+
+#### 排查
+
+- \\\`health(diagnose=true)\\\`：截图 + Chrome 状态 + console 错误（确认页面是否正常加载）
+- \\\`health(reload=true)\\\`：重载 headless Chrome 页面（Plugin 未连接时尝试）
+- 如果 Plugin 始终不连接，可能是 RemNote 登录 session 过期，需重新 setup
+
 **关键要点**：
 - \\\`connect\\\` 是所有业务操作的前提，未 connect 时任何命令都会报"守护进程未运行"
 - \\\`health\\\` 检查三层状态：daemon 运行 → Plugin 已连接 → SDK 就绪，三者全部通过才能执行业务命令
@@ -105,19 +153,20 @@ disconnect → 关闭 daemon，清空所有缓存
 
 ### Windows 注意事项
 
-- **首次 connect 较慢**：daemon 启动时会自动安装 remnote-plugin 的依赖（约 600+ 个包），在 Windows 上可能需要 30-60 秒，connect 超时设为 60 秒
-- **依赖自动修复**：如果 webpack-dev-server 因依赖损坏而崩溃，daemon 会自动清洁重装依赖（删除 node_modules 后重新安装）并重试，最多重试 2 次
+- **默认模式秒级启动**：使用预构建 plugin，无需安装依赖
+- **\`--dev\` 模式首次较慢**：会自动安装 remnote-plugin 的依赖（约 600+ 个包），在 Windows 上可能需要 30-60 秒，connect 超时设为 60 秒
+- **\`--dev\` 依赖自动修复**：如果 webpack-dev-server 因依赖损坏而崩溃，daemon 会自动清洁重装依赖（删除 node_modules 后重新安装）并重试，最多重试 2 次
 - **端口残留**：多次 connect 失败后可能出现端口被占用（EADDRINUSE），用 \\\`remnote-bridge disconnect\\\` 或手动终止占用端口的进程后重试
 
-### ⚠️ connect 后需要用户配合（重要）
+### ⚠️ 标准模式：connect 后需要用户配合（重要）
 
-\\\`connect\\\` 成功只意味着 daemon 和 webpack-dev-server 已启动，**Plugin 并未自动连接**。用户必须在 RemNote 中完成以下操作，Plugin 才能连接到 daemon：
+\\\`connect\\\`（不传 headless）成功只意味着 daemon 和 Plugin 服务已启动，**Plugin 并未自动连接**。用户必须在 RemNote 中完成以下操作，Plugin 才能连接到 daemon：
 
 **首次使用**（RemNote 从未加载过此插件）：
 1. 打开 RemNote 桌面端或网页端
 2. 点击左侧边栏底部的插件图标（拼图形状）
 3. 点击「开发你的插件」（Develop Your Plugin）
-4. 在输入框中填入 \\\`http://localhost:8080\\\`（即 connect 输出的 webpack-dev-server 地址）
+4. 在输入框中填入 \\\`http://localhost:8080\\\`（即 connect 输出的 Plugin 服务地址）
 5. 等待插件加载完成
 
 **非首次使用**（之前已加载过此插件）：