evolclaw-web 1.0.1 → 1.2.0

package/dist/index.js

@@ -67,14 +67,14 @@ const fileLog = (line) => {
 };
 const log = (line) => { logLine(line); fileLog(line); };
 // 单实例保护：
-// 1) 按 instance 文件杀掉登记在册的旧 watch-web 进程
-const { writeWatchWeb, removeWatchWeb, cleanupWatchWebs, cleanupWatchWebByPort } = await import('./process-utils.js');
-const killedWebs = cleanupWatchWebs();
+// 1) 按 instance 文件杀掉登记在册的旧 ecweb 进程
+const { writeEcweb, removeEcweb, cleanupEcwebs, cleanupEcwebByPort } = await import('./process-utils.js');
+const killedWebs = cleanupEcwebs();
 for (const r of killedWebs)
-    logLine(`${YELLOW}↺ 已清理旧 watch 进程 PID ${r.pid}（端口 ${r.port}）${RST}`);
+    logLine(`${YELLOW}↺ 已清理旧 ecweb 进程 PID ${r.pid}（端口 ${r.port}）${RST}`);
 // 2) 兜底：按端口杀掉 instance 文件已丢失的孤儿进程（杀不掉的僵尸）
 const WATCH_WEB_PORT = port ?? 42705;
-const killedByPort = cleanupWatchWebByPort(WATCH_WEB_PORT);
+const killedByPort = cleanupEcwebByPort(WATCH_WEB_PORT);
 for (const pid of killedByPort)
     logLine(`${YELLOW}↺ 已强占端口 ${WATCH_WEB_PORT}：杀掉占用进程 PID ${pid}${RST}`);
 if (killedWebs.length > 0 || killedByPort.length > 0) {
@@ -90,7 +90,7 @@ catch (e) {
     process.exit(1);
 }
 // 注册 instance 文件
-writeWatchWeb(handle.port);
+writeEcweb(handle.port);
 // 列出访问地址
 const ifaces = os.networkInterfaces();
 const lanIps = [];
@@ -101,7 +101,7 @@ for (const list of Object.values(ifaces)) {
     }
 }
 process.stdout.write(`\n${BOLD}${CYAN}🔭 EvolClaw Watch${RST}  ${DIM}(home: ${p.root})${RST}\n\n`);
-process.stdout.write(`  ${BOLD}配对码:${RST}  ${GREEN}${BOLD}${handle.pairingCode}${RST}  ${DIM}(5 分钟内有效，配对后 token 缓存 24h 自动续期)${RST}\n\n`);
+process.stdout.write(`  ${BOLD}配对码:${RST}  ${GREEN}${BOLD}${handle.pairingCode}${RST}  ${DIM}(5 分钟内有效，配对后 token 缓存 30 天，有访问自动续期)${RST}\n\n`);
 process.stdout.write(`  ${BOLD}本机:${RST}    http://localhost:${handle.port}\n`);
 for (const ip of lanIps)
     process.stdout.write(`  ${BOLD}局域网:${RST}  http://${ip}:${handle.port}\n`);
@@ -116,13 +116,13 @@ const cleanup = () => {
         return; // 幂等：raw 模式下连按 Ctrl-C/q 不应重复触发
     cleaningUp = true;
     logLine(`${YELLOW}退出中…${RST}`);
-    removeWatchWeb();
+    removeEcweb();
     // 兜底：close() 万一卡住也强制退出，避免进程挂死
     const force = setTimeout(() => process.exit(0), 2000);
     force.unref();
     handle.close().finally(() => process.exit(0));
 };
-process.on('exit', () => removeWatchWeb());
+process.on('exit', () => removeEcweb());
 process.on('SIGINT', cleanup);
 process.on('SIGTERM', cleanup);
 if (process.stdin.isTTY) {

package/dist/process-utils.js

@@ -151,25 +151,32 @@ function readCmdline(pid) {
 function instanceDir() {
     return resolvePaths().instanceDir;
 }
-function watchWebFile(pid) {
-    return path.join(instanceDir(), `watch-web-${pid}.json`);
+function isEcwebInstanceFile(file) {
+    return /^(ecweb|watch-web)-\d+\.json$/.test(file);
 }
-export function writeWatchWeb(port) {
+function ecwebFile(pid) {
+    return path.join(instanceDir(), `ecweb-${pid}.json`);
+}
+export function writeEcweb(port) {
     const dir = instanceDir();
     fs.mkdirSync(dir, { recursive: true });
     const startedAt = getProcessStartTime(process.pid) ?? Date.now();
     const record = { pid: process.pid, startedAt, startedAtIso: new Date(startedAt).toISOString(), port };
-    const filePath = watchWebFile(process.pid);
+    const filePath = ecwebFile(process.pid);
     const tmp = filePath + '.tmp';
     fs.writeFileSync(tmp, JSON.stringify(record, null, 2));
     fs.renameSync(tmp, filePath);
     return filePath;
 }
-export function removeWatchWeb(pid) {
-    try {
-        fs.unlinkSync(watchWebFile(pid ?? process.pid));
+export function removeEcweb(pid) {
+    const target = pid ?? process.pid;
+    const dir = instanceDir();
+    for (const prefix of ['ecweb', 'watch-web']) {
+        try {
+            fs.unlinkSync(path.join(dir, `${prefix}-${target}.json`));
+        }
+        catch { }
     }
-    catch { }
 }
 function safeParseJson(filePath) {
     try {
@@ -180,10 +187,11 @@ function safeParseJson(filePath) {
     }
 }
 /**
- * 杀掉所有非自己 PID 的存活 watch-web 进程并清理文件。
+ * 杀掉所有非自己 PID 的存活 ecweb 进程并清理文件。
+ * 兼容清理迁移前遗留的 watch-web-*.json。
  * 用启动时间比对防 PID 复用。返回被杀的记录列表。
  */
-export function cleanupWatchWebs() {
+export function cleanupEcwebs() {
     const dir = instanceDir();
     if (!fs.existsSync(dir))
         return [];
@@ -196,7 +204,7 @@ export function cleanupWatchWebs() {
     }
     const killed = [];
     for (const file of files) {
-        if (!file.startsWith('watch-web-') || !file.endsWith('.json'))
+        if (!isEcwebInstanceFile(file))
             continue;
         const filePath = path.join(dir, file);
         const record = safeParseJson(filePath);
@@ -217,7 +225,7 @@ export function cleanupWatchWebs() {
  * 兜底：按端口找占用进程，确认是 ecweb 进程后 SIGKILL。
  * 用于清理 instance 文件已丢失的孤儿进程（杀不掉的僵尸）。返回被杀的 PID 列表。
  */
-export function cleanupWatchWebByPort(port) {
+export function cleanupEcwebByPort(port) {
     const killed = [];
     for (const pid of findPidByPort(port)) {
         if (pid === process.pid || !isProcessRunning(pid))

package/dist/server.js

@@ -3,7 +3,7 @@
  *
  * - HTTP: 静态资源 + 配对 API
  * - WebSocket: 订阅式实时推送（aid / msg / session）
- * - 鉴权: 6 位配对码（5 分钟有效）→ token（24h，有访问自动续期），持久化到磁盘
+ * - 鉴权: 6 位配对码（5 分钟有效）→ token（30 天，有访问自动续期），持久化到磁盘
  * - 安全: 绑定 0.0.0.0（支持远程访问），token 校验，只读
  *
  * 与 evolclaw 的唯一通信：启动时发 ping 检查 protocolVersion（soft 校验）。
@@ -12,6 +12,7 @@ import http from 'http';
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
+import { spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 import { resolvePaths } from './paths.js';
@@ -20,13 +21,31 @@ import { setDebugLog, dlog } from './debug-log.js';
 import { aidSource } from './sources/aid.js';
 import { msgSource } from './sources/msg.js';
 import { sessionSource } from './sources/session.js';
+import { cacheSource } from './sources/cache.js';
+import { systemSource } from './sources/system.js';
+import { triggersSource } from './sources/triggers.js';
+import { monitorSource } from './sources/monitor.js';
+import { queryStatsForDashboard, queryStatsExplorer, queryStatsByPeer, queryStatsByAgent, queryStatsOverview } from './sources/stats.js';
+import { getSessionsAunDir, listLocalAids, listPeers, readMessages } from './fs-utils.js';
+import { ccProjectsDir } from './paths.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const STATIC_DIR = path.join(__dirname, 'static');
-const TOKEN_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+const TOKEN_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30天（滑动窗口：每次有效访问刷新 lastActive 自动续期）
 const PAIRING_TTL_MS = 5 * 60 * 1000; // 5min
 const DEFAULT_PORT = 42705;
 const PROTOCOL_VERSION = 1; // 与 evolclaw ping response 对齐的软校验版本
-const SOURCES = { aid: aidSource, msg: msgSource, session: sessionSource };
+const SOURCES = { agents: aidSource, msg: msgSource, session: sessionSource, cache: cacheSource, system: systemSource, triggers: triggersSource, monitor: monitorSource };
+// ECWeb 自身版本：渲染 System 页时随快照下发（不走 daemon IPC，ECWeb 就是这个进程）。
+function readEcwebVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
+        return pkg?.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const ECWEB_VERSION = readEcwebVersion();
 const MIME = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'text/javascript; charset=utf-8',
@@ -35,7 +54,16 @@ const MIME = {
     '.svg': 'image/svg+xml',
 };
 function tokenStorePath() {
-    return path.join(resolvePaths().instanceDir, 'watch-web-tokens.json');
+    const dir = resolvePaths().instanceDir;
+    const current = path.join(dir, 'ecweb-tokens.json');
+    const legacy = path.join(dir, 'watch-web-tokens.json');
+    if (!fs.existsSync(current) && fs.existsSync(legacy)) {
+        try {
+            fs.renameSync(legacy, current);
+        }
+        catch { }
+    }
+    return current;
 }
 function loadTokens() {
     try {
@@ -108,12 +136,116 @@ function parseUrl(rawUrl) {
     }
     return { path: rawUrl.slice(0, qIdx), query };
 }
+function handleStatsApi(req, res) {
+    const { path: urlPath, query } = parseUrl(req.url || '');
+    res.setHeader('Content-Type', 'application/json');
+    if (urlPath === '/api/stats/dashboard') {
+        const data = queryStatsForDashboard();
+        if (!data) {
+            res.writeHead(503);
+            res.end(JSON.stringify({ error: 'stats unavailable (node:sqlite missing or no data)' }));
+        }
+        else {
+            res.writeHead(200);
+            res.end(JSON.stringify(data));
+        }
+    }
+    else if (urlPath === '/api/stats/explorer') {
+        const params = {};
+        if (query.from)
+            params.from_ts = Number(query.from);
+        if (query.to)
+            params.to_ts = Number(query.to);
+        if (query.agent)
+            params.agent_aid = query.agent;
+        if (query.peer)
+            params.peer_key = query.peer;
+        if (query.model)
+            params.model = query.model;
+        if (query.granularity)
+            params.granularity = query.granularity;
+        const data = queryStatsExplorer(params);
+        res.writeHead(200);
+        res.end(JSON.stringify(data));
+    }
+    else if (urlPath === '/api/stats/peers') {
+        const params = {};
+        if (query.from)
+            params.from_ts = Number(query.from);
+        if (query.to)
+            params.to_ts = Number(query.to);
+        if (query.agent)
+            params.agent_aid = query.agent;
+        if (query.limit)
+            params.limit = Number(query.limit);
+        const data = queryStatsByPeer(params);
+        res.writeHead(200);
+        res.end(JSON.stringify(data));
+    }
+    else if (urlPath === '/api/stats/agents') {
+        const params = {};
+        if (query.from)
+            params.from_ts = Number(query.from);
+        if (query.to)
+            params.to_ts = Number(query.to);
+        if (query.limit)
+            params.limit = Number(query.limit);
+        const data = queryStatsByAgent(params);
+        res.writeHead(200);
+        res.end(JSON.stringify(data));
+    }
+    else if (urlPath === '/api/stats/overview') {
+        const tokenStats = queryStatsOverview();
+        // session count: scan all CC project dirs
+        let sessionCount = 0;
+        try {
+            const base = ccProjectsDir();
+            for (const d of fs.readdirSync(base, { withFileTypes: true })) {
+                if (!d.isDirectory())
+                    continue;
+                try {
+                    sessionCount += fs.readdirSync(path.join(base, d.name)).filter(f => f.endsWith('.jsonl')).length;
+                }
+                catch { }
+            }
+        }
+        catch { }
+        // message counts: scan aun dir
+        let msgIn = 0, msgOut = 0;
+        try {
+            const aunDir = getSessionsAunDir();
+            for (const aid of listLocalAids(aunDir)) {
+                for (const peer of listPeers(aunDir, aid)) {
+                    for (const m of readMessages(aunDir, aid, peer)) {
+                        if (m.dir === 'in')
+                            msgIn++;
+                        else
+                            msgOut++;
+                    }
+                }
+            }
+        }
+        catch { }
+        res.writeHead(200);
+        res.end(JSON.stringify({ token_stats: tokenStats, session_count: sessionCount, msg_in: msgIn, msg_out: msgOut }));
+    }
+    else {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: 'not found' }));
+    }
+}
 function clientIp(req) {
     const fwd = req.headers['x-forwarded-for'];
     if (typeof fwd === 'string' && fwd)
         return fwd.split(',')[0].trim();
     return req.socket.remoteAddress || '?';
 }
+// 仅 localhost 可访问（取配对码）：直连 socket 地址必须是回环。
+// 不信任 x-forwarded-for（代理头可伪造），只看真实 TCP 来源。
+function isLocalhost(req) {
+    const addr = req.socket.remoteAddress || '';
+    return addr === '127.0.0.1' || addr === '::1' || addr === '::ffff:127.0.0.1';
+}
 function genPairingCode() {
     return String(crypto.randomInt(0, 1000000)).padStart(6, '0');
 }
@@ -146,7 +278,7 @@ function handlePair(req, res, pairingCode, pairingExpiry, log) {
         store.tokens.push({ token, createdAt: now, lastActive: now, label: ip });
         saveTokens(store);
         res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({ ok: true, token }));
-        log(`✓ 配对成功 from ${ip}（token 缓存 24h）`);
+        log(`✓ 配对成功 from ${ip}（token 缓存 30 天，有访问自动续期）`);
     });
 }
 // ── WebSocket connection ──
@@ -173,15 +305,17 @@ function handleConnection(ws, req, log) {
             send({ type: 'error', message: `unknown view: ${view}` });
             return;
         }
+        // System 视图：把 ECWeb 自身版本合并进快照（前端版本卡用）
+        const decorate = (data) => (view === 'system' && data ? { ...data, ecwebVersion: ECWEB_VERSION } : data);
         try {
-            send({ type: 'snapshot', view, data: await source.snapshot(params) });
+            send({ type: 'snapshot', view, data: decorate(await source.snapshot(params)) });
         }
         catch (e) {
             send({ type: 'error', message: `snapshot failed: ${e?.message || e}` });
         }
         unsubscribe = source.subscribe(params, (data) => {
             if (currentView === view)
-                send({ type: 'delta', view, data });
+                send({ type: 'delta', view, data: decorate(data) });
         });
     };
     ws.on('message', async (raw) => {
@@ -206,8 +340,25 @@ function handleConnection(ws, req, log) {
                 params.sessionId = msg.sessionId;
             if (msg.project)
                 params.project = msg.project;
+            if (msg.agent)
+                params.agent = msg.agent;
             dlog(`▸ 订阅 ${msg.view}${msg.aid ? ` aid=${String(msg.aid).split('.')[0]}` : ''}${msg.peer ? ` peer=${String(msg.peer).split('.')[0]}` : ''}${msg.sessionId ? ` session=${String(msg.sessionId).slice(0, 8)}` : ''} from ${ip}`);
             await switchSubscription(msg.view, params);
+            return;
+        }
+        if (msg.type === 'menu' && msg.payload) {
+            const p = resolvePaths();
+            const resp = await ipcQuery(p.socket, { type: 'menu.exec', payload: msg.payload }, 5000);
+            if (resp?.ok) {
+                send({ type: 'menu.response', requestId: msg.requestId, data: resp.response });
+            }
+            else {
+                send({ type: 'menu.response', requestId: msg.requestId, data: {
+                        type: 'menu.response', id: msg.payload?.id ?? '',
+                        error: { code: 'INTERNAL', message: resp?.error ?? 'daemon unreachable' },
+                    } });
+            }
+            return;
         }
     });
     // NAT keepalive: ping every 25s to prevent middlebox from cutting the connection
@@ -232,19 +383,69 @@ function handleConnection(ws, req, log) {
     ws.on('error', () => { });
 }
 // ── Port binding ──
-function bindPort(server, preferred) {
+/** 跨平台：查端口上的 LISTENING 进程 PID（清理被占端口用）。 */
+function findPidsOnPort(port) {
+    const pids = new Set();
+    try {
+        if (process.platform === 'win32') {
+            const out = spawnSync('netstat', ['-ano', '-p', 'TCP'], { encoding: 'utf-8', windowsHide: true }).stdout || '';
+            for (const line of out.split('\n')) {
+                if (!/LISTENING/i.test(line))
+                    continue;
+                const m = line.match(/:(\d+)\s+\S+\s+LISTENING\s+(\d+)/i);
+                if (m && Number(m[1]) === port) {
+                    const pid = Number(m[2]);
+                    if (pid && pid !== process.pid)
+                        pids.add(pid);
+                }
+            }
+        }
+        else {
+            const out = spawnSync('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], { encoding: 'utf-8' }).stdout || '';
+            for (const l of out.split('\n')) {
+                const pid = parseInt(l.trim(), 10);
+                if (pid && pid !== process.pid)
+                    pids.add(pid);
+            }
+        }
+    }
+    catch { /* netstat/lsof 缺失或无匹配 */ }
+    return [...pids];
+}
+/** 杀掉占用目标端口的旧进程（强制）。 */
+function killPidsOnPort(port, log) {
+    let killed = false;
+    for (const pid of findPidsOnPort(port)) {
+        try {
+            if (process.platform === 'win32')
+                spawnSync('taskkill', ['/PID', String(pid), '/F'], { windowsHide: true });
+            else
+                process.kill(pid, 'SIGKILL');
+            log(`⚠ 端口 ${port} 被旧进程 PID ${pid} 占用，已终止`);
+            killed = true;
+        }
+        catch { /* 已退出或无权限 */ }
+    }
+    return killed;
+}
+function sleepMs(ms) { return new Promise(r => setTimeout(r, ms)); }
+function bindPort(server, preferred, log) {
     return new Promise((resolve, reject) => {
-        let attempt = 0;
+        let killedOnce = false;
         const tryBind = (port) => {
-            server.once('error', (err) => {
-                if (err.code === 'EADDRINUSE' && attempt < 10) {
-                    attempt++;
-                    tryBind(port + 1);
+            server.once('error', async (err) => {
+                if (err.code === 'EADDRINUSE' && !killedOnce) {
+                    // 默认行为：杀掉占用端口的旧进程并重试本端口（而非 +1 漂移），避免端口被占。
+                    killedOnce = true;
+                    killPidsOnPort(port, log);
+                    await sleepMs(600);
+                    tryBind(port);
                 }
-                else
+                else {
                     reject(err);
+                }
             });
-            server.listen(port, '0.0.0.0', () => resolve({ port, displaced: port !== preferred }));
+            server.listen(port, '0.0.0.0', () => resolve({ port, displaced: false }));
         };
         tryBind(preferred);
     });
@@ -270,6 +471,12 @@ export async function startWatchWebServer(opts = {}) {
     }
     const server = http.createServer((req, res) => {
         if (req.method === 'GET' && (req.url || '') === '/api/pair-code') {
+            // 仅 localhost 可取码：远程浏览器拿不到，必须由同机的 `ec watch web` 显示给用户
+            if (!isLocalhost(req)) {
+                res.writeHead(403, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'forbidden' }));
+                return;
+            }
             const { code, expiresAt } = freshPairing();
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ code, expiresAt }));
@@ -277,6 +484,19 @@ export async function startWatchWebServer(opts = {}) {
         else if (req.method === 'POST' && (req.url || '').startsWith('/api/pair')) {
             handlePair(req, res, pairingCode, pairingExpiry, log);
         }
+        else if (req.method === 'GET' && (req.url || '').startsWith('/api/stats/')) {
+            // Stats API — requires auth
+            const authHeader = req.headers.authorization || '';
+            const bearerToken = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+            const { query } = parseUrl(req.url || '');
+            const token = bearerToken || query.token || '';
+            if (!validateAndRenew(token, Date.now())) {
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'unauthorized' }));
+                return;
+            }
+            handleStatsApi(req, res);
+        }
         else {
             serveStatic(req, res);
         }
@@ -294,7 +514,7 @@ export async function startWatchWebServer(opts = {}) {
             handleConnection(ws, req, log);
         });
     });
-    const { port, displaced } = await bindPort(server, opts.port ?? DEFAULT_PORT);
+    const { port, displaced } = await bindPort(server, opts.port ?? DEFAULT_PORT, log);
     return {
         url: `http://0.0.0.0:${port}`,
         port,

package/dist/sources/aid.js

@@ -64,13 +64,31 @@ function scanAidActivity() {
     }
     return result;
 }
+// evolclaw 版本：与 watch aid 状态栏一致。daemon 进程级、整轮 watch 不变，
+// 故缓存一次（首次 menu.query name=system 拿到后复用），避免每秒多发一次 IPC。
+let _cachedVersion = null;
+async function fetchVersion(socket) {
+    if (_cachedVersion)
+        return _cachedVersion;
+    try {
+        const r = await ipcQuery(socket, { type: 'menu.exec', payload: { type: 'menu.query', id: 'aid-sys-q', name: 'system' } }, 4000);
+        const v = r?.ok ? r.response?.data?.version : null;
+        if (v)
+            _cachedVersion = v;
+        return v ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 async function buildSnapshot() {
     const p = resolvePaths();
-    const [aidsResp, statsResp, statusResp, agentsResp] = await Promise.all([
+    const [aidsResp, statsResp, statusResp, agentsResp, version] = await Promise.all([
         ipcQuery(p.socket, { type: 'aun-aids' }),
         ipcQuery(p.socket, { type: 'aun-aid-stats' }),
         ipcQuery(p.socket, { type: 'status' }),
         ipcQuery(p.socket, { type: 'evolagent.list' }),
+        fetchVersion(p.socket),
     ]);
     const daemonRunning = aidsResp !== null || statusResp !== null;
     if (!daemonRunning) {
@@ -89,10 +107,11 @@ async function buildSnapshot() {
         stats: statsResp?.stats ?? [],
         status: statusResp ?? null,
         agents: agentsResp?.agents ?? [],
+        version: version ?? null,
     };
 }
 export const aidSource = {
-    kind: 'aid',
+    kind: 'agents',
     async snapshot() {
         return buildSnapshot();
     },

package/dist/sources/cache.js

@@ -0,0 +1,43 @@
+/**
+ * Cache 数据源 — daemon 统一 FileCache 的运行统计（命中率/读盘/驱逐/失效）。
+ *
+ * 复用 daemon 的 IPC socket：拉 `cache-stats`（只读）。IPC 无推送，
+ * 故 1s 轮询 + JSON diff，仅在变化时 push（与 aidSource 同款）。
+ * daemon 未运行（ipcQuery 返回 null）→ { daemonRunning:false, stats:null }。
+ */
+import { resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc-client.js';
+async function buildSnapshot() {
+    const p = resolvePaths();
+    const resp = await ipcQuery(p.socket, { type: 'cache-stats' });
+    if (resp === null || !resp.ok) {
+        // daemon 离线，或旧 daemon 不认识 cache-stats（回 {error:...}，ok 为 undefined）
+        return { daemonRunning: resp !== null, supported: !!resp?.ok, stats: null };
+    }
+    return { daemonRunning: true, supported: true, stats: resp.stats };
+}
+export const cacheSource = {
+    kind: 'cache',
+    async snapshot() {
+        return buildSnapshot();
+    },
+    subscribe(_params, push) {
+        let lastJson = '';
+        let stopped = false;
+        const tick = async () => {
+            if (stopped)
+                return;
+            try {
+                const snap = await buildSnapshot();
+                const json = JSON.stringify(snap);
+                if (json !== lastJson) {
+                    lastJson = json;
+                    push(snap);
+                }
+            }
+            catch { /* ignore transient IPC errors */ }
+        };
+        const timer = setInterval(tick, 1000);
+        return () => { stopped = true; clearInterval(timer); };
+    },
+};

package/dist/sources/monitor.js

@@ -0,0 +1,96 @@
+/**
+ * Monitor 数据源 — 复用 daemon 的 IPC socket（`monitor-snapshot` 命令）。
+ *
+ * 拉进程级 + 系统级运行指标（CPU/内存/uptime/loadAvg）+ 全局 stats（含最近错误）
+ * + per-agent 汇总。IPC 无推送能力，故 2s 轮询 + JSON diff，仅在变化时 push。
+ *
+ * 时序数据在源侧维护「三档分辨率」滚动缓冲区，随快照一并下发，前端按所选周期切换：
+ *   - fine   : 2s  桶 × 60  ≈ 近 2 分钟
+ *   - mid    : 10s 桶 × 60  ≈ 近 10 分钟
+ *   - coarse : 60s 桶 × 60  ≈ 近 1 小时
+ * 每个桶内对 CPU/内存做均值聚合，避免长周期下点数爆炸。
+ */
+import { resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc-client.js';
+// 模块级缓冲区——所有订阅者共享同一份累积时序（单一事实源）。
+const resolutions = {
+    fine: { bucketMs: 2_000, cap: 60, buf: [] },
+    mid: { bucketMs: 10_000, cap: 60, buf: [] },
+    coarse: { bucketMs: 60_000, cap: 60, buf: [] },
+};
+/** 把一个原始样本并入指定分辨率的桶（同桶内做增量均值，跨桶则新建）。 */
+function ingest(res, sample) {
+    const bucketTs = Math.floor(sample.ts / res.bucketMs) * res.bucketMs;
+    const last = res.buf[res.buf.length - 1];
+    if (last && last.ts === bucketTs) {
+        const n = last._n + 1;
+        last.procCpu = last.procCpu + (sample.procCpu - last.procCpu) / n;
+        last.sysCpu = last.sysCpu + (sample.sysCpu - last.sysCpu) / n;
+        last.procRss = last.procRss + (sample.procRss - last.procRss) / n;
+        last.sysMemUsed = last.sysMemUsed + (sample.sysMemUsed - last.sysMemUsed) / n;
+        last._n = n;
+    }
+    else {
+        res.buf.push({ ts: bucketTs, procCpu: sample.procCpu, sysCpu: sample.sysCpu, procRss: sample.procRss, sysMemUsed: sample.sysMemUsed, _n: 1 });
+        if (res.buf.length > res.cap)
+            res.buf.shift();
+    }
+}
+/** 导出某分辨率的纯数据点（剥掉内部 _n 字段）。 */
+function exportBuf(res) {
+    return res.buf.map((b) => ({ ts: b.ts, procCpu: round1(b.procCpu), sysCpu: round1(b.sysCpu), procRss: Math.round(b.procRss), sysMemUsed: Math.round(b.sysMemUsed) }));
+}
+function round1(n) { return Math.round(n * 10) / 10; }
+async function fetchSnapshot() {
+    const p = resolvePaths();
+    const resp = await ipcQuery(p.socket, { type: 'monitor-snapshot' }, 3000);
+    // resp === null → daemon 离线或 socket 不可达；resp.ok === false → 命令不受支持（旧 daemon）
+    if (!resp?.ok) {
+        return { daemonRunning: resp !== null, snapshot: null, history: { fine: [], mid: [], coarse: [] } };
+    }
+    const s = resp.snapshot;
+    const sample = {
+        ts: s.ts,
+        procCpu: s.cpuPercent ?? 0,
+        sysCpu: s.system?.cpuPercent ?? 0,
+        procRss: s.memory?.rss ?? 0,
+        sysMemUsed: s.system?.memUsed ?? 0,
+    };
+    ingest(resolutions.fine, sample);
+    ingest(resolutions.mid, sample);
+    ingest(resolutions.coarse, sample);
+    return {
+        daemonRunning: true,
+        snapshot: s,
+        history: {
+            fine: exportBuf(resolutions.fine),
+            mid: exportBuf(resolutions.mid),
+            coarse: exportBuf(resolutions.coarse),
+        },
+    };
+}
+export const monitorSource = {
+    kind: 'monitor',
+    async snapshot() {
+        return fetchSnapshot();
+    },
+    subscribe(_params, push) {
+        let lastJson = '';
+        let stopped = false;
+        const tick = async () => {
+            if (stopped)
+                return;
+            try {
+                const snap = await fetchSnapshot();
+                const json = JSON.stringify(snap);
+                if (json !== lastJson) {
+                    lastJson = json;
+                    push(snap);
+                }
+            }
+            catch { /* ignore transient IPC errors */ }
+        };
+        const timer = setInterval(tick, 2000);
+        return () => { stopped = true; clearInterval(timer); };
+    },
+};