friday-mcp-v2 2.0.6 → 3.0.0

package/dist/bridge-client.js

@@ -0,0 +1,210 @@
+import net from 'node:net';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { dirname, resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { setTimeout as delay } from 'node:timers/promises';
+import {
+    BRIDGE_TIMEOUTS,
+    createBridgeError,
+    getBridgeEndpoint,
+    isRecoverableBridgeError,
+    normalizeSiteUrl,
+} from './bridge-common.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export class BridgeClient {
+    constructor(options = {}) {
+        this.endpoint = options.endpoint || getBridgeEndpoint();
+        this.bridgeScriptPath = options.bridgeScriptPath || resolvePath(__dirname, 'friday-bridge.js');
+        this.startPromise = null;
+    }
+
+    async ping(timeoutMs = 1000, autoStart = false) {
+        return this.request('ping', {}, { timeoutMs, autoStart });
+    }
+
+    async ensureBridgeRunning() {
+        if (this.startPromise) return this.startPromise;
+        this.startPromise = this._ensureBridgeRunning();
+        try {
+            return await this.startPromise;
+        } finally {
+            this.startPromise = null;
+        }
+    }
+
+    async _ensureBridgeRunning() {
+        try {
+            await this.ping(1000, false);
+            return;
+        } catch {
+            // bridge 未起動
+        }
+
+        const child = spawn(process.execPath, [this.bridgeScriptPath], {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+            env: process.env,
+        });
+        child.unref();
+
+        const deadline = Date.now() + BRIDGE_TIMEOUTS.STARTUP;
+        let lastError = null;
+        while (Date.now() < deadline) {
+            await delay(BRIDGE_TIMEOUTS.STARTUP_POLL);
+            try {
+                await this.ping(1000, false);
+                return;
+            } catch (error) {
+                lastError = error;
+            }
+        }
+
+        throw createBridgeError(
+            'BRIDGE_UNAVAILABLE',
+            `Bridge failed to start: ${lastError?.message || 'unknown error'}`,
+            true
+        );
+    }
+
+    async request(method, params = {}, options = {}) {
+        const timeoutMs = options.timeoutMs || BRIDGE_TIMEOUTS.READ;
+        const autoStart = options.autoStart !== false;
+        try {
+            return await this._requestOnce(method, params, timeoutMs);
+        } catch (error) {
+            if (autoStart && isRecoverableBridgeError(error)) {
+                await this.ensureBridgeRunning();
+                return this._requestOnce(method, params, timeoutMs);
+            }
+            throw error;
+        }
+    }
+
+    _requestOnce(method, params, timeoutMs) {
+        const requestId = crypto.randomUUID();
+        return new Promise((resolve, reject) => {
+            const socket = process.platform === 'win32'
+                ? net.createConnection(this.endpoint)
+                : net.createConnection({ path: this.endpoint });
+
+            let settled = false;
+            let buffer = '';
+
+            const finish = (fn, value) => {
+                if (settled) return;
+                settled = true;
+                clearTimeout(timer);
+                socket.destroy();
+                fn(value);
+            };
+
+            const timer = setTimeout(() => {
+                finish(reject, createBridgeError('BRIDGE_TIMEOUT', `Bridge RPC timeout: ${method}`, true));
+            }, timeoutMs);
+
+            socket.setEncoding('utf8');
+
+            socket.on('connect', () => {
+                socket.write(JSON.stringify({
+                    type: 'request',
+                    id: requestId,
+                    method,
+                    params,
+                }) + '\n');
+            });
+
+            socket.on('data', (chunk) => {
+                buffer += chunk;
+                while (true) {
+                    const newline = buffer.indexOf('\n');
+                    if (newline === -1) break;
+                    const line = buffer.slice(0, newline).trim();
+                    buffer = buffer.slice(newline + 1);
+                    if (!line) continue;
+                    let message;
+                    try {
+                        message = JSON.parse(line);
+                    } catch {
+                        continue;
+                    }
+                    if (message.type !== 'response' || message.id !== requestId) continue;
+                    if (message.ok) {
+                        finish(resolve, message.result);
+                    } else {
+                        finish(reject, createBridgeError(
+                            message.error?.code || 'BRIDGE_UNAVAILABLE',
+                            message.error?.message || `Bridge RPC failed: ${method}`,
+                            !!message.error?.retryable
+                        ));
+                    }
+                }
+            });
+
+            socket.on('error', (error) => {
+                finish(reject, error);
+            });
+
+            socket.on('close', () => {
+                if (!settled) {
+                    finish(reject, createBridgeError('BRIDGE_UNAVAILABLE', `Bridge connection closed: ${method}`, true));
+                }
+            });
+        });
+    }
+
+    async getBridgeStatus(options = {}) {
+        return this.request('getBridgeStatus', {}, { timeoutMs: BRIDGE_TIMEOUTS.READ, ...options });
+    }
+
+    async listConnections(options = {}) {
+        return this.request('listConnections', {}, { timeoutMs: BRIDGE_TIMEOUTS.READ, ...options });
+    }
+
+    async getConnectedEditors(siteUrl, options = {}) {
+        const result = await this.listConnections(options);
+        return (result.sessions || []).filter((session) => session.siteUrl === normalizeSiteUrl(siteUrl));
+    }
+
+    async isPostEditing(postId, siteUrl, options = {}) {
+        const result = await this.listConnections(options);
+        return (result.sessions || []).some((session) =>
+            session.siteUrl === normalizeSiteUrl(siteUrl) && Number(session.postId) === Number(postId)
+        );
+    }
+
+    async getEditorState(params, options = {}) {
+        return this.request('getEditorState', params, { timeoutMs: BRIDGE_TIMEOUTS.READ, ...options });
+    }
+
+    async getSelection(params, options = {}) {
+        return this.request('getSelection', params, { timeoutMs: BRIDGE_TIMEOUTS.READ, ...options });
+    }
+
+    async getArticleStructure(params, options = {}) {
+        return this.request('getArticleStructure', params, { timeoutMs: BRIDGE_TIMEOUTS.READ, ...options });
+    }
+
+    async sendEditorCommand(params, options = {}) {
+        return this.request('sendEditorCommand', params, { timeoutMs: BRIDGE_TIMEOUTS.MUTATION, ...options });
+    }
+
+    async selectBlock(params, options = {}) {
+        return this.request('selectBlock', params, { timeoutMs: BRIDGE_TIMEOUTS.MUTATION, ...options });
+    }
+
+    async searchBlocks(params, options = {}) {
+        return this.request('searchBlocks', params, { timeoutMs: BRIDGE_TIMEOUTS.COMMAND, ...options });
+    }
+
+    async sendTabCommand(params, options = {}) {
+        return this.request('sendTabCommand', params, { timeoutMs: BRIDGE_TIMEOUTS.MUTATION, ...options });
+    }
+
+    async shutdown(options = {}) {
+        return this.request('shutdown', {}, { timeoutMs: BRIDGE_TIMEOUTS.READ, autoStart: false, ...options });
+    }
+}

package/dist/bridge-common.js

@@ -0,0 +1,92 @@
+import os from 'node:os';
+import { join } from 'node:path';
+
+export const BRIDGE_TIMEOUTS = {
+    READ: 5000,
+    COMMAND: 30000,
+    MUTATION: 120000,
+    STARTUP: 5000,
+    STARTUP_POLL: 250,
+    STALE_SESSION_MS: 60000,
+    OWNER_WAIT: 10000,
+    OWNER_WAIT_INTERVAL: 1000,
+    PER_ARTICLE_QUEUE_LIMIT: 20,
+    GLOBAL_QUEUE_LIMIT: 200,
+};
+
+export function normalizeSiteUrl(url) {
+    return url?.replace(/\/+$/, '') || '';
+}
+
+export function sanitizeIdentifier(value) {
+    const sanitized = String(value || 'user').replace(/[^a-zA-Z0-9_.-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+    return sanitized || 'user';
+}
+
+export function getCurrentUserTag() {
+    try {
+        return sanitizeIdentifier(os.userInfo().username);
+    } catch {
+        return sanitizeIdentifier(process.env.USERNAME || process.env.USER || 'user');
+    }
+}
+
+export function getBridgeEndpoint() {
+    const userTag = getCurrentUserTag();
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\friday-mcp-v2-${userTag}`;
+    }
+    const runtimeDir = process.env.XDG_RUNTIME_DIR || join(os.tmpdir(), `friday-mcp-${userTag}`);
+    return join(runtimeDir, 'bridge.sock');
+}
+
+export function getBridgeLogPath() {
+    if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA || join(os.homedir(), 'AppData', 'Local');
+        return join(localAppData, 'FridayMCP', 'logs', 'bridge.log');
+    }
+    return join(os.homedir(), '.local', 'share', 'friday-mcp', 'logs', 'bridge.log');
+}
+
+export function getBridgePidPath() {
+    if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA || join(os.homedir(), 'AppData', 'Local');
+        return join(localAppData, 'FridayMCP', 'bridge.pid');
+    }
+    return join(os.homedir(), '.local', 'share', 'friday-mcp', 'bridge.pid');
+}
+
+export function buildArticleKey(siteUrl, postId) {
+    return `${normalizeSiteUrl(siteUrl)}::${Number(postId)}`;
+}
+
+export function parseArticleKey(articleKey) {
+    const idx = articleKey.lastIndexOf('::');
+    if (idx === -1) return { siteUrl: '', postId: NaN };
+    return {
+        siteUrl: articleKey.slice(0, idx),
+        postId: Number(articleKey.slice(idx + 2)),
+    };
+}
+
+export function isRecoverableBridgeError(error) {
+    const message = error?.message || '';
+    const code = error?.code || error?.bridgeCode || '';
+    return [
+        'ENOENT',
+        'ECONNREFUSED',
+        'ECONNRESET',
+        'EPIPE',
+        'ETIMEDOUT',
+        'BRIDGE_UNAVAILABLE',
+        'BRIDGE_TIMEOUT',
+    ].includes(code) || /not connected|socket hang up|connect/i.test(message);
+}
+
+export function createBridgeError(code, message, retryable = false) {
+    const error = new Error(message);
+    error.code = code;
+    error.bridgeCode = code;
+    error.retryable = retryable;
+    return error;
+}

package/dist/editor-session-store.js

@@ -0,0 +1,164 @@
+/**
+ * F.R.I.D.A.Y Editor Session Store — Phase 2B
+ *
+ * WS 経由で受信した エディタ状態を Node メモリ内に保持するストア。
+ * 外部依存なし。全サイト共通の 1 インスタンスで運用。
+ */
+
+export class EditorSessionStore {
+    constructor() {
+        /** @type {Map<string, SessionState>} sessionId → SessionState */
+        this.sessions = new Map();
+    }
+
+    // =========================================================================
+    // 書き込み API（ws-server.js から呼ばれる）
+    // =========================================================================
+
+    register(sessionId, { postId, siteUrl, tabId, postTitle }) {
+        const now = Date.now();
+        const existing = this.sessions.get(sessionId);
+        this.sessions.set(sessionId, {
+            postId: Number(postId),
+            siteUrl: this._normUrl(siteUrl),
+            tabId,
+            postTitle: postTitle || '',
+            registeredAt: existing?.registeredAt || now,
+            lastRegisterAt: now,
+            lastTouchedAt: now,
+            lastTouchSource: 'register',
+            touchCount: (existing?.touchCount || 0) + 1,
+            lastStateSyncAt: existing?.lastStateSyncAt || 0,
+            lastSelectionSyncAt: existing?.lastSelectionSyncAt || 0,
+            lastHeartbeatAt: existing?.lastHeartbeatAt || 0,
+            // 状態データ（既存があれば引き継ぎ — WS 再接続時の register 再送で消さないため）
+            selectedBlock: existing?.selectedBlock ?? null,
+            allBlocks: existing?.allBlocks ?? null,
+            headings: existing?.headings ?? null,
+            blockSummary: existing?.blockSummary ?? null,
+            selectionSynced: existing?.selectionSynced ?? false,
+            stateSynced: existing?.stateSynced ?? false,
+        });
+    }
+
+    unregister(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+
+    clear() {
+        this.sessions.clear();
+    }
+
+    updateState(sessionId, { blockSummary, allBlocks, headings }) {
+        const session = this.sessions.get(sessionId);
+        if (!session) return;
+        session.blockSummary = blockSummary ?? session.blockSummary;
+        session.allBlocks = allBlocks ?? session.allBlocks;
+        session.headings = headings ?? session.headings;
+        session.stateSynced = true;
+        session.lastTouchedAt = Date.now();
+        session.lastTouchSource = 'state-sync';
+        session.lastStateSyncAt = session.lastTouchedAt;
+        session.touchCount++;
+    }
+
+    updateSelection(sessionId, selectedBlock) {
+        const session = this.sessions.get(sessionId);
+        if (!session) return;
+        session.selectedBlock = selectedBlock;
+        session.selectionSynced = true;
+        session.lastTouchedAt = Date.now();
+        session.lastTouchSource = 'selection-sync';
+        session.lastSelectionSyncAt = session.lastTouchedAt;
+        session.touchCount++;
+    }
+
+    touch(sessionId, source) {
+        const session = this.sessions.get(sessionId);
+        if (!session) return;
+        session.lastTouchedAt = Date.now();
+        session.lastTouchSource = source;
+        if (source === 'heartbeat') {
+            session.lastHeartbeatAt = session.lastTouchedAt;
+        }
+        session.touchCount++;
+    }
+
+    // =========================================================================
+    // 読み取り API（mcp-server.js / wordpress-api.js から呼ばれる）
+    // =========================================================================
+
+    get(sessionId) {
+        return this.sessions.get(sessionId) || null;
+    }
+
+    /** @param {number} postId @param {string} siteUrl — 必須 */
+    getByPostId(postId, siteUrl) {
+        const normSite = this._normUrl(siteUrl);
+        const results = [];
+        for (const [sessionId, s] of this.sessions) {
+            if (s.postId === Number(postId) && s.siteUrl === normSite) {
+                results.push({ sessionId, ...s });
+            }
+        }
+        return results;
+    }
+
+    getBySiteUrl(siteUrl) {
+        const normSite = this._normUrl(siteUrl);
+        const results = [];
+        for (const [sessionId, s] of this.sessions) {
+            if (s.siteUrl === normSite) {
+                results.push({ sessionId, ...s });
+            }
+        }
+        return results;
+    }
+
+    /** PHP `/status` 互換の connectedEditors[] を返す */
+    getConnectedEditors(siteUrl) {
+        const normSite = siteUrl ? this._normUrl(siteUrl) : null;
+        const results = [];
+        for (const [sessionId, s] of this.sessions) {
+            if (normSite && s.siteUrl !== normSite) continue;
+            results.push({
+                sessionId,
+                postId: s.postId,
+                postTitle: s.postTitle,
+                siteUrl: s.siteUrl,
+                tabId: s.tabId,
+            });
+        }
+        return results;
+    }
+
+    /** @param {number} postId @param {string} siteUrl — 必須 */
+    isPostEditing(postId, siteUrl) {
+        return this.getByPostId(postId, siteUrl).length > 0;
+    }
+
+    hasStructure(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.stateSynced === true;
+    }
+
+    hasSelection(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.selectionSynced === true;
+    }
+
+    getAll() {
+        return Array.from(this.sessions.entries()).map(([sessionId, s]) => ({
+            sessionId,
+            ...s,
+        }));
+    }
+
+    // =========================================================================
+    // Internal
+    // =========================================================================
+
+    _normUrl(url) {
+        return url?.replace(/\/+$/, '') || '';
+    }
+}