b7a8e29d21
- VERSION file as authoritative version source - export.mjs reads VERSION with package.json fallback - bw-ota.ps1 DryRun mode for safe testing - auto-setup.ps1 bumped to v3.2.0 (Phase 8 OTA)
459 lines
15 KiB
JavaScript
459 lines
15 KiB
JavaScript
#!/usr/bin/env node
|
|
// Bookworm Smart Assistant v6.6 — 可视化中控 API 服务器
|
|
// 零 npm 依赖，纯 Node.js 内置模块
|
|
// 启动: node dashboard-server.js
|
|
// 访问: http://localhost:3210
|
|
|
|
const http = require('http');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const { exec } = require('child_process');
|
|
const url = require('url');
|
|
|
|
// ─── 配置 ───────────────────────────────────────────────
|
|
const PORT = parseInt(process.env.DASHBOARD_PORT, 10) || 3210;
|
|
const SCRIPT_CACHE_TTL = 15000;
|
|
const SCRIPT_TIMEOUT = 120000;
|
|
|
|
// ─── 根目录检测 ─────────────────────────────────────────
|
|
function detectClaudeRoot() {
|
|
if (process.env.CLAUDE_HOME) return process.env.CLAUDE_HOME;
|
|
if (process.env.CLAUDE_ROOT) return process.env.CLAUDE_ROOT;
|
|
const selfDir = path.dirname(__filename);
|
|
if (selfDir.includes('.claude')) {
|
|
return selfDir.replace(/[/\\]scripts$/, '');
|
|
}
|
|
const IS_WSL = process.platform === 'linux' && fs.existsSync('/mnt/c');
|
|
if (IS_WSL) {
|
|
try {
|
|
const usersDir = '/mnt/c/Users';
|
|
for (const u of fs.readdirSync(usersDir)) {
|
|
const candidate = path.join(usersDir, u, '.claude');
|
|
if (fs.existsSync(candidate)) return candidate;
|
|
}
|
|
} catch {}
|
|
}
|
|
try { return require('./paths.config.js').PATHS.root; } catch { return (process.env.USERPROFILE || process.env.HOME || '').replace(/\\/g, '/') + '/.claude'; }
|
|
}
|
|
|
|
const ROOT = detectClaudeRoot();
|
|
const SCRIPTS_DIR = path.join(ROOT, 'scripts');
|
|
const DEBUG_DIR = path.join(ROOT, 'debug');
|
|
const PROJECTS_DIR = path.join(ROOT, 'projects');
|
|
|
|
// ─── 工具函数 ───────────────────────────────────────────
|
|
|
|
function readJsonl(filePath) {
|
|
if (!fs.existsSync(filePath)) return [];
|
|
try {
|
|
const content = fs.readFileSync(filePath, 'utf8').trim();
|
|
if (!content) return [];
|
|
const lines = content.split('\n');
|
|
const entries = [];
|
|
for (const line of lines) {
|
|
if (!line.trim()) continue;
|
|
try { entries.push(JSON.parse(line)); } catch {}
|
|
}
|
|
return entries;
|
|
} catch { return []; }
|
|
}
|
|
|
|
function readJsonlByDateRange(prefix, days) {
|
|
const result = [];
|
|
const now = new Date();
|
|
for (let i = 0; i < days; i++) {
|
|
const d = new Date(now);
|
|
d.setDate(d.getDate() - i);
|
|
const dateStr = d.toISOString().slice(0, 10);
|
|
const filePath = path.join(DEBUG_DIR, `${prefix}${dateStr}.jsonl`);
|
|
result.push(...readJsonl(filePath));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const _cache = {};
|
|
function cachedRunScript(key, script, args = '', ttlMs = SCRIPT_CACHE_TTL) {
|
|
return new Promise((resolve) => {
|
|
const now = Date.now();
|
|
if (_cache[key] && (now - _cache[key].ts) < ttlMs) {
|
|
return resolve(_cache[key].data);
|
|
}
|
|
if (_cache[key] && _cache[key].pending) {
|
|
return _cache[key].pending.then(resolve);
|
|
}
|
|
const cmd = `node "${path.join(SCRIPTS_DIR, script)}" ${args}`;
|
|
const pending = new Promise((res) => {
|
|
exec(cmd, {
|
|
timeout: SCRIPT_TIMEOUT,
|
|
encoding: 'utf8',
|
|
cwd: SCRIPTS_DIR,
|
|
env: { ...process.env, CLAUDE_HOME: ROOT },
|
|
maxBuffer: 10 * 1024 * 1024,
|
|
}, (err, stdout) => {
|
|
delete (_cache[key] || {}).pending;
|
|
if (err) {
|
|
if (err.killed) {
|
|
return res({ error: 'timeout', message: `脚本 ${script} 超时 (${SCRIPT_TIMEOUT}ms)` });
|
|
}
|
|
if (stdout) { try { return res(JSON.parse(stdout)); } catch {} }
|
|
return res({ error: 'script_error', message: err.message || String(err) });
|
|
}
|
|
try {
|
|
const data = JSON.parse(stdout);
|
|
_cache[key] = { ts: Date.now(), data };
|
|
res(data);
|
|
} catch {
|
|
res({ error: 'parse_error', message: '脚本输出不是有效 JSON', raw: (stdout || '').slice(0, 200) });
|
|
}
|
|
});
|
|
});
|
|
_cache[key] = { ..._cache[key], pending };
|
|
pending.then(resolve);
|
|
});
|
|
}
|
|
|
|
function respondJson(res, code, data) {
|
|
const body = JSON.stringify(data);
|
|
res.writeHead(code, {
|
|
'Content-Type': 'application/json; charset=utf-8',
|
|
'Access-Control-Allow-Origin': '*',
|
|
'Access-Control-Allow-Methods': 'GET, OPTIONS',
|
|
'Access-Control-Allow-Headers': 'Content-Type',
|
|
'Cache-Control': 'no-cache',
|
|
});
|
|
res.end(body);
|
|
}
|
|
|
|
function respondHtml(res, html) {
|
|
res.writeHead(200, {
|
|
'Content-Type': 'text/html; charset=utf-8',
|
|
'Cache-Control': 'no-cache',
|
|
});
|
|
res.end(html);
|
|
}
|
|
|
|
function findEvolutionLogs() {
|
|
const entries = [];
|
|
if (!fs.existsSync(PROJECTS_DIR)) return entries;
|
|
try {
|
|
for (const proj of fs.readdirSync(PROJECTS_DIR)) {
|
|
const evoPath = path.join(PROJECTS_DIR, proj, 'memory', 'evolution-log.jsonl');
|
|
entries.push(...readJsonl(evoPath));
|
|
}
|
|
} catch {}
|
|
entries.sort((a, b) => (a.seq || 0) - (b.seq || 0));
|
|
return entries;
|
|
}
|
|
|
|
function readJsonFile(filePath) {
|
|
if (!fs.existsSync(filePath)) return null;
|
|
try {
|
|
return JSON.parse(fs.readFileSync(filePath, 'utf8'));
|
|
} catch { return null; }
|
|
}
|
|
|
|
function today() {
|
|
return new Date().toISOString().slice(0, 10);
|
|
}
|
|
|
|
function getLastModified(prefix) {
|
|
const dateStr = today();
|
|
const filePath = path.join(DEBUG_DIR, `${prefix}${dateStr}.jsonl`);
|
|
try {
|
|
const stat = fs.statSync(filePath);
|
|
return stat.mtime.toISOString();
|
|
} catch { return null; }
|
|
}
|
|
|
|
/** 读取 stats-compiled.json 摘要 — v6.6 新增 */
|
|
function getSystemStats() {
|
|
const data = readJsonFile(path.join(ROOT, 'stats-compiled.json'));
|
|
if (!data || !data.summary) return null;
|
|
return {
|
|
version: data.version || 'unknown',
|
|
skills: data.summary.skills || 0,
|
|
agents: data.summary.agents || 0,
|
|
hooks: data.summary.hooksRegistered || 0,
|
|
hooksTotal: data.summary.hooks || 0,
|
|
mcp: data.summary.mcpTotal || 0,
|
|
generated: data.generated || null,
|
|
};
|
|
}
|
|
|
|
// ─── API 路由 ───────────────────────────────────────────
|
|
|
|
const routes = {};
|
|
|
|
routes['/'] = (req, res) => {
|
|
const htmlPath = path.join(SCRIPTS_DIR, 'dashboard.html');
|
|
if (!fs.existsSync(htmlPath)) {
|
|
res.writeHead(404, { 'Content-Type': 'text/plain' });
|
|
res.end('dashboard.html not found');
|
|
return;
|
|
}
|
|
const html = fs.readFileSync(htmlPath, 'utf8');
|
|
respondHtml(res, html);
|
|
};
|
|
|
|
routes['/api/health'] = async (req, res) => {
|
|
const data = await cachedRunScript('health', 'health-check.js', '--json');
|
|
respondJson(res, 200, data);
|
|
};
|
|
|
|
routes['/api/disk'] = async (req, res) => {
|
|
const data = await cachedRunScript('disk', 'auto-cleanup.js', '--report');
|
|
respondJson(res, 200, data);
|
|
};
|
|
|
|
routes['/api/weekly'] = async (req, res) => {
|
|
const data = await cachedRunScript('weekly', 'weekly-report.js', '--json');
|
|
respondJson(res, 200, data);
|
|
};
|
|
|
|
routes['/api/dashboard'] = async (req, res, query) => {
|
|
const range = parseInt(query.range, 10) || 7;
|
|
const data = await cachedRunScript(`dashboard-${range}`, 'dashboard.js', `--json --range ${range}`);
|
|
respondJson(res, 200, data);
|
|
};
|
|
|
|
routes['/api/activity'] = (req, res, query) => {
|
|
const days = Math.min(parseInt(query.days, 10) || 7, 90);
|
|
const entries = readJsonlByDateRange('activity-', days);
|
|
respondJson(res, 200, entries);
|
|
};
|
|
|
|
routes['/api/security'] = (req, res, query) => {
|
|
const days = Math.min(parseInt(query.days, 10) || 7, 90);
|
|
const entries = readJsonlByDateRange('security-', days);
|
|
respondJson(res, 200, entries);
|
|
};
|
|
|
|
routes['/api/compliance'] = (req, res, query) => {
|
|
const days = Math.min(parseInt(query.days, 10) || 7, 90);
|
|
const entries = readJsonlByDateRange('compliance-', days);
|
|
respondJson(res, 200, entries);
|
|
};
|
|
|
|
routes['/api/evolution'] = (req, res) => {
|
|
const entries = findEvolutionLogs();
|
|
respondJson(res, 200, entries);
|
|
};
|
|
|
|
routes['/api/skills'] = (req, res) => {
|
|
const data = readJsonFile(path.join(ROOT, 'skills-index.json'));
|
|
respondJson(res, 200, data || { error: 'skills-index.json not found' });
|
|
};
|
|
|
|
routes['/api/route-feedback'] = (req, res) => {
|
|
const entries = readJsonl(path.join(DEBUG_DIR, 'route-feedback.jsonl'));
|
|
respondJson(res, 200, entries);
|
|
};
|
|
|
|
routes['/api/weights'] = (req, res) => {
|
|
const data = readJsonFile(path.join(DEBUG_DIR, 'route-weights.json'));
|
|
respondJson(res, 200, data || {});
|
|
};
|
|
|
|
// v6.6: /api/status 新增 system 字段，从 stats-compiled.json 读取真实计数
|
|
routes['/api/status'] = (req, res) => {
|
|
const now = new Date().toISOString();
|
|
const activityMtime = getLastModified('activity-');
|
|
const securityMtime = getLastModified('security-');
|
|
const complianceMtime = getLastModified('compliance-');
|
|
let sessionInfo = null;
|
|
try {
|
|
sessionInfo = JSON.parse(fs.readFileSync(path.join(DEBUG_DIR, 'session-active.lock'), 'utf8'));
|
|
} catch {}
|
|
function getFileMtime(filePath) {
|
|
try { return fs.statSync(filePath).mtime.toISOString(); } catch { return null; }
|
|
}
|
|
const detectionMtime = getFileMtime(path.join(DEBUG_DIR, 'detection-stats.json'));
|
|
const skillCorrMtime = getFileMtime(path.join(DEBUG_DIR, 'skill-outcome-correlation.json'));
|
|
const outcomeAggMtime = getFileMtime(path.join(DEBUG_DIR, 'outcome-aggregation.json'));
|
|
const traceMtime = getLastModified('trace-');
|
|
const remediationMtime = getFileMtime(path.join(DEBUG_DIR, 'remediation-log.jsonl'));
|
|
|
|
respondJson(res, 200, {
|
|
serverTime: now,
|
|
uptime: process.uptime(),
|
|
cacheTTL: SCRIPT_CACHE_TTL,
|
|
pollInterval: 30,
|
|
system: getSystemStats(),
|
|
dataSources: {
|
|
activity: { lastModified: activityMtime },
|
|
security: { lastModified: securityMtime },
|
|
compliance: { lastModified: complianceMtime },
|
|
detectionStats: { lastModified: detectionMtime },
|
|
skillCorrelation: { lastModified: skillCorrMtime },
|
|
outcomeAggregation: { lastModified: outcomeAggMtime },
|
|
traces: { lastModified: traceMtime },
|
|
remediations: { lastModified: remediationMtime },
|
|
},
|
|
session: sessionInfo,
|
|
});
|
|
};
|
|
|
|
routes['/api/detection-stats'] = (req, res) => {
|
|
const data = readJsonFile(path.join(DEBUG_DIR, 'detection-stats.json'));
|
|
respondJson(res, 200, data || { error: 'detection-stats.json not found' });
|
|
};
|
|
|
|
routes['/api/skill-correlation'] = (req, res) => {
|
|
const data = readJsonFile(path.join(DEBUG_DIR, 'skill-outcome-correlation.json'));
|
|
respondJson(res, 200, data || { error: 'skill-outcome-correlation.json not found' });
|
|
};
|
|
|
|
routes['/api/outcome-aggregation'] = (req, res) => {
|
|
const data = readJsonFile(path.join(DEBUG_DIR, 'outcome-aggregation.json'));
|
|
respondJson(res, 200, data || { error: 'outcome-aggregation.json not found' });
|
|
};
|
|
|
|
routes['/api/traces'] = (req, res, query) => {
|
|
const days = Math.min(parseInt(query.days, 10) || 7, 90);
|
|
const entries = readJsonlByDateRange('trace-', days);
|
|
respondJson(res, 200, entries);
|
|
};
|
|
|
|
routes['/api/remediations'] = (req, res) => {
|
|
const entries = readJsonl(path.join(DEBUG_DIR, 'remediation-log.jsonl'));
|
|
respondJson(res, 200, entries);
|
|
};
|
|
|
|
routes['/api/config-validate'] = async (req, res) => {
|
|
const data = await cachedRunScript('configValidate', 'config-validator.js', '--json', 60000);
|
|
respondJson(res, 200, data);
|
|
};
|
|
|
|
routes['/api/health-history'] = (req, res) => {
|
|
let data = readJsonFile(path.join(DEBUG_DIR, 'health-weight-history.json'));
|
|
if (Array.isArray(data)) {
|
|
data = data.slice(-30);
|
|
}
|
|
respondJson(res, 200, data || []);
|
|
};
|
|
|
|
// ─── SSE 实时推送 ────────────────────────────────────────
|
|
|
|
const sseClients = new Set();
|
|
let lastMtimes = {};
|
|
|
|
function collectMtimes() {
|
|
const mtimes = {};
|
|
const files = [
|
|
['detection', path.join(DEBUG_DIR, 'detection-stats.json')],
|
|
['skillCorr', path.join(DEBUG_DIR, 'skill-outcome-correlation.json')],
|
|
['outcome', path.join(DEBUG_DIR, 'outcome-aggregation.json')],
|
|
['remediation', path.join(DEBUG_DIR, 'remediation-log.jsonl')],
|
|
['weightHistory', path.join(DEBUG_DIR, 'health-weight-history.json')],
|
|
];
|
|
const dateStr = today();
|
|
const dateFiles = [
|
|
['activity', path.join(DEBUG_DIR, `activity-${dateStr}.jsonl`)],
|
|
['security', path.join(DEBUG_DIR, `security-${dateStr}.jsonl`)],
|
|
['compliance', path.join(DEBUG_DIR, `compliance-${dateStr}.jsonl`)],
|
|
['trace', path.join(DEBUG_DIR, `trace-${dateStr}.jsonl`)],
|
|
];
|
|
for (const [key, fp] of [...files, ...dateFiles]) {
|
|
try { mtimes[key] = fs.statSync(fp).mtimeMs; } catch { mtimes[key] = 0; }
|
|
}
|
|
return mtimes;
|
|
}
|
|
|
|
function checkAndPush() {
|
|
if (sseClients.size === 0) return;
|
|
const current = collectMtimes();
|
|
const changed = [];
|
|
for (const key of Object.keys(current)) {
|
|
if (current[key] !== (lastMtimes[key] || 0)) changed.push(key);
|
|
}
|
|
if (changed.length > 0) {
|
|
lastMtimes = current;
|
|
const msg = `data: ${JSON.stringify({ type: 'data-changed', sources: changed, ts: new Date().toISOString() })}\n\n`;
|
|
for (const client of sseClients) {
|
|
try { client.write(msg); } catch { sseClients.delete(client); }
|
|
}
|
|
}
|
|
}
|
|
|
|
setInterval(checkAndPush, 5000);
|
|
lastMtimes = collectMtimes();
|
|
|
|
routes['/api/events'] = (req, res) => {
|
|
res.writeHead(200, {
|
|
'Content-Type': 'text/event-stream',
|
|
'Cache-Control': 'no-cache',
|
|
'Connection': 'keep-alive',
|
|
'Access-Control-Allow-Origin': '*',
|
|
});
|
|
res.write(`data: ${JSON.stringify({ type: 'connected', ts: new Date().toISOString() })}\n\n`);
|
|
sseClients.add(res);
|
|
req.on('close', () => sseClients.delete(res));
|
|
};
|
|
|
|
// ─── HTTP 服务器 ────────────────────────────────────────
|
|
|
|
const server = http.createServer((req, res) => {
|
|
if (req.method === 'OPTIONS') {
|
|
res.writeHead(204, {
|
|
'Access-Control-Allow-Origin': '*',
|
|
'Access-Control-Allow-Methods': 'GET, OPTIONS',
|
|
'Access-Control-Allow-Headers': 'Content-Type',
|
|
});
|
|
res.end();
|
|
return;
|
|
}
|
|
|
|
if (req.method !== 'GET') {
|
|
respondJson(res, 405, { error: 'Method not allowed' });
|
|
return;
|
|
}
|
|
|
|
const parsed = url.parse(req.url, true);
|
|
const pathname = parsed.pathname;
|
|
const query = parsed.query || {};
|
|
|
|
const handler = routes[pathname];
|
|
if (handler) {
|
|
Promise.resolve(handler(req, res, query)).catch(e => {
|
|
respondJson(res, 500, { error: 'Internal error', message: e.message });
|
|
});
|
|
} else {
|
|
respondJson(res, 404, { error: 'Not found', path: pathname });
|
|
}
|
|
});
|
|
|
|
server.on('error', (e) => {
|
|
if (e.code === 'EADDRINUSE') {
|
|
console.error(`\n端口 ${PORT} 已被占用！`);
|
|
console.error(` 请设置环境变量: DASHBOARD_PORT=3211 node dashboard-server.js\n`);
|
|
process.exit(1);
|
|
}
|
|
throw e;
|
|
});
|
|
|
|
// v6.6: 绑定 127.0.0.1 (仅本机访问)
|
|
if (require.main === module) {
|
|
server.listen(PORT, '127.0.0.1', () => {
|
|
console.log(`\nBookworm 控制中心 v6.6 已启动`);
|
|
console.log(` 地址: http://localhost:${PORT}`);
|
|
console.log(` 根目录: ${ROOT}`);
|
|
console.log(` 缓存 TTL: ${SCRIPT_CACHE_TTL / 1000}s`);
|
|
console.log(` 按 Ctrl+C 停止\n`);
|
|
});
|
|
}
|
|
|
|
if (typeof module !== 'undefined') {
|
|
module.exports = {
|
|
detectClaudeRoot,
|
|
readJsonl,
|
|
readJsonlByDateRange,
|
|
cachedRunScript,
|
|
respondJson,
|
|
findEvolutionLogs,
|
|
readJsonFile,
|
|
getSystemStats,
|
|
routes,
|
|
ROOT,
|
|
};
|
|
}
|