evolcore 0.0.21 → 0.0.23

package/dist/core/command/daemon-diagnostics.js

@@ -0,0 +1,448 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolvePaths } from '../../paths.js';
+import { isValidAid } from '../../aun/aid/validation.js';
+function diagnosticPaths(overrides) {
+    if (overrides)
+        return overrides;
+    const paths = resolvePaths();
+    return {
+        logs: paths.logs,
+        agentsDir: paths.agentsDir,
+        daemonConfig: paths.daemonConfig,
+        defaultsConfig: paths.defaultsConfig,
+    };
+}
+const LOG_SOURCES = [
+    { id: 'daemon', label: 'Daemon', pattern: /^daemon(?:-.+)?\.log$/ },
+    { id: 'ecweb', label: 'ECWeb', pattern: /^(?:watch-web|ecweb[^/]*)\.(?:log|out)$/ },
+    { id: 'stdout', label: 'Standard output', pattern: /^stdout\.log(?:\..+)?$/ },
+    { id: 'aun', label: 'AUN', pattern: /^aun(?:-.+)?\.log$/ },
+    { id: 'sdk', label: 'TypeScript SDK', pattern: /^ts-sdk-.+\.log$/ },
+    { id: 'events', label: 'Events', pattern: /^events-.+\.log$/ },
+    { id: 'channel-in', label: 'Channel · inbound', pattern: /^channel-in-.+\.log$/ },
+    { id: 'channel-out', label: 'Channel · outbound', pattern: /^channel-out-.+\.log$/ },
+    { id: 'commands', label: 'Commands', pattern: /^commands-.+\.jsonl$/ },
+    { id: 'triggers', label: 'Trigger runs', pattern: /^trigger-runs(?:-.+)?\.(?:log|jsonl)$/ },
+    { id: 'restart', label: 'Restart', pattern: /^restart\.log$/ },
+    { id: 'menu-cli', label: 'Menu CLI', pattern: /^menu-cli-exec\.log$/ },
+    { id: 'menu-protocol', label: 'Menu Protocol', pattern: /^menu-protocol(?:-.+)?\.log$/ },
+    { id: 'causation', label: 'Causation spans', pattern: /^causation-spans(?:-.+)?\.log$/ },
+    { id: 'command-audit', label: 'Command audit', pattern: /^command-audit(?:-.+)?\.log$/ },
+    { id: 'role-mutations', label: 'Role mutations', pattern: /^role-mutations(?:-.+)?\.log$/ },
+];
+const LOG_LEVELS = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+const LEVEL_RANK = new Map(LOG_LEVELS.map((level, index) => [level, index]));
+const DEFAULT_LOG_LIMIT = 200;
+const MAX_LOG_LIMIT = 1_000;
+const MAX_LOG_SCAN_LINES = 10_000;
+const MAX_FILE_TAIL_BYTES = 32 * 1024 * 1024;
+const READ_CHUNK_BYTES = 256 * 1024;
+const MAX_LINE_CHARS = 16_000;
+const RESPONSE_CONTENT_BUDGET = 104 * 1024;
+const MAX_DIAGNOSTIC_QUERY_MS = 5_000;
+const cursorSecret = crypto.randomBytes(32);
+function listLogFiles(paths) {
+    try {
+        return fs.readdirSync(paths.logs, { withFileTypes: true })
+            .filter(entry => entry.isFile())
+            .map(entry => {
+            const filePath = path.join(paths.logs, entry.name);
+            const stat = fs.statSync(filePath);
+            return { name: entry.name, path: filePath, size: stat.size, mtimeMs: stat.mtimeMs };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function availableLogSources(files) {
+    return LOG_SOURCES.map(source => {
+        const matches = files.filter(file => source.pattern.test(file.name));
+        return {
+            id: source.id,
+            label: source.label,
+            fileCount: matches.length,
+            size: matches.reduce((sum, file) => sum + file.size, 0),
+            updatedAt: matches.reduce((latest, file) => Math.max(latest, file.mtimeMs), 0),
+        };
+    }).filter(source => source.fileCount > 0);
+}
+function readTail(file, maxLines) {
+    if (file.size <= 0 || maxLines <= 0)
+        return [];
+    let handle;
+    try {
+        handle = fs.openSync(file.path, 'r');
+        const chunks = [];
+        let position = file.size;
+        let bytesRead = 0;
+        let newlines = 0;
+        while (position > 0 && bytesRead < MAX_FILE_TAIL_BYTES && newlines <= maxLines) {
+            const size = Math.min(READ_CHUNK_BYTES, position, MAX_FILE_TAIL_BYTES - bytesRead);
+            const chunk = Buffer.allocUnsafe(size);
+            position -= size;
+            fs.readSync(handle, chunk, 0, size, position);
+            chunks.unshift(chunk);
+            bytesRead += size;
+            for (const byte of chunk)
+                if (byte === 0x0a)
+                    newlines += 1;
+        }
+        let text = Buffer.concat(chunks).toString('utf8');
+        if (position > 0) {
+            const firstBreak = text.indexOf('\n');
+            text = firstBreak >= 0 ? text.slice(firstBreak + 1) : '';
+        }
+        return text.split(/\r?\n/).filter(Boolean).slice(-maxLines);
+    }
+    finally {
+        if (handle !== undefined)
+            try {
+                fs.closeSync(handle);
+            }
+            catch { }
+    }
+}
+function parseLine(rawLine, file) {
+    const raw = rawLine.length > MAX_LINE_CHARS ? `${rawLine.slice(0, MAX_LINE_CHARS)} …` : rawLine;
+    let value;
+    if (rawLine.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(rawLine);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                value = parsed;
+        }
+        catch { }
+    }
+    const textTimestamp = raw.match(/^\[([^\]]+)]\s*(?:\[(?:TRACE|DEBUG|INFO|WARN|ERROR|FATAL)])?/i)?.[1];
+    const timestampValue = value?.ts ?? value?.timestamp ?? value?.startedAt ?? value?.firedAt ?? textTimestamp;
+    const timestamp = typeof timestampValue === 'number'
+        ? new Date(timestampValue).toISOString()
+        : typeof timestampValue === 'string' && timestampValue.trim() ? timestampValue.trim() : null;
+    const explicitLevel = typeof value?.level === 'string' ? value.level.toLowerCase() : undefined;
+    const textLevel = raw.match(/(?:^|\s|\[)(TRACE|DEBUG|INFO|WARN|WARNING|ERROR|FATAL)(?:\]|\s|:)/i)?.[1]?.toLowerCase();
+    const inferred = value?.error || value?.status === 'failed' ? 'error'
+        : value?.status === 'completed' ? 'info'
+            : value?.status === 'started' ? 'debug' : undefined;
+    const level = (explicitLevel || (textLevel === 'warning' ? 'warn' : textLevel) || inferred || null);
+    const scalar = (item) => typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean' ? String(item) : null;
+    const fields = [];
+    const excluded = new Set(['ts', 'timestamp', 'level', 'message', 'msg', 'text', 'event', 'type', 'status', 'error']);
+    if (value) {
+        for (const [key, item] of Object.entries(value)) {
+            if (excluded.has(key) || fields.length >= 12)
+                continue;
+            const normalized = scalar(item);
+            if (normalized !== null)
+                fields.push({ key, value: normalized });
+        }
+    }
+    const event = typeof value?.event === 'string' ? value.event
+        : typeof value?.type === 'string' ? value.type
+            : typeof value?.status === 'string' ? value.status : null;
+    const module = typeof value?.module === 'string' ? value.module
+        : event ? event.split(/[.:]/)[0] : null;
+    const actor = typeof value?.actor === 'string' ? value.actor
+        : typeof value?.aid === 'string' ? value.aid
+            : typeof value?.selfAid === 'string' ? value.selfAid : null;
+    const directionValue = typeof value?.dir === 'string' ? value.dir.toLowerCase() : '';
+    const direction = directionValue === 'in' || directionValue === 'inbound'
+        ? 'in' : directionValue === 'out' || directionValue === 'outbound' ? 'out' : null;
+    const message = value
+        ? scalar(value.message ?? value.msg ?? value.text ?? value.reason ?? value.error) ?? ''
+        : raw.replace(/^\[[^\]]+]\s*(?:\[(?:TRACE|DEBUG|INFO|WARN|ERROR|FATAL)\]\s*)?/i, '').trim();
+    return {
+        timestamp,
+        level,
+        file,
+        module: module || null,
+        actor,
+        direction,
+        event,
+        fields,
+        format: value ? 'json' : 'text',
+        userMessage: !value && !!module && /^\S+: .+$/.test(message),
+        message,
+        raw,
+    };
+}
+function timeBoundary(value, now) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (typeof value !== 'string' && typeof value !== 'number')
+        throw { code: 'INVALID_ARGUMENT', message: 'time filter must be an ISO timestamp, epoch, or duration' };
+    if (typeof value === 'number' || /^\d+$/.test(value)) {
+        const number = Number(value);
+        if (!Number.isFinite(number) || number < 0)
+            throw { code: 'INVALID_ARGUMENT', message: `Invalid time filter: ${String(value)}` };
+        return number < 10_000_000_000 ? number * 1000 : number;
+    }
+    const duration = value.match(/^(\d+)(ms|s|m|h|d)$/i);
+    if (duration) {
+        const unit = duration[2].toLowerCase();
+        const multiplier = unit === 'ms' ? 1 : unit === 's' ? 1_000 : unit === 'm' ? 60_000 : unit === 'h' ? 3_600_000 : 86_400_000;
+        return now - Number(duration[1]) * multiplier;
+    }
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw { code: 'INVALID_ARGUMENT', message: `Invalid time filter: ${value}` };
+    return parsed;
+}
+function cursorSignature(encoded) {
+    return crypto.createHmac('sha256', cursorSecret).update(encoded).digest('base64url');
+}
+function encodeCursor(value) {
+    const encoded = Buffer.from(JSON.stringify(value)).toString('base64url');
+    return `${encoded}.${cursorSignature(encoded)}`;
+}
+function decodeCursor(value, expected) {
+    if (value === undefined || value === null || value === '')
+        return 0;
+    if (typeof value !== 'string')
+        throw { code: 'INVALID_ARGUMENT', message: 'cursor must be a string' };
+    const [encoded, signature, ...rest] = value.split('.');
+    if (!encoded || !signature || rest.length || signature !== cursorSignature(encoded)) {
+        throw { code: 'INVALID_ARGUMENT', message: 'Invalid diagnostic cursor' };
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+    }
+    catch {
+        throw { code: 'INVALID_ARGUMENT', message: 'Invalid diagnostic cursor' };
+    }
+    if (decoded.kind !== expected.kind || decoded.requester !== expected.requester) {
+        throw { code: 'INVALID_ARGUMENT', message: 'Diagnostic cursor does not belong to this request' };
+    }
+    if (decoded.fingerprint !== expected.fingerprint) {
+        throw { code: 'CATALOG_STALE', message: 'Diagnostic resource changed; restart pagination' };
+    }
+    const offset = Number(decoded.offset);
+    if (!Number.isSafeInteger(offset) || offset < 0)
+        throw { code: 'INVALID_ARGUMENT', message: 'Invalid diagnostic cursor offset' };
+    return offset;
+}
+function resourceFingerprint(value) {
+    return crypto.createHash('sha256').update(JSON.stringify(value)).digest('base64url');
+}
+export function listDiagnosticLogOptions(pathOverrides) {
+    const files = listLogFiles(diagnosticPaths(pathOverrides));
+    return {
+        views: ['status', 'monitor', 'logs'],
+        sources: availableLogSources(files),
+        levels: [...LOG_LEVELS],
+        limits: { default: DEFAULT_LOG_LIMIT, max: MAX_LOG_LIMIT },
+    };
+}
+export function queryDiagnosticLogs(args, requester, pathOverrides) {
+    const startedAt = Date.now();
+    const allowed = new Set(['view', 'source', 'since', 'until', 'level', 'limit', 'cursor']);
+    const unknown = Object.keys(args).find(key => !allowed.has(key));
+    if (unknown)
+        throw { code: 'INVALID_ARGUMENT', message: `Unsupported logs argument: ${unknown}` };
+    const files = listLogFiles(diagnosticPaths(pathOverrides));
+    const sources = availableLogSources(files);
+    if (args.source !== undefined && typeof args.source !== 'string') {
+        throw { code: 'INVALID_ARGUMENT', message: 'source must be a string' };
+    }
+    const sourceId = typeof args.source === 'string' && args.source.trim()
+        ? args.source.trim()
+        : sources.some(source => source.id === 'daemon') ? 'daemon' : sources[0]?.id;
+    const source = LOG_SOURCES.find(candidate => candidate.id === sourceId);
+    if (!source || !sources.some(candidate => candidate.id === sourceId)) {
+        throw { code: 'INVALID_ARGUMENT', message: `Unknown or unavailable log source: ${String(sourceId ?? '')}` };
+    }
+    const limit = args.limit === undefined ? DEFAULT_LOG_LIMIT : Number(args.limit);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_LOG_LIMIT) {
+        throw { code: 'INVALID_ARGUMENT', message: `limit must be an integer from 1 to ${MAX_LOG_LIMIT}` };
+    }
+    if (args.level !== undefined && typeof args.level !== 'string') {
+        throw { code: 'INVALID_ARGUMENT', message: 'level must be a string' };
+    }
+    const level = args.level === undefined ? undefined : args.level.toLowerCase();
+    if (level !== undefined && !LEVEL_RANK.has(level)) {
+        throw { code: 'INVALID_ARGUMENT', message: `Unsupported log level: ${level}` };
+    }
+    const now = Date.now();
+    const since = timeBoundary(args.since, now);
+    const until = timeBoundary(args.until, now);
+    if (since !== undefined && until !== undefined && since > until) {
+        throw { code: 'INVALID_ARGUMENT', message: 'since must not be later than until' };
+    }
+    const matching = files.filter(file => source.pattern.test(file.name)).sort((a, b) => a.mtimeMs - b.mtimeMs);
+    const fingerprint = resourceFingerprint({
+        source: sourceId, level, since: args.since ?? null, until: args.until ?? null,
+        files: matching.map(file => [file.name, file.size, file.mtimeMs]),
+    });
+    const offset = decodeCursor(args.cursor, { kind: 'logs', requester, fingerprint });
+    const rawRows = [];
+    for (const file of [...matching].reverse()) {
+        const remaining = MAX_LOG_SCAN_LINES - rawRows.length;
+        if (remaining <= 0)
+            break;
+        rawRows.push(...readTail(file, remaining).map(line => ({ line, file: file.name })));
+    }
+    const rows = rawRows.map(item => parseLine(item.line, item.file))
+        .filter(row => {
+        const timestamp = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
+        if (since !== undefined && (!Number.isFinite(timestamp) || timestamp < since))
+            return false;
+        if (until !== undefined && (!Number.isFinite(timestamp) || timestamp > until))
+            return false;
+        if (level !== undefined) {
+            const rowRank = row.level ? LEVEL_RANK.get(row.level) : undefined;
+            if (rowRank === undefined || rowRank < LEVEL_RANK.get(level))
+                return false;
+        }
+        return true;
+    });
+    const newestFirst = rows.reverse();
+    const page = [];
+    let bytes = 0;
+    let consumed = 0;
+    for (const row of newestFirst.slice(offset)) {
+        if (page.length >= limit)
+            break;
+        const rowBytes = Buffer.byteLength(JSON.stringify(row), 'utf8');
+        if (page.length > 0 && bytes + rowBytes > RESPONSE_CONTENT_BUDGET)
+            break;
+        page.push(row);
+        bytes += rowBytes;
+        consumed += 1;
+    }
+    const nextOffset = offset + consumed;
+    if (Date.now() - startedAt > MAX_DIAGNOSTIC_QUERY_MS) {
+        throw { code: 'TIMEOUT', message: 'Diagnostic log query exceeded the server time limit' };
+    }
+    return {
+        source: sourceId,
+        filters: { since: since ?? null, until: until ?? null, level: level ?? null },
+        limit,
+        lines: page.reverse(),
+        nextCursor: nextOffset < newestFirst.length
+            ? encodeCursor({ kind: 'logs', requester, fingerprint, offset: nextOffset })
+            : null,
+        updatedAt: now,
+    };
+}
+export function listRawConfigResources(pathOverrides) {
+    const paths = diagnosticPaths(pathOverrides);
+    const resources = [
+        { value: 'daemon', label: 'daemon.json' },
+        { value: 'defaults', label: 'agents/defaults.json' },
+    ];
+    try {
+        const agentsDir = paths.agentsDir;
+        for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
+            if (!entry.isDirectory() || !isValidAid(entry.name))
+                continue;
+            const configFile = path.join(agentsDir, entry.name, 'config.json');
+            try {
+                const stat = fs.lstatSync(configFile);
+                if (stat.isFile() && !stat.isSymbolicLink())
+                    resources.push({ value: `agent:${entry.name}`, label: `agents/${entry.name}/config.json` });
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return resources;
+}
+function rawConfigPath(resource, paths) {
+    if (resource === 'daemon' || resource === 'defaults') {
+        const candidate = resource === 'daemon' ? paths.daemonConfig : paths.defaultsConfig;
+        try {
+            const stat = fs.lstatSync(candidate);
+            return stat.isFile() && !stat.isSymbolicLink() ? candidate : undefined;
+        }
+        catch {
+            // Let the caller turn a missing fixed resource into NOT_FOUND.
+            return candidate;
+        }
+    }
+    if (resource.startsWith('agent:')) {
+        const aid = resource.slice('agent:'.length);
+        if (!isValidAid(aid))
+            return undefined;
+        const agentDirectory = path.join(paths.agentsDir, aid);
+        try {
+            const directoryStat = fs.lstatSync(agentDirectory);
+            if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink())
+                return undefined;
+        }
+        catch {
+            return undefined;
+        }
+        const candidate = path.join(paths.agentsDir, aid, 'config.json');
+        const expectedRoot = path.resolve(paths.agentsDir);
+        if (path.dirname(path.resolve(candidate)) !== path.join(expectedRoot, aid))
+            return undefined;
+        try {
+            const stat = fs.lstatSync(candidate);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                return undefined;
+        }
+        catch {
+            return candidate;
+        }
+        return candidate;
+    }
+    return undefined;
+}
+function utf8PageEnd(content, start, maxBytes) {
+    let low = start;
+    let high = content.length;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (Buffer.byteLength(content.slice(start, middle), 'utf8') <= maxBytes)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return Math.max(start, low);
+}
+export function readRawConfigResource(args, requester, pathOverrides) {
+    const startedAt = Date.now();
+    const allowed = new Set(['view', 'resource', 'cursor']);
+    const unknown = Object.keys(args).find(key => !allowed.has(key));
+    if (unknown)
+        throw { code: 'INVALID_ARGUMENT', message: `Unsupported rawFile argument: ${unknown}` };
+    const resource = typeof args.resource === 'string' ? args.resource.trim() : '';
+    const file = rawConfigPath(resource, diagnosticPaths(pathOverrides));
+    if (!file)
+        throw { code: 'INVALID_ARGUMENT', message: 'resource must be one of the advertised rawFile resources' };
+    let stat;
+    let content;
+    try {
+        stat = fs.statSync(file);
+        content = fs.readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            throw { code: 'NOT_FOUND', message: `Configuration resource does not exist: ${resource}` };
+        throw error;
+    }
+    if (!stat.isFile())
+        throw { code: 'NOT_FOUND', message: `Configuration resource is not a file: ${resource}` };
+    const fingerprint = resourceFingerprint({ resource, size: stat.size, mtimeMs: stat.mtimeMs });
+    const offset = decodeCursor(args.cursor, { kind: 'rawFile', requester, fingerprint });
+    if (offset > content.length)
+        throw { code: 'INVALID_ARGUMENT', message: 'rawFile cursor offset is outside the resource' };
+    const end = utf8PageEnd(content, offset, RESPONSE_CONTENT_BUDGET);
+    const truncated = end < content.length;
+    if (Date.now() - startedAt > MAX_DIAGNOSTIC_QUERY_MS) {
+        throw { code: 'TIMEOUT', message: 'Raw configuration query exceeded the server time limit' };
+    }
+    return {
+        resource,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        sha256: crypto.createHash('sha256').update(content).digest('hex'),
+        content: content.slice(offset, end),
+        offset,
+        truncated,
+        nextCursor: truncated ? encodeCursor({ kind: 'rawFile', requester, fingerprint, offset: end }) : null,
+    };
+}

package/dist/core/command/menu-catalog.js

@@ -80,6 +80,9 @@ const ENTRIES = [
     { id: 'activity.agent', type: 'setting', contexts: ['agent'], name: 'activity', label: 'Agent 中间输出', section: 'agent', order: 50, query: { cmd: '/activity', args: { scope: 'agent' }, operation: 'activity.current', scope: 'agent' }, options: { cmd: '/activity', args: { scope: 'agent' }, operation: 'activity.current', scope: 'agent' }, update: { cmd: '/activity', args: { scope: 'agent' }, operation: 'activity.update', scope: 'agent' }, control: 'select' },
     { id: 'observable.agent', type: 'setting', contexts: ['agent'], name: 'observable', label: '观察模式', section: 'agent', order: 60, query: { cmd: '/observable', operation: 'observable.current', scope: 'agent' }, update: { cmd: '/observable', operation: 'observable.update', scope: 'agent' }, valueSchema: { type: 'boolean' }, control: 'toggle' },
     { id: 'system.status', type: 'list', contexts: ['process'], name: 'system', label: '系统状态', section: 'process', order: 10, query: { cmd: '/system', operation: 'system.status', scope: 'process' }, control: 'list' },
+    { id: 'system.monitor', type: 'list', contexts: ['process'], name: 'system', label: '运行监控快照', section: 'process', order: 11, query: { cmd: '/system', args: { view: 'monitor' }, operation: 'system.status', scope: 'process' }, control: 'list' },
+    { id: 'system.logs', type: 'list', contexts: ['process'], name: 'system', label: 'Daemon 日志', section: 'process', order: 12, query: { cmd: '/system', args: { view: 'logs' }, operation: 'system.status', scope: 'process' }, options: { cmd: '/system', args: { option: 'logs' }, operation: 'system.status', scope: 'process', mode: 'dynamic' }, control: 'list' },
+    { id: 'config.rawFile', type: 'list', contexts: ['process'], name: 'config', label: '原始配置文件', section: 'process', order: 13, query: { cmd: '/config', args: { view: 'rawFile' }, operation: 'config.read', scope: 'process' }, options: { cmd: '/config', args: { option: 'rawFile' }, operation: 'config.read', scope: 'process', mode: 'dynamic' }, control: 'list' },
     { id: 'system.restart', type: 'action', contexts: ['process'], name: 'system', label: '重启服务', section: 'process', order: 20, action: { cmd: '/system', action: 'restart', operation: 'system.restart', scope: 'process' } },
     { id: 'system.upgrade', type: 'action', contexts: ['process'], name: 'system', label: '升级服务', section: 'process', order: 30, action: { cmd: '/system', action: 'upgrade', operation: 'system.upgrade', scope: 'process' } },
     { id: 'agent.list', type: 'list', contexts: ['process'], name: 'agent', label: 'Agent 列表', section: 'process', order: 40, options: { cmd: '/agent', args: { options: 'all' }, operation: 'agent.list', scope: 'control', mode: 'dynamic' }, control: 'list' },