@rikaidev/yomi 0.6.2 → 0.6.5

package/dist/mcp/daemon.js

@@ -0,0 +1,333 @@
+/**
+ * Yomi MCP Shared Daemon.
+ *
+ * Runs a single, persistent Yomi instance (holding one LINE session, one
+ * Transformers embedding model, and one SQLite search index) as a background
+ * daemon. Multiple AI clients (OpenCode, Minimax, Claude Code, Cursor, Agy)
+ * share this daemon via HTTP/SSE or transparent stdio proxies, eliminating
+ * redundant processes, memory duplication, and session race conditions.
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { createServer } from 'node:http';
+import { dirname } from 'node:path';
+import { Readable } from 'node:stream';
+import { createMcpHandler, ReadBuffer, serializeMessage, } from '@modelcontextprotocol/server';
+import { LineProtocolService } from '../line/core/service.js';
+import { startCapture } from '../search/capture.js';
+import { getDefaultEmbedder } from '../search/default-embedder.js';
+import { yomiDataPath } from '../util/data-dir.js';
+import { createCliLogger } from '../util/log.js';
+import { checkForUpdate } from '../util/update-check.js';
+import { YOMI_VERSION } from '../version.js';
+import { NO_CREDENTIALS_MESSAGE } from './handlers/index.js';
+import { buildInstructions, createBuildServer } from './server.js';
+const log = createCliLogger('YomiDaemon');
+export const DEFAULT_DAEMON_PORT = 3333;
+export const DEFAULT_DAEMON_HOST = '127.0.0.1';
+export function daemonInfoPath() {
+    return yomiDataPath('daemon.json');
+}
+export function readDaemonInfo() {
+    const file = daemonInfoPath();
+    if (!existsSync(file)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(file, 'utf8');
+        const data = JSON.parse(raw);
+        if (!data.pid || !data.port) {
+            return null;
+        }
+        // Verify whether the process is actually alive
+        try {
+            process.kill(data.pid, 0);
+            return data;
+        }
+        catch {
+            // Process is dead, clean up stale state file
+            try {
+                rmSync(file);
+            }
+            catch { }
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+export async function isDaemonHealthy(info) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch(`http://${info.host}:${info.port}/health`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            return false;
+        }
+        const json = (await res.json());
+        return json?.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getRunningDaemon() {
+    const info = readDaemonInfo();
+    if (!info) {
+        return null;
+    }
+    const healthy = await isDaemonHealthy(info);
+    if (healthy) {
+        return info;
+    }
+    // Check if PID is still alive. If alive, do NOT delete daemon.json (avoid competing instances)
+    try {
+        process.kill(info.pid, 0);
+        return info;
+    }
+    catch {
+        try {
+            rmSync(daemonInfoPath());
+        }
+        catch { }
+        return null;
+    }
+}
+export async function startDaemonServer(options = {}) {
+    const host = options.host ?? DEFAULT_DAEMON_HOST;
+    const requestedPort = options.port ??
+        (process.env.YOMI_PORT
+            ? parseInt(process.env.YOMI_PORT, 10)
+            : DEFAULT_DAEMON_PORT);
+    const service = options.service ?? new LineProtocolService();
+    service.on('error', (error) => log.warn('service.error', { error: error?.message ?? String(error) }));
+    const resumed = await service.resumeSession();
+    if (!resumed) {
+        log.warn('session.resume_failed', { message: NO_CREDENTIALS_MESSAGE });
+    }
+    else {
+        log.info('session.resumed', { mid: service.profile?.mid ?? null });
+        startCapture(service, getDefaultEmbedder()).catch((error) => {
+            log.error('capture.start_failed', {
+                error: error?.message ?? String(error),
+            });
+        });
+    }
+    const updateNotice = await checkForUpdate();
+    if (updateNotice) {
+        log.info('update.available', { current: YOMI_VERSION });
+    }
+    const instructions = buildInstructions(updateNotice);
+    const buildServer = createBuildServer(service, instructions);
+    const mcpHandler = createMcpHandler(buildServer, {
+        legacy: 'stateless',
+        onerror: (error) => log.error('server.protocol_error', {
+            error: error?.message ?? String(error),
+        }),
+    });
+    const server = createServer(async (req, res) => {
+        // Health and status endpoint
+        if (req.url === '/health' || req.url === '/status') {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({
+                ok: true,
+                version: YOMI_VERSION,
+                pid: process.pid,
+                uptime: process.uptime(),
+                session: service.profile ? { mid: service.profile.mid } : null,
+                loginRequired: service.loginRequired ?? false,
+            }));
+            return;
+        }
+        // Modern / Streamable HTTP & Legacy MCP endpoint
+        const url = `http://${req.headers.host || `${host}:${requestedPort}`}${req.url}`;
+        const headers = new Headers();
+        for (const [k, v] of Object.entries(req.headers)) {
+            if (v) {
+                headers.set(k, Array.isArray(v) ? v.join(', ') : v);
+            }
+        }
+        // Ensure Accept header includes text/event-stream for MCP spec compliance
+        const accept = headers.get('accept');
+        if (!accept) {
+            headers.set('accept', 'application/json, text/event-stream');
+        }
+        else if (!accept.includes('text/event-stream')) {
+            headers.set('accept', `${accept}, text/event-stream`);
+        }
+        const body = req.method === 'GET' || req.method === 'HEAD'
+            ? undefined
+            : Readable.toWeb(req);
+        const webReq = new Request(url, {
+            method: req.method,
+            headers,
+            body,
+            duplex: 'half',
+        });
+        try {
+            const webRes = await mcpHandler.fetch(webReq);
+            res.writeHead(webRes.status, Object.fromEntries(webRes.headers.entries()));
+            if (webRes.body) {
+                const reader = webRes.body.getReader();
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    res.write(value);
+                }
+            }
+            res.end();
+        }
+        catch (error) {
+            res.writeHead(500, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({
+                jsonrpc: '2.0',
+                error: { code: -32603, message: error?.message ?? String(error) },
+                id: null,
+            }));
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.on('error', reject);
+        server.listen(requestedPort, host, () => resolve());
+    });
+    const addr = server.address();
+    const actualPort = typeof addr === 'object' && addr ? addr.port : requestedPort;
+    const info = {
+        pid: process.pid,
+        port: actualPort,
+        host,
+        startedAt: new Date().toISOString(),
+        version: YOMI_VERSION,
+    };
+    try {
+        const file = daemonInfoPath();
+        const dir = dirname(file);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(file, JSON.stringify(info, null, 2), 'utf8');
+    }
+    catch (err) {
+        log.warn('daemon.info_write_failed', { error: err?.message ?? String(err) });
+    }
+    const cleanup = () => {
+        try {
+            rmSync(daemonInfoPath());
+        }
+        catch { }
+        try {
+            server.close();
+        }
+        catch { }
+    };
+    process.once('SIGTERM', cleanup);
+    process.once('SIGINT', cleanup);
+    process.once('exit', cleanup);
+    if (!options.quiet) {
+        log.info('daemon.started', { port: actualPort, host, pid: process.pid });
+    }
+    return { server, port: actualPort, info };
+}
+export async function stopDaemon() {
+    const info = readDaemonInfo();
+    if (!info) {
+        return { stopped: false };
+    }
+    try {
+        process.kill(info.pid, 'SIGTERM');
+        const start = Date.now();
+        while (Date.now() - start < 3000) {
+            await new Promise((r) => setTimeout(r, 100));
+            try {
+                process.kill(info.pid, 0);
+            }
+            catch {
+                try {
+                    rmSync(daemonInfoPath());
+                }
+                catch { }
+                return { stopped: true, pid: info.pid };
+            }
+        }
+        // Force kill if graceful exit timed out
+        process.kill(info.pid, 'SIGKILL');
+        try {
+            rmSync(daemonInfoPath());
+        }
+        catch { }
+        return { stopped: true, pid: info.pid };
+    }
+    catch {
+        try {
+            rmSync(daemonInfoPath());
+        }
+        catch { }
+        return { stopped: false };
+    }
+}
+export async function proxyStdioToDaemon(info) {
+    const daemonUrl = `http://${info.host}:${info.port}/mcp`;
+    const readBuffer = new ReadBuffer();
+    process.stdin.on('data', (chunk) => {
+        readBuffer.append(chunk);
+        while (true) {
+            let message;
+            try {
+                message = readBuffer.readMessage();
+            }
+            catch (err) {
+                log.error('proxy.buffer_error', { error: err?.message ?? String(err) });
+                break;
+            }
+            if (!message)
+                break;
+            const body = serializeMessage(message);
+            fetch(daemonUrl, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json, text/event-stream',
+                },
+                body,
+            })
+                .then(async (res) => {
+                const text = await res.text();
+                const lines = text.split('\n');
+                let handled = false;
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6).trim();
+                        if (data) {
+                            process.stdout.write(`${data}\n`);
+                            handled = true;
+                        }
+                    }
+                }
+                if (!handled && text.trim()) {
+                    process.stdout.write(`${text.trim()}\n`);
+                }
+            })
+                .catch((error) => {
+                if (message.id !== undefined && message.id !== null) {
+                    const errResp = {
+                        jsonrpc: '2.0',
+                        id: message.id,
+                        error: {
+                            code: -32000,
+                            message: `Failed to forward request to Yomi daemon: ${error?.message ?? String(error)}`,
+                        },
+                    };
+                    process.stdout.write(`${JSON.stringify(errResp)}\n`);
+                }
+            });
+        }
+    });
+    await new Promise((resolve) => {
+        process.stdin.on('end', resolve);
+        process.stdin.on('close', resolve);
+    });
+}

package/dist/mcp/integrator.js

@@ -79,7 +79,7 @@ description: Manage and interact with user's LINE account via Yomi E2EE MCP Serv
 
 # Yomi LINE Copilot Skill
 
-You have real-time access to the user's LINE account through the Yomi Letter-Sealing E2EE server. Discover the current tools and complete a scoped read before claiming that access; the names below describe expected capabilities, not proof they are connected.
+You have real-time access to the user's LINE account through the Yomi Letter-Sealing E2EE server. Check which of these tools your runtime actually exposes, and complete a scoped read before claiming that access; the names below describe expected capabilities, not proof they are connected.
 
 ## Reading
 1. \`list_conversations\`: List the chats the account can see.
@@ -95,10 +95,16 @@ You have real-time access to the user's LINE account through the Yomi Letter-Sea
 2. \`unsend_message\`: Recall a message the account sent.
 
 ## Operating the server
+- The Yomi Model Context Protocol server is registered globally for the coding tools on this machine. Every tool keeps its own server list, so a tool that does not expose the names above is missing its own registration, not the server.
+- When the names above are in your tool list, call them directly. Start the server yourself only when they are absent.
 - The Model Context Protocol server speaks stdio and lives only while its stdin stays open. A command that closes stdin ends the server, so keep the pipe open for as long as the session needs it.
 - The \`yomi messages\` CLI reports an empty list; only the Model Context Protocol tools above return real messages.
 - \`unsend_message\` is irreversible, and LINE accepts a recall only within one hour of sending. A recall past that window is refused by LINE itself, not by the tool.
 
+## Recovering message text
+- A message can come back with no text while the conversation still holds it. The local search index keeps the plaintext, so look the same message id up in \`search-index.db\` in the Yomi data directory before you report a message as empty.
+- An empty text field is not proof of a recall. A recall is an unsend you made yourself, and LINE refuses one outside the first hour.
+
 ## Guidelines
 - Summarize conversations concisely and highlight action items or mentions needing attention.
 - Drafting does not authorize sending. Require explicit sending authorization for the recipient and content; reuse that exact authorization when already given.

package/dist/mcp/server.js

@@ -21,43 +21,8 @@ import { TOOLS } from './tools.js';
 import { LOGIN_UI_RESOURCE_CONTENTS, LOGIN_UI_RESOURCE_LISTING, LOGIN_UI_RESOURCE_URI, } from './ui/resource.js';
 import { toolsForClient } from './ui/tools-with-ui.js';
 const log = createCliLogger('Yomi');
-/**
- * Build and start the Yomi MCP server over stdio.
- */
-async function main() {
-    const service = new LineProtocolService();
-    // A Node EventEmitter with zero 'error' listeners turns any emit('error')
-    // into an uncaught exception that kills this process (see pwless-login-flow.ts,
-    // auth-session-service.ts). This listener must exist for the lifetime of the
-    // service so a login/session error surfaces as a log line, not a crash — the
-    // real failure still reaches callers through the normal throw/rejection path.
-    service.on('error', (error) => log.warn('service.error', { error: error?.message ?? String(error) }));
-    const resumed = await service.resumeSession();
-    if (!resumed) {
-        log.warn('session.resume_failed', { message: NO_CREDENTIALS_MESSAGE });
-    }
-    else {
-        log.info('session.resumed', { mid: service.profile?.mid ?? null });
-        startCapture(service, getDefaultEmbedder()).catch((error) => {
-            log.error('capture.start_failed', {
-                error: error?.message ?? String(error),
-            });
-        });
-    }
-    // Asked once per process, bounded, best-effort: a hand-installed .mcpb
-    // bundle never auto-updates, so this notice is the only way a GUI-only user
-    // learns a newer Yomi exists (see ../util/update-check.ts). Awaited here
-    // because `instructions` is built once, before any client connects.
-    const updateNotice = await checkForUpdate();
-    if (updateNotice) {
-        log.info('update.available', { current: YOMI_VERSION });
-    }
-    // `instructions` is surfaced by the MCP SDK to the client/model on
-    // initialize — a "TOS on connect" privacy disclosure. It is a consent
-    // notice, not decoration. A short model directive precedes the canonical
-    // policy prose, which lives ONLY in PRIVACY.md (see ./policy.ts) so the
-    // disclosure is single-sourced and never drifts from get_scope_policy.
-    const instructions = (updateNotice ? `${updateNotice}\n\n` : '') +
+export function buildInstructions(updateNotice) {
+    return ((updateNotice ? `${updateNotice}\n\n` : '') +
         'SESSION ERRORS — if a tool fails with a login-required or signed-out ' +
         'error, the MCP server and its connection are healthy: LINE revoked this ' +
         "device's session (usually because the same account logged in somewhere " +
@@ -82,8 +47,10 @@ async function main() {
         'is included below, so you do NOT need to call get_scope_policy just to recite the ' +
         'policy; call get_scope_policy only when the user asks to see the policy again or ' +
         'wants the current exclusion list. Policy follows:\n\n' +
-        getPrivacyPolicyText();
-    const buildServer = ({ era }) => {
+        getPrivacyPolicyText());
+}
+export function createBuildServer(service, instructions) {
+    return ({ era }) => {
         const server = new Server({ name: 'yomi', version: YOMI_VERSION }, {
             capabilities: { tools: {}, resources: {} },
             instructions,
@@ -258,6 +225,41 @@ async function main() {
         });
         return server;
     };
+}
+/**
+ * Build and start the Yomi MCP server over stdio.
+ */
+async function main() {
+    // If a background daemon is running and standalone is not forced, proxy stdio to it!
+    if (process.env.YOMI_STANDALONE !== '1') {
+        const { getRunningDaemon, proxyStdioToDaemon } = await import('./daemon.js');
+        const daemon = await getRunningDaemon();
+        if (daemon) {
+            log.info('daemon.connected', { port: daemon.port, pid: daemon.pid });
+            await proxyStdioToDaemon(daemon);
+            return;
+        }
+    }
+    const service = new LineProtocolService();
+    service.on('error', (error) => log.warn('service.error', { error: error?.message ?? String(error) }));
+    const resumed = await service.resumeSession();
+    if (!resumed) {
+        log.warn('session.resume_failed', { message: NO_CREDENTIALS_MESSAGE });
+    }
+    else {
+        log.info('session.resumed', { mid: service.profile?.mid ?? null });
+        startCapture(service, getDefaultEmbedder()).catch((error) => {
+            log.error('capture.start_failed', {
+                error: error?.message ?? String(error),
+            });
+        });
+    }
+    const updateNotice = await checkForUpdate();
+    if (updateNotice) {
+        log.info('update.available', { current: YOMI_VERSION });
+    }
+    const instructions = buildInstructions(updateNotice);
+    const buildServer = createBuildServer(service, instructions);
     serveStdio(buildServer, {
         legacy: 'serve',
         onerror: (error) => log.error('server.protocol_error', { error: error.message }),

package/dist/version.js

@@ -4,4 +4,4 @@
  * virtual filesystem). MUST stay equal to the "version" field in
  * package.json — the test in version.test.ts enforces that.
  */
-export const YOMI_VERSION = '0.6.2';
+export const YOMI_VERSION = '0.6.5';

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=22.13.0 <23.0.0 || >=23.4.0"
   },
-  "version": "0.6.2",
+  "version": "0.6.5",
   "description": "Open-source personal LINE MCP server for AI agents. Read, reply, send images, and search LINE conversations locally with Letter-Sealing E2EE.",
   "type": "module",
   "license": "MIT",

package/run.mjs

@@ -433,14 +433,111 @@ switch (cmd) {
   case 'serve':
     await load('mcp/server');
     break;
+  case 'daemon': {
+    const subCmd = args[1] && !args[1].startsWith('-') ? args[1] : 'start';
+    const { startDaemonServer, stopDaemon, getRunningDaemon } = await load('mcp/daemon');
+
+    if (subCmd === 'status') {
+      const daemon = await getRunningDaemon();
+      if (!daemon) {
+        console.log(JSON.stringify({ running: false }));
+      } else {
+        console.log(JSON.stringify({ running: true, ...daemon }));
+      }
+      process.exit(0);
+    }
+
+    if (subCmd === 'stop') {
+      const res = await stopDaemon();
+      if (res.stopped) {
+        console.log(JSON.stringify({ stopped: true, pid: res.pid }));
+      } else {
+        console.log(JSON.stringify({ stopped: false, message: 'Daemon is not running' }));
+      }
+      process.exit(0);
+    }
+
+    if (subCmd === 'start' || subCmd === 'run') {
+      const isForeground = args.includes('--foreground') || args.includes('-f');
+      const portIdx = args.indexOf('--port');
+      const port = portIdx >= 0 && args[portIdx + 1] ? parseInt(args[portIdx + 1], 10) : undefined;
+
+      const existing = await getRunningDaemon();
+      if (existing) {
+        console.log(JSON.stringify({ started: false, message: 'Daemon already running', ...existing }));
+        process.exit(0);
+      }
+
+      if (isForeground) {
+        await startDaemonServer({ port });
+        break;
+      }
+
+      const { spawn } = await import('node:child_process');
+      const child = spawn(
+        process.execPath,
+        [process.argv[1], 'daemon', 'start', '--foreground', ...(port ? ['--port', String(port)] : [])],
+        {
+          detached: true,
+          stdio: 'ignore',
+          env: process.env,
+        },
+      );
+      child.unref();
+
+      let running = null;
+      for (let i = 0; i < 100; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        running = await getRunningDaemon();
+        if (running) break;
+      }
+
+      if (running) {
+        console.log(JSON.stringify({ started: true, ...running }));
+        process.exit(0);
+      } else {
+        console.error(JSON.stringify({ started: false, error: 'Daemon failed to initialize in background' }));
+        process.exit(1);
+      }
+    }
+
+    if (subCmd === 'restart') {
+      await stopDaemon();
+      await new Promise((r) => setTimeout(r, 500));
+      const { spawn } = await import('node:child_process');
+      const child = spawn(process.execPath, [process.argv[1], 'daemon', 'start', '--foreground'], {
+        detached: true,
+        stdio: 'ignore',
+        env: process.env,
+      });
+      child.unref();
+      let running = null;
+      for (let i = 0; i < 100; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        running = await getRunningDaemon();
+        if (running) break;
+      }
+      if (running) {
+        console.log(JSON.stringify({ restarted: true, ...running }));
+        process.exit(0);
+      } else {
+        console.error(JSON.stringify({ restarted: false, error: 'Daemon failed to restart' }));
+        process.exit(1);
+      }
+    }
+
+    console.error(`Unknown daemon command: ${subCmd}\nUsage: yomi daemon [start|stop|status|restart] [--foreground] [--port <number>]`);
+    process.exit(1);
+  }
   case 'help':
   case '--help':
   case '-h':
     console.log(`Yomi (読み) — read, reply, send images to, and search your LINE from any AI agent.
 
 Usage:
-  yomi                Start the MCP stdio server (default)
+  yomi                Start the MCP stdio server (default, proxies to daemon if running)
   yomi serve          Same as above, explicit
+  yomi daemon [...]   Manage background persistent MCP daemon (start|stop|status|restart)
   yomi login [...]    Run the passwordless login flow in a terminal
   yomi unsend <id>    Retract (unsend) a message sent within the last hour
   yomi help           Show this help
@@ -448,6 +545,9 @@ Usage:
 
 Examples:
   npx @rikaidev/yomi                  # start MCP server
+  npx @rikaidev/yomi daemon start     # start persistent shared daemon
+  npx @rikaidev/yomi daemon status    # check daemon status
+  npx @rikaidev/yomi daemon stop      # stop background daemon
   npx @rikaidev/yomi login            # interactive login
   npx @rikaidev/yomi login --phone +886912345678 --region TW`);
     break;