ec-web 0.0.1 → 0.0.3

package/dist/sources/models.js

@@ -0,0 +1,75 @@
+import { resolveParentDistModule, toFileUrl } from './parent-package.js';
+async function getCatalogModule() {
+    const catalogPath = resolveParentDistModule('core', 'model', 'model-catalog.js');
+    const mod = await import(toFileUrl(catalogPath));
+    if (typeof mod.getCatalog !== 'function') {
+        throw new Error('getCatalog not found in model-catalog.js');
+    }
+    return { getCatalog: mod.getCatalog };
+}
+export function inferModelFamily(id) {
+    if (['opus', 'sonnet', 'haiku'].includes(id))
+        return id;
+    const claude = id.match(/^claude-([a-z0-9]+)-/i);
+    if (claude)
+        return claude[1].toLowerCase();
+    const vendor = id.match(/^([a-z0-9]+)[-_]/i);
+    return vendor ? vendor[1].toLowerCase() : 'other';
+}
+export function normalizeModelEntries(models) {
+    const seen = new Set();
+    const out = [];
+    for (const model of models || []) {
+        if (!model || typeof model.id !== 'string')
+            continue;
+        const id = model.id.trim();
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        const isAlias = model.owned_by === 'alias';
+        out.push({
+            id,
+            owned_by: model.owned_by,
+            created: model.created,
+            family: inferModelFamily(id),
+            status: isAlias ? 'alias' : 'available',
+            isAlias
+        });
+    }
+    return out;
+}
+export async function getModelCatalogSnapshot(baseagent = 'claude') {
+    const { getCatalog } = await getCatalogModule();
+    const catalog = await getCatalog(undefined, baseagent);
+    const normalized = normalizeModelEntries(catalog.models || []);
+    return {
+        models: normalized,
+        catalogModels: normalized,
+        source: catalog.source || 'unknown',
+        lastUpdate: new Date().toISOString()
+    };
+}
+function sendJson(res, status, payload) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+export async function handleModelsApi(req, res) {
+    try {
+        const url = new URL(req.url || '', 'http://localhost');
+        if (req.method === 'GET' && url.pathname === '/api/models/catalog') {
+            const baseagent = url.searchParams.get('baseagent') || 'claude';
+            if (!/^[a-z0-9_-]+$/i.test(baseagent)) {
+                sendJson(res, 400, { success: false, error: 'Invalid baseagent' });
+                return;
+            }
+            const data = await getModelCatalogSnapshot(baseagent);
+            sendJson(res, 200, { success: true, data });
+            return;
+        }
+        sendJson(res, 404, { success: false, error: 'Not found' });
+    }
+    catch (err) {
+        console.error('[models] API error:', err);
+        sendJson(res, 500, { success: false, error: err.message });
+    }
+}

package/dist/sources/monitor.js

@@ -0,0 +1,179 @@
+/**
+ * Monitor 数据源 — 复用 daemon 的 IPC socket（`monitor-snapshot` 命令）。
+ *
+ * 拉 daemon 进程树 + 系统级运行指标（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 fs from 'node:fs';
+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.netRxBps = last.netRxBps + (sample.netRxBps - last.netRxBps) / n;
+        last.netTxBps = last.netTxBps + (sample.netTxBps - last.netTxBps) / n;
+        for (const process of sample.processes) {
+            const current = last.processes.find(item => item.pid === process.pid);
+            if (current) {
+                const processSamples = current._n + 1;
+                current.cpuPercent += (process.cpuPercent - current.cpuPercent) / processSamples;
+                current.rss += (process.rss - current.rss) / processSamples;
+                current.name = process.name;
+                current.kind = process.kind;
+                current._n = processSamples;
+            }
+            else {
+                last.processes.push({ ...process, _n: 1 });
+            }
+        }
+        last._n = n;
+    }
+    else {
+        res.buf.push({ ...sample, ts: bucketTs, processes: sample.processes.map(process => ({ ...process, _n: 1 })), _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),
+        netRxBps: Math.round(b.netRxBps),
+        netTxBps: Math.round(b.netTxBps),
+        processes: b.processes.map(process => ({
+            pid: process.pid,
+            name: process.name,
+            kind: process.kind,
+            cpuPercent: round1(process.cpuPercent),
+            rss: Math.round(process.rss),
+        })),
+    }));
+}
+function round1(n) { return Math.round(n * 10) / 10; }
+let previousNetworkSample = null;
+let latestNetworkRate = { rxBps: 0, txBps: 0 };
+function readNetworkTotals() {
+    try {
+        const lines = fs.readFileSync('/proc/net/dev', 'utf8').split('\n').slice(2);
+        let rxBytes = 0;
+        let txBytes = 0;
+        for (const line of lines) {
+            const separator = line.indexOf(':');
+            if (separator < 0)
+                continue;
+            const name = line.slice(0, separator).trim();
+            if (!name || /^(lo|docker\d*|br-|veth|virbr|vmnet|ifb)/.test(name))
+                continue;
+            const fields = line.slice(separator + 1).trim().split(/\s+/);
+            rxBytes += Number(fields[0]) || 0;
+            txBytes += Number(fields[8]) || 0;
+        }
+        return { rxBytes, txBytes };
+    }
+    catch {
+        return { rxBytes: 0, txBytes: 0 };
+    }
+}
+function sampleNetworkRate(ts) {
+    const totals = readNetworkTotals();
+    if (!previousNetworkSample) {
+        previousNetworkSample = { ...totals, ts };
+        return latestNetworkRate;
+    }
+    const elapsedMs = ts - previousNetworkSample.ts;
+    if (elapsedMs < 250)
+        return latestNetworkRate;
+    latestNetworkRate = {
+        rxBps: Math.max(0, (totals.rxBytes - previousNetworkSample.rxBytes) * 1000 / elapsedMs),
+        txBps: Math.max(0, (totals.txBytes - previousNetworkSample.txBytes) * 1000 / elapsedMs),
+    };
+    previousNetworkSample = { ...totals, ts };
+    return latestNetworkRate;
+}
+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 ts = Number(s.ts) || Date.now();
+    const network = sampleNetworkRate(ts);
+    const sample = {
+        ts,
+        procCpu: s.cpuPercent ?? 0,
+        sysCpu: s.system?.cpuPercent ?? 0,
+        procRss: s.memory?.rss ?? 0,
+        sysMemUsed: s.system?.memUsed ?? 0,
+        netRxBps: network.rxBps,
+        netTxBps: network.txBps,
+        processes: Array.isArray(s.processTree?.processes) ? s.processTree.processes.map((process) => ({
+            pid: Number(process.pid),
+            name: String(process.name || 'process'),
+            kind: String(process.kind || 'child'),
+            cpuPercent: Number(process.cpuPercent) || 0,
+            rss: Number(process.rss) || 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); };
+    },
+};