evolclaw-web 1.1.0 → 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';
@@ -23,16 +24,17 @@ 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 = { agents: aidSource, msg: msgSource, session: sessionSource, cache: cacheSource, system: systemSource, triggers: triggersSource };
+const SOURCES = { agents: aidSource, msg: msgSource, session: sessionSource, cache: cacheSource, system: systemSource, triggers: triggersSource, monitor: monitorSource };
 // ECWeb 自身版本：渲染 System 页时随快照下发（不走 daemon IPC，ECWeb 就是这个进程）。
 function readEcwebVersion() {
     try {
@@ -52,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 {
@@ -267,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 ──
@@ -372,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);
     });
@@ -453,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,6 +107,7 @@ async function buildSnapshot() {
         stats: statsResp?.stats ?? [],
         status: statusResp ?? null,
         agents: agentsResp?.agents ?? [],
+        version: version ?? null,
     };
 }
 export const aidSource = {

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); };
+    },
+};

package/dist/sources/session.js

@@ -25,7 +25,16 @@ function dlog(line) { if (_dlog)
 const CACHE_VERSION = 2;
 const _metaCache = new Map();
 function cacheDir(encoded) {
-    return path.join(resolvePaths().dataDir, 'watch-web-cache', encoded);
+    const dataDir = resolvePaths().dataDir;
+    const currentRoot = path.join(dataDir, 'ecweb-cache');
+    const legacyRoot = path.join(dataDir, 'watch-web-cache');
+    if (!fs.existsSync(currentRoot) && fs.existsSync(legacyRoot)) {
+        try {
+            fs.renameSync(legacyRoot, currentRoot);
+        }
+        catch { }
+    }
+    return path.join(currentRoot, encoded);
 }
 function readDiskCache(encoded, id, mtime, size) {
     try {

package/dist/sources/system.js

@@ -5,7 +5,7 @@
  * 另注入 ecwebVersion（ECWeb 进程自身 package.json 版本，由 server.ts 合并，不走 daemon IPC）。
  * check / upgrade 结果不在快照里——由前端按钮触发 menu.action 后写入 state。
  *
- * subscribe: 3s 轮询 + JSON diff，仅变化时 push。
+ * subscribe: 30s 轮询 + JSON diff，仅变化时 push。
  */
 import { resolvePaths } from '../paths.js';
 import { ipcQuery } from '../ipc-client.js';
@@ -45,7 +45,7 @@ export const systemSource = {
             }
             catch { /* ignore transient IPC errors */ }
         };
-        const timer = setInterval(tick, 3000);
+        const timer = setInterval(tick, 30000);
         return () => { stopped = true; clearInterval(timer); };
     },
 };