remnote-bridge 0.1.0

package/dist/cli/daemon/daemon.js

@@ -0,0 +1,186 @@
+/**
+ * 守护进程主逻辑
+ *
+ * 作为 fork 子进程运行：
+ * 1. 启动 WS Server
+ * 2. 启动 webpack-dev-server 子进程
+ * 3. 写入 PID 文件
+ * 4. 管理自动超时关闭
+ * 5. 通过 IPC 向父进程发送 ready 信号
+ */
+import path from 'path';
+import fs from 'fs';
+import { BridgeServer } from '../server/ws-server.js';
+import { ConfigServer } from '../server/config-server.js';
+import { DevServerManager } from './dev-server.js';
+import { writePid, removePid } from './pid.js';
+import { loadConfig, pidFilePath, logFilePath, findProjectRoot } 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 logStream = fs.createWriteStream(logPath, { flags: 'a' });
+    logStream.write(`\n${'='.repeat(60)}\n[${new Date().toISOString()}] 守护进程启动 (PID: ${process.pid})\n${'='.repeat(60)}\n`);
+    function log(message, level = 'info') {
+        const timestamp = new Date().toISOString();
+        const line = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+        logStream.write(line);
+    }
+    // 超时管理
+    let timeoutMs = config.daemonTimeoutMinutes * 60 * 1000;
+    let timeoutTimer;
+    let lastResetTime = Date.now();
+    function resetTimeout() {
+        clearTimeout(timeoutTimer);
+        lastResetTime = Date.now();
+        timeoutTimer = setTimeout(() => {
+            log('超时关闭（无 CLI 交互）');
+            shutdown();
+        }, timeoutMs);
+    }
+    function getTimeoutRemaining() {
+        const elapsed = Date.now() - lastResetTime;
+        return Math.max(0, Math.floor((timeoutMs - elapsed) / 1000));
+    }
+    // 创建 WS Server（抽取为函数，供软重启复用）
+    function createServer(cfg) {
+        const srv = new BridgeServer({
+            port: cfg.wsPort,
+            host: '127.0.0.1',
+            onLog: log,
+            getTimeoutRemaining,
+            defaults: cfg.defaults,
+        });
+        srv.onCliRequest = () => resetTimeout();
+        return srv;
+    }
+    let server = createServer(config);
+    // 软重启：关闭旧 WS Server → 重新读配置 → 创建新 WS Server → 启动
+    async function reload() {
+        log('开始软重启...');
+        try {
+            await server.stop();
+            log('旧 WS Server 已关闭');
+        }
+        catch (err) {
+            log(`旧 WS Server 关闭失败: ${err}`, 'error');
+        }
+        config = loadConfig(projectRoot);
+        timeoutMs = config.daemonTimeoutMinutes * 60 * 1000;
+        server = createServer(config);
+        await server.start();
+        log(`新 WS Server 已启动 (端口 ${config.wsPort})`);
+        resetTimeout();
+        log('软重启完成');
+    }
+    // 启动 ConfigServer
+    const configServer = new ConfigServer({
+        port: config.configPort,
+        host: '127.0.0.1',
+        projectRoot,
+        onRestart: reload,
+        onLog: log,
+    });
+    // 启动 webpack-dev-server
+    // 从包安装路径计算 pluginDir（dist/cli/daemon/daemon.js → 包根/remnote-plugin）
+    const packageRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+    const pluginDir = path.join(packageRoot, 'remnote-plugin');
+    const devServer = new DevServerManager({
+        pluginDir,
+        port: config.devServerPort,
+        onLog: log,
+        onExit: (code) => {
+            if (!shutdownInProgress && code !== 0) {
+                log('webpack-dev-server 异常退出，守护进程关闭', 'error');
+                shutdown();
+            }
+        },
+    });
+    async function shutdown() {
+        if (shutdownInProgress)
+            return;
+        shutdownInProgress = true;
+        log('开始优雅关闭...');
+        clearTimeout(timeoutTimer);
+        try {
+            await server.stop();
+            log('WS Server 已关闭');
+        }
+        catch (err) {
+            log(`WS Server 关闭失败: ${err}`, 'error');
+        }
+        try {
+            await configServer.stop();
+            log('ConfigServer 已关闭');
+        }
+        catch (err) {
+            log(`ConfigServer 关闭失败: ${err}`, 'error');
+        }
+        try {
+            await devServer.stop();
+            log('webpack-dev-server 已关闭');
+        }
+        catch (err) {
+            log(`webpack-dev-server 关闭失败: ${err}`, 'error');
+        }
+        removePid(pidPath);
+        log('PID 文件已删除');
+        logStream.end(() => {
+            process.exit(0);
+        });
+    }
+    // 信号处理
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+    try {
+        await server.start();
+        log(`WS Server 已启动 (端口 ${config.wsPort})`);
+    }
+    catch (err) {
+        log(`WS Server 启动失败: ${err}`, 'error');
+        process.send?.({ type: 'error', message: `WS Server 启动失败: ${err}` });
+        process.exit(1);
+    }
+    try {
+        await configServer.start();
+        log(`ConfigServer 已启动 (端口 ${config.configPort})`);
+    }
+    catch (err) {
+        log(`ConfigServer 启动失败: ${err}`, 'warn');
+        // ConfigServer 非关键，启动失败不阻塞
+    }
+    try {
+        devServer.start();
+        log(`webpack-dev-server 启动中 (端口 ${config.devServerPort})`);
+    }
+    catch (err) {
+        log(`webpack-dev-server 启动失败: ${err}`, 'error');
+        await server.stop();
+        process.send?.({ type: 'error', message: `webpack-dev-server 启动失败: ${err}` });
+        process.exit(1);
+    }
+    // 写入 PID 文件
+    writePid(pidPath, process.pid);
+    log(`PID 文件已写入: ${pidPath} (PID: ${process.pid})`);
+    // 启动超时计时器
+    resetTimeout();
+    // 通知父进程就绪
+    process.send?.({
+        type: 'ready',
+        wsPort: config.wsPort,
+        devServerPort: config.devServerPort,
+        configPort: config.configPort,
+        pid: process.pid,
+    });
+    // 断开 IPC 通道（让父进程可以退出）
+    if (process.channel) {
+        process.channel.unref();
+    }
+}
+main().catch((err) => {
+    console.error('守护进程启动失败:', err);
+    process.exit(1);
+});

package/dist/cli/daemon/dev-server.d.ts

@@ -0,0 +1,26 @@
+/**
+ * webpack-dev-server 子进程管理
+ *
+ * 在 remnote-plugin 目录下启动 npm run dev。
+ */
+export interface DevServerOptions {
+    pluginDir: string;
+    port: number;
+    onLog?: (message: string, level: 'info' | 'warn' | 'error') => void;
+    onExit?: (code: number | null) => void;
+}
+export declare class DevServerManager {
+    private child;
+    private options;
+    constructor(options: DevServerOptions);
+    /**
+     * 启动 webpack-dev-server。
+     * 如果 remnote-plugin 目录不存在，抛出错误。
+     */
+    start(): void;
+    /**
+     * 停止 webpack-dev-server。
+     */
+    stop(): Promise<void>;
+    isRunning(): boolean;
+}

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

@@ -0,0 +1,81 @@
+/**
+ * webpack-dev-server 子进程管理
+ *
+ * 在 remnote-plugin 目录下启动 npm run dev。
+ */
+import { spawn, execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+export class DevServerManager {
+    child = null;
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * 启动 webpack-dev-server。
+     * 如果 remnote-plugin 目录不存在，抛出错误。
+     */
+    start() {
+        const { pluginDir, port, onLog, onExit } = this.options;
+        if (!fs.existsSync(path.join(pluginDir, 'package.json'))) {
+            throw new Error(`Plugin 目录不存在或缺少 package.json: ${pluginDir}`);
+        }
+        // 首次使用时自动安装 plugin 依赖
+        if (!fs.existsSync(path.join(pluginDir, 'node_modules'))) {
+            onLog?.('[dev-server] remnote-plugin/node_modules 不存在，正在安装依赖...', 'info');
+            execSync('npm install', { cwd: pluginDir, stdio: 'pipe' });
+            onLog?.('[dev-server] 依赖安装完成', 'info');
+        }
+        // 通过环境变量传递端口
+        this.child = spawn('npm', ['run', 'dev'], {
+            cwd: pluginDir,
+            env: { ...process.env, PORT: String(port) },
+            stdio: 'pipe',
+        });
+        this.child.stdout?.on('data', (data) => {
+            onLog?.(`[dev-server] ${data.toString().trim()}`, 'info');
+        });
+        this.child.stderr?.on('data', (data) => {
+            onLog?.(`[dev-server] ${data.toString().trim()}`, 'warn');
+        });
+        this.child.on('exit', (code) => {
+            onLog?.(`webpack-dev-server 退出 (code: ${code})`, code === 0 ? 'info' : 'error');
+            this.child = null;
+            onExit?.(code);
+        });
+        this.child.on('error', (err) => {
+            onLog?.(`webpack-dev-server 启动失败: ${err.message}`, 'error');
+            this.child = null;
+            onExit?.(1);
+        });
+    }
+    /**
+     * 停止 webpack-dev-server。
+     */
+    stop() {
+        return new Promise((resolve) => {
+            if (!this.child) {
+                resolve();
+                return;
+            }
+            // 5 秒后强制 kill
+            const forceKillTimer = setTimeout(() => {
+                if (this.child) {
+                    this.child.kill('SIGKILL');
+                    this.child = null;
+                    resolve();
+                }
+            }, 5000);
+            this.child.on('exit', () => {
+                clearTimeout(forceKillTimer);
+                this.child = null;
+                resolve();
+            });
+            this.child.kill('SIGTERM');
+        });
+    }
+    isRunning() {
+        return this.child !== null && !this.child.killed;
+    }
+}

package/dist/cli/daemon/pid.d.ts

@@ -0,0 +1,34 @@
+/**
+ * PID 文件管理
+ *
+ * 写入、读取、stale 检测、清理。
+ */
+/**
+ * 写入 PID 文件
+ */
+export declare function writePid(filePath: string, pid: number): void;
+/**
+ * 读取 PID 文件。文件不存在返回 null。
+ */
+export declare function readPid(filePath: string): number | null;
+/**
+ * 删除 PID 文件
+ */
+export declare function removePid(filePath: string): void;
+/**
+ * 检查进程是否存活
+ */
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * 检查守护进程状态。返回：
+ * - { running: true, pid } — 守护进程正在运行
+ * - { running: false } — 守护进程未运行（无 PID 文件或 stale）
+ *
+ * 若 PID 文件存在但进程已死（stale），自动清理 PID 文件。
+ */
+export declare function checkDaemon(pidPath: string): {
+    running: true;
+    pid: number;
+} | {
+    running: false;
+};

package/dist/cli/daemon/pid.js

@@ -0,0 +1,67 @@
+/**
+ * PID 文件管理
+ *
+ * 写入、读取、stale 检测、清理。
+ */
+import fs from 'fs';
+/**
+ * 写入 PID 文件
+ */
+export function writePid(filePath, pid) {
+    fs.writeFileSync(filePath, String(pid), 'utf-8');
+}
+/**
+ * 读取 PID 文件。文件不存在返回 null。
+ */
+export function readPid(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8').trim();
+        const pid = parseInt(content, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 删除 PID 文件
+ */
+export function removePid(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // 文件不存在也没关系
+    }
+}
+/**
+ * 检查进程是否存活
+ */
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检查守护进程状态。返回：
+ * - { running: true, pid } — 守护进程正在运行
+ * - { running: false } — 守护进程未运行（无 PID 文件或 stale）
+ *
+ * 若 PID 文件存在但进程已死（stale），自动清理 PID 文件。
+ */
+export function checkDaemon(pidPath) {
+    const pid = readPid(pidPath);
+    if (pid === null) {
+        return { running: false };
+    }
+    if (isProcessAlive(pid)) {
+        return { running: true, pid };
+    }
+    // stale PID 文件，清理
+    removePid(pidPath);
+    return { running: false };
+}

package/dist/cli/daemon/send-request.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Daemon 通信工具 — CLI 命令向守护进程发送请求的通用方法
+ *
+ * 封装 WS 连接建立、请求发送、响应等待、超时处理的完整流程。
+ * 所有业务命令（health、read-rem、edit-rem 等）均通过此函数与 daemon 通信。
+ */
+export declare class DaemonNotRunningError extends Error {
+    constructor();
+}
+export declare class DaemonUnreachableError extends Error {
+    constructor(cause: string);
+}
+/**
+ * 向守护进程发送请求并等待响应。
+ *
+ * 流程：读取 PID 文件 → 建立 WS 连接 → 发送 BridgeRequest → 等待 BridgeResponse → 关闭连接
+ *
+ * @throws DaemonNotRunningError — PID 文件不存在或进程已死
+ * @throws DaemonUnreachableError — WS 连接失败
+ * @throws Error — daemon 返回 error 字段或响应超时
+ */
+export declare function sendDaemonRequest(action: string, payload?: Record<string, unknown>, options?: {
+    timeout?: number;
+}): Promise<unknown>;

package/dist/cli/daemon/send-request.js

@@ -0,0 +1,92 @@
+/**
+ * Daemon 通信工具 — CLI 命令向守护进程发送请求的通用方法
+ *
+ * 封装 WS 连接建立、请求发送、响应等待、超时处理的完整流程。
+ * 所有业务命令（health、read-rem、edit-rem 等）均通过此函数与 daemon 通信。
+ */
+import WebSocket from 'ws';
+import crypto from 'crypto';
+import { loadConfig, pidFilePath, findProjectRoot } from '../config.js';
+import { checkDaemon } from './pid.js';
+import { isBridgeResponse } from '../protocol.js';
+const CONNECT_TIMEOUT_MS = 5_000;
+const DEFAULT_RESPONSE_TIMEOUT_MS = 30_000;
+export class DaemonNotRunningError extends Error {
+    constructor() {
+        super('守护进程未运行，请先执行 remnote-bridge connect');
+        this.name = 'DaemonNotRunningError';
+    }
+}
+export class DaemonUnreachableError extends Error {
+    constructor(cause) {
+        super(`无法连接守护进程: ${cause}`);
+        this.name = 'DaemonUnreachableError';
+    }
+}
+/**
+ * 向守护进程发送请求并等待响应。
+ *
+ * 流程：读取 PID 文件 → 建立 WS 连接 → 发送 BridgeRequest → 等待 BridgeResponse → 关闭连接
+ *
+ * @throws DaemonNotRunningError — PID 文件不存在或进程已死
+ * @throws DaemonUnreachableError — WS 连接失败
+ * @throws Error — daemon 返回 error 字段或响应超时
+ */
+export async function sendDaemonRequest(action, payload = {}, options) {
+    const projectRoot = findProjectRoot();
+    const config = loadConfig(projectRoot);
+    const pidPath = pidFilePath(projectRoot);
+    // 检查 daemon 是否运行
+    const daemonStatus = checkDaemon(pidPath);
+    if (!daemonStatus.running) {
+        throw new DaemonNotRunningError();
+    }
+    const responseTimeout = options?.timeout ?? DEFAULT_RESPONSE_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(`ws://127.0.0.1:${config.wsPort}`);
+        const requestId = crypto.randomUUID();
+        let responseTimer = null;
+        const connectTimer = setTimeout(() => {
+            ws.terminate();
+            reject(new DaemonUnreachableError('连接超时'));
+        }, CONNECT_TIMEOUT_MS);
+        ws.on('open', () => {
+            clearTimeout(connectTimer);
+            responseTimer = setTimeout(() => {
+                ws.terminate();
+                reject(new Error(`请求超时 (${responseTimeout / 1000}s): ${action}`));
+            }, responseTimeout);
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (isBridgeResponse(msg) && msg.id === requestId) {
+                        if (responseTimer)
+                            clearTimeout(responseTimer);
+                        ws.close();
+                        if (msg.error) {
+                            reject(new Error(msg.error));
+                        }
+                        else {
+                            resolve(msg.result);
+                        }
+                    }
+                }
+                catch {
+                    // 忽略非 JSON 消息
+                }
+            });
+            // 发送请求
+            ws.send(JSON.stringify({
+                id: requestId,
+                action,
+                payload,
+            }));
+        });
+        ws.on('error', (err) => {
+            clearTimeout(connectTimer);
+            if (responseTimer)
+                clearTimeout(responseTimer);
+            reject(new DaemonUnreachableError(err.message));
+        });
+    });
+}

package/dist/cli/handlers/context-read-handler.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ContextReadHandler — read-context 请求的业务编排
+ *
+ * 职责：转发到 Plugin 获取上下文视图，返回结果。
+ */
+import type { DefaultsConfig } from '../config.js';
+export interface ContextReadResult {
+    nodeCount: number;
+    outline: string;
+    breadcrumb: string[];
+    mode: 'focus' | 'page';
+}
+export declare class ContextReadHandler {
+    private forwardToPlugin;
+    private defaults;
+    constructor(forwardToPlugin: (action: string, payload: Record<string, unknown>) => Promise<unknown>, defaults?: DefaultsConfig);
+    handleReadContext(payload: Record<string, unknown>): Promise<ContextReadResult>;
+}

package/dist/cli/handlers/context-read-handler.js

@@ -0,0 +1,24 @@
+/**
+ * ContextReadHandler — read-context 请求的业务编排
+ *
+ * 职责：转发到 Plugin 获取上下文视图，返回结果。
+ */
+import { DEFAULT_DEFAULTS } from '../config.js';
+export class ContextReadHandler {
+    forwardToPlugin;
+    defaults;
+    constructor(forwardToPlugin, defaults) {
+        this.forwardToPlugin = forwardToPlugin;
+        this.defaults = defaults ?? DEFAULT_DEFAULTS;
+    }
+    async handleReadContext(payload) {
+        const mode = payload.mode ?? this.defaults.readContextMode;
+        const ancestorLevels = payload.ancestorLevels ?? this.defaults.readContextAncestorLevels;
+        const depth = payload.depth ?? this.defaults.readContextDepth;
+        const maxNodes = payload.maxNodes ?? this.defaults.maxNodes;
+        const maxSiblings = payload.maxSiblings ?? this.defaults.maxSiblings;
+        return await this.forwardToPlugin('read_context', {
+            mode, ancestorLevels, depth, maxNodes, maxSiblings,
+        });
+    }
+}

package/dist/cli/handlers/edit-handler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * EditHandler — edit-rem 命令的编排器
+ *
+ * 在 daemon 层实现三道防线 + str_replace + 后处理校验。
+ * Plugin 只负责原子写入（write_rem_fields）。
+ *
+ * 防线 1：缓存存在性检查（必须先 read 再 edit）
+ * 防线 2：乐观并发检测（当前 JSON 与缓存 JSON 比较）
+ * 防线 3：str_replace 精确匹配（old_str 必须唯一匹配）
+ */
+import { RemCache } from './rem-cache.js';
+export interface EditRemPayload {
+    remId: string;
+    oldStr: string;
+    newStr: string;
+}
+export interface EditRemResult {
+    ok: boolean;
+    changes: string[];
+    warnings: string[];
+    error?: string;
+    appliedChanges?: string[];
+    failedField?: string;
+}
+export declare class EditHandler {
+    private cache;
+    private forwardToPlugin;
+    constructor(cache: RemCache, forwardToPlugin: (action: string, payload: Record<string, unknown>) => Promise<unknown>);
+    handleEditRem(payload: EditRemPayload): Promise<EditRemResult>;
+}