ec-web 0.0.1 → 0.0.3

package/dist/sources/aid.js

@@ -0,0 +1,139 @@
+/**
+ * AID 数据源 — 复用 daemon 的 IPC socket（与 evolcore `watch aid` 同源）。
+ *
+ * daemon 运行时：拉 aun-aids / aun-aid-stats / agent-stats / status / evolagent.list。
+ * daemon 未运行时：降级到读 instance/ 目录的 aid-*.jsonl（精简版 scanInstances）。
+ * IPC 无推送能力，故 1s 轮询 + JSON diff，仅在变化时 push。
+ */
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc-client.js';
+/** 精简版实例扫描：仅在 daemon 离线时降级用，读各 alive main 进程的 aid 活动日志 */
+function scanAidActivity() {
+    const result = new Map();
+    const dir = resolvePaths().instanceDir;
+    let files;
+    try {
+        files = fs.readdirSync(dir);
+    }
+    catch {
+        return result;
+    }
+    for (const file of files) {
+        if (!file.startsWith('main-') || !file.endsWith('.json'))
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf-8'));
+        }
+        catch {
+            continue;
+        }
+        if (!rec?.pid)
+            continue;
+        // 进程存活检测（轻量：signal 0）
+        try {
+            process.kill(rec.pid, 0);
+        }
+        catch {
+            continue;
+        }
+        // 读该 pid 的 aid-<pid>.jsonl，按 aid 取最后活动
+        const aidLog = path.join(dir, `aid-${rec.pid}.jsonl`);
+        let content;
+        try {
+            content = fs.readFileSync(aidLog, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of content.trim().split('\n')) {
+            if (!line)
+                continue;
+            try {
+                const ev = JSON.parse(line);
+                if (ev.aid && ev.ts) {
+                    const prev = result.get(ev.aid);
+                    if (!prev || ev.ts > prev.ts)
+                        result.set(ev.aid, { ts: ev.ts, event: ev.event });
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    return result;
+}
+// evolcore 版本：与 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' }, auth: { source: 'ecweb', localDirect: true } }, 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, agentStatsResp, statusResp, agentsResp, version] = await Promise.all([
+        ipcQuery(p.socket, { type: 'aun-aids' }),
+        ipcQuery(p.socket, { type: 'aun-aid-stats' }),
+        ipcQuery(p.socket, { type: 'agent-stats' }),
+        ipcQuery(p.socket, { type: 'status' }),
+        ipcQuery(p.socket, { type: 'evolagent.list' }),
+        fetchVersion(p.socket),
+    ]);
+    const daemonRunning = aidsResp !== null || statusResp !== null;
+    if (!daemonRunning) {
+        const activity = scanAidActivity();
+        const aids = Array.from(activity.entries()).map(([aid, info]) => ({
+            aid,
+            status: info.event === 'disconnected' ? 'disconnected' : 'offline',
+            lastActivity: info.ts,
+            lastEvent: info.event,
+        }));
+        return { daemonRunning: false, aids, stats: [], agents: [] };
+    }
+    return {
+        daemonRunning: true,
+        aids: aidsResp?.aids ?? [],
+        stats: statsResp?.stats ?? [],
+        agentStats: agentStatsResp?.stats ?? [],
+        status: statusResp ?? null,
+        agents: agentsResp?.agents ?? [],
+        version: version ?? null,
+    };
+}
+export const aidSource = {
+    kind: 'agents',
+    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/baseagent-detector.js

@@ -0,0 +1,72 @@
+/**
+ * Base agent 环境检测 — 检测 Claude 和 Codex 的可用性。
+ *
+ * 检测条件：
+ * - Claude: ~/.claude/projects/ 目录存在
+ * - Codex: ~/.codex/sessions/ 和 ~/.codex/state_*.sqlite 存在，且 Node 版本 >= 22.5
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { createRequire } from 'module';
+const requireFromHere = createRequire(import.meta.url);
+let _cached = null;
+/**
+ * 检测 node:sqlite 模块是否可用（Node 22.5+）
+ */
+function checkSqliteAvailable() {
+    try {
+        requireFromHere('node:sqlite');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检测 Codex state_*.sqlite 文件是否存在
+ */
+function checkCodexStateDb() {
+    const codexHome = path.join(os.homedir(), '.codex');
+    if (!fs.existsSync(codexHome))
+        return false;
+    try {
+        const files = fs.readdirSync(codexHome).filter(f => /^state_\d+\.sqlite$/.test(f));
+        return files.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检测 Claude projects 目录是否存在
+ */
+function checkClaudeProjects() {
+    const claudeProjects = path.join(os.homedir(), '.claude', 'projects');
+    return fs.existsSync(claudeProjects);
+}
+/**
+ * 检测 Codex sessions 目录是否存在
+ */
+function checkCodexSessions() {
+    const codexSessions = path.join(os.homedir(), '.codex', 'sessions');
+    return fs.existsSync(codexSessions);
+}
+/**
+ * 检测所有 base agent 的可用性
+ * 结果会缓存，避免重复检测
+ */
+export function detectBaseAgents() {
+    if (_cached)
+        return _cached;
+    const claude = checkClaudeProjects();
+    const codex = checkCodexSessions() && checkCodexStateDb() && checkSqliteAvailable();
+    _cached = { claude, codex };
+    return _cached;
+}
+/**
+ * 重置缓存（测试用）
+ */
+export function resetDetectionCache() {
+    _cached = null;
+}

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/gateway.js

@@ -0,0 +1,44 @@
+/**
+ * gateway.ts — 网关（baseagent 后端）配置数据源（只读代理）。
+ *
+ * ECWeb 不直接读写配置文件。snapshot 通过 daemon 的 menu.exec IPC 调
+ * menu.query name=gateway，由 daemon 端的 command-handler-gateway-control 统一
+ * 出数据（apiKey 已掩码）。写操作（update/test/delete）走前端 menuSend → menu IPC，
+ * 不经过本 source。
+ *
+ * 连不上 daemon 时返回 { gateways: [], error } 让前端提示。
+ */
+import { resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc-client.js';
+async function getSnapshot() {
+    const sock = resolvePaths().socket;
+    const resp = await ipcQuery(sock, { type: 'menu.exec', payload: { type: 'menu.query', name: 'gateway', id: 'ecw-gateway-snap' }, auth: { source: 'ecweb', localDirect: true } }, 5000);
+    if (!resp) {
+        return { gateways: [], scopes: [], types: [], error: 'evolcore 未运行或 socket 不可达' };
+    }
+    if (!resp.ok) {
+        return { gateways: [], scopes: [], types: [], error: resp.error || 'daemon 返回失败' };
+    }
+    const inner = resp.response;
+    if (inner?.error) {
+        return { gateways: [], scopes: [], types: [], error: inner.error.message };
+    }
+    const data = inner?.data ?? {};
+    return {
+        gateways: Array.isArray(data.gateways) ? data.gateways : [],
+        scopes: Array.isArray(data.scopes) ? data.scopes : [],
+        types: Array.isArray(data.types) ? data.types : [],
+        effective: Array.isArray(data.effective) ? data.effective : [],
+        envMismatch: data.envMismatch || { hasMismatch: false, mismatches: [] },
+    };
+}
+export const gatewaySource = {
+    kind: 'gateway',
+    async snapshot() {
+        return getSnapshot();
+    },
+    subscribe(_params, _push) {
+        // 网关配置变更不频繁，无文件监听；前端通过操作后主动 re-subscribe 刷新。
+        return () => { };
+    },
+};

package/dist/sources/logs.js

@@ -0,0 +1,396 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolvePaths } from '../paths.js';
+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: 'causation', label: 'Causation spans', pattern: /^causation-spans(?:-.+)?\.log$/ },
+];
+const DEFAULT_LIMIT = 500;
+const MAX_LIMIT = 1000;
+const MAX_FILE_TAIL_BYTES = 384 * 1024;
+const MAX_LINE_CHARS = 12_000;
+function listLogFiles() {
+    const logsDir = resolvePaths().logs;
+    try {
+        return fs.readdirSync(logsDir, { withFileTypes: true })
+            .filter(entry => entry.isFile())
+            .map(entry => {
+            const filePath = path.join(logsDir, entry.name);
+            const stat = fs.statSync(filePath);
+            return { name: entry.name, path: filePath, size: stat.size, mtimeMs: stat.mtimeMs };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function availableSources(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((total, file) => total + file.size, 0),
+            updatedAt: matches.reduce((latest, file) => Math.max(latest, file.mtimeMs), 0),
+        };
+    }).filter(source => source.fileCount > 0)
+        .sort((a, b) => {
+        const ai = LOG_SOURCES.findIndex(source => source.id === a.id);
+        const bi = LOG_SOURCES.findIndex(source => source.id === b.id);
+        return ai - bi;
+    });
+}
+function readTail(file, maxLines) {
+    if (file.size <= 0 || maxLines <= 0)
+        return [];
+    const bytes = Math.min(file.size, MAX_FILE_TAIL_BYTES);
+    const buffer = Buffer.allocUnsafe(bytes);
+    let handle = null;
+    try {
+        handle = fs.openSync(file.path, 'r');
+        fs.readSync(handle, buffer, 0, bytes, file.size - bytes);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (handle != null)
+            try {
+                fs.closeSync(handle);
+            }
+            catch { }
+    }
+    let text = buffer.toString('utf8');
+    if (bytes < file.size) {
+        const firstBreak = text.indexOf('\n');
+        text = firstBreak >= 0 ? text.slice(firstBreak + 1) : '';
+    }
+    return text.split(/\r?\n/).filter(Boolean).slice(-maxLines);
+}
+function shortLogName(file) {
+    return path.basename(file)
+        .replace(/\.(?:log|jsonl|out)(?:\..+)?$/, '')
+        .replace(/-\d{8}-\d{2}$/, '')
+        .replace(/-\d{8}$/, '')
+        .replace(/-\d{4}-\d{2}-\d{2}(?:-\d{2})?$/, '');
+}
+function normalizeTimestamp(value) {
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    const millis = Number(value);
+    return Number.isFinite(millis) && millis > 0 ? new Date(millis).toISOString() : null;
+}
+function fieldValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return null;
+}
+function collectFields(value, excluded, limit = 10, prefix = '') {
+    const fields = [];
+    for (const [key, rawValue] of Object.entries(value)) {
+        if (excluded.has(key) || fields.length >= limit)
+            continue;
+        const scalar = fieldValue(rawValue);
+        if (scalar != null) {
+            fields.push({ key: prefix ? `${prefix}.${key}` : key, value: scalar });
+            continue;
+        }
+        if (rawValue && typeof rawValue === 'object' && !Array.isArray(rawValue)) {
+            fields.push(...collectFields(rawValue, new Set(), limit - fields.length, prefix ? `${prefix}.${key}` : key));
+        }
+    }
+    return fields.slice(0, limit);
+}
+function parseJsonLine(raw, file) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const timestamp = normalizeTimestamp(value.ts ?? value.timestamp ?? value.startedAt ?? value.firedAt ?? value.finishedAt);
+    let level = null;
+    if (value.status === 'failed' || value.error)
+        level = 'error';
+    else if (value.status === 'completed')
+        level = 'info';
+    else if (value.status === 'started')
+        level = 'debug';
+    if (value.msgId && value.status) {
+        const direction = value.dir === 'inbound' ? 'in' : (value.dir === 'outbound' ? 'out' : null);
+        const peer = String(value.msgId).replace(/_\d+(_reply)?$/, '').replace(/^[^_]+_/, '');
+        return {
+            timestamp,
+            level,
+            file,
+            module: 'message',
+            actor: peer || null,
+            direction,
+            event: String(value.status),
+            fields: collectFields(value, new Set(['ts', 'timestamp', 'msgId', 'status', 'dir']), 8),
+            format: 'json',
+            userMessage: false,
+            message: peer ? `${peer}:` : '',
+            raw,
+        };
+    }
+    if (value.dir && value.event) {
+        const directionValue = String(value.dir).toLowerCase();
+        const direction = directionValue === 'in' || directionValue === 'inbound'
+            ? 'in'
+            : (directionValue === 'out' || directionValue === 'outbound' ? 'out' : null);
+        const event = String(value.event);
+        const fields = value.data && typeof value.data === 'object'
+            ? collectFields(value.data, new Set(), 10)
+            : collectFields(value, new Set(['ts', 'timestamp', 'dir', 'event', 'self_aid', 'data']), 10);
+        return {
+            timestamp,
+            level,
+            file,
+            module: event.split(/[.:]/)[0] || 'event',
+            actor: value.self_aid ? String(value.self_aid) : null,
+            direction,
+            event,
+            fields,
+            format: 'json',
+            userMessage: false,
+            message: '',
+            raw,
+        };
+    }
+    if (value.runId && value.triggerId) {
+        const startedAt = Number(value.startedAt);
+        const finishedAt = Number(value.finishedAt);
+        const duration = Number.isFinite(startedAt) && Number.isFinite(finishedAt) && finishedAt >= startedAt
+            ? finishedAt - startedAt
+            : null;
+        const fields = [
+            { key: 'runId', value: String(value.runId) },
+            { key: 'triggerId', value: String(value.triggerId) },
+            ...(duration == null ? [] : [{ key: 'duration', value: `${duration}ms` }]),
+            ...(value.source?.type ? [{ key: 'source', value: String(value.source.type) }] : []),
+        ];
+        return {
+            timestamp,
+            level,
+            file,
+            module: 'trigger',
+            actor: value.agentAid ? String(value.agentAid) : null,
+            direction: null,
+            event: value.status ? String(value.status) : null,
+            fields,
+            format: 'json',
+            userMessage: false,
+            message: String(value.definition?.name || value.reason || value.error?.message || ''),
+            raw,
+        };
+    }
+    if (value.command) {
+        return {
+            timestamp,
+            level,
+            file,
+            module: 'command',
+            actor: value.aid ? String(value.aid) : null,
+            direction: null,
+            event: value.cmd ? String(value.cmd) : null,
+            fields: collectFields(value, new Set(['ts', 'timestamp', 'cmd', 'command', 'aid']), 8),
+            format: 'json',
+            userMessage: false,
+            message: String(value.command),
+            raw,
+        };
+    }
+    if (value.type) {
+        const event = String(value.type);
+        return {
+            timestamp,
+            level,
+            file,
+            module: event.split(/[.:]/)[0] || 'event',
+            actor: value.self_aid ? String(value.self_aid) : (value.agentAid ? String(value.agentAid) : null),
+            direction: null,
+            event,
+            fields: collectFields(value, new Set(['ts', 'timestamp', 'type', 'self_aid', 'agentAid']), 10),
+            format: 'json',
+            userMessage: false,
+            message: '',
+            raw,
+        };
+    }
+    return {
+        timestamp,
+        level,
+        file,
+        module: shortLogName(file),
+        actor: value.aid ? String(value.aid) : null,
+        direction: null,
+        event: value.status ? String(value.status) : null,
+        fields: collectFields(value, new Set(['ts', 'timestamp', 'aid', 'status']), 10),
+        format: 'json',
+        userMessage: false,
+        message: '',
+        raw,
+    };
+}
+function parseTextLine(raw, file) {
+    let message = raw;
+    let timestamp = null;
+    let level = null;
+    let module = null;
+    let actor = null;
+    const fields = [];
+    const structured = message.match(/^\[([^\]]+)]\s*\[(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)]\s*/i);
+    if (structured) {
+        timestamp = structured[1];
+        level = structured[2].toLowerCase();
+        message = message.slice(structured[0].length);
+    }
+    else {
+        const timeOnly = message.match(/^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\s+/);
+        if (timeOnly) {
+            timestamp = timeOnly[1];
+            message = message.slice(timeOnly[0].length);
+        }
+    }
+    if (!level) {
+        const levelFirst = message.match(/^\[(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)]\s*/i);
+        if (levelFirst) {
+            level = levelFirst[1].toLowerCase();
+            message = message.slice(levelFirst[0].length);
+        }
+    }
+    const sdkFirst = !level ? message.match(/^\[([^\]]+)]\s+\[(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)]\s*/i) : null;
+    if (sdkFirst) {
+        module = sdkFirst[1];
+        level = sdkFirst[2].toLowerCase();
+        message = message.slice(sdkFirst[0].length);
+    }
+    const tags = [];
+    while (message.startsWith('[')) {
+        const tag = message.match(/^\[([^\]]+)]\s*/);
+        if (!tag)
+            break;
+        tags.push(tag[1]);
+        message = message.slice(tag[0].length);
+    }
+    if (!module && tags.length)
+        module = tags.shift() || null;
+    for (const tag of tags) {
+        const equals = tag.indexOf('=');
+        if (equals > 0)
+            fields.push({ key: tag.slice(0, equals), value: tag.slice(equals + 1) });
+        else if (/\.agentid\.pub$/.test(tag))
+            actor = tag;
+        else
+            fields.push({ key: 'context', value: tag });
+    }
+    if (!level) {
+        const detectedLevel = message.match(/\b(TRACE|DEBUG|INFO|WARN|WARNING|ERROR|FATAL)\b/i)?.[1];
+        if (detectedLevel)
+            level = detectedLevel.toLowerCase() === 'warning' ? 'warn' : detectedLevel.toLowerCase();
+    }
+    if (!module && timestamp)
+        module = shortLogName(file);
+    return {
+        timestamp,
+        level,
+        file,
+        module,
+        actor,
+        direction: null,
+        event: null,
+        fields,
+        format: 'text',
+        userMessage: !!module && /^\S+: .+$/.test(message),
+        message,
+        raw,
+    };
+}
+function parseLine(rawLine, file) {
+    const raw = rawLine.length > MAX_LINE_CHARS
+        ? `${rawLine.slice(0, MAX_LINE_CHARS)} …`
+        : rawLine;
+    return raw.startsWith('{') ? (parseJsonLine(raw, file) || parseTextLine(raw, file)) : parseTextLine(raw, file);
+}
+function linesFor(files, source, limit) {
+    const matching = files
+        .filter(file => source.pattern.test(file.name))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    let rawLines = [];
+    for (const file of matching) {
+        const remaining = limit - rawLines.length;
+        if (remaining <= 0)
+            break;
+        const fileLines = readTail(file, remaining).map(line => ({ file: file.name, line }));
+        rawLines = [...fileLines, ...rawLines];
+    }
+    return rawLines.slice(-limit).map(item => parseLine(item.line, item.file));
+}
+function buildSnapshot(params = {}) {
+    const files = listLogFiles();
+    const sources = availableSources(files);
+    const requested = String(params.source || '');
+    const selectedSource = sources.some(source => source.id === requested)
+        ? requested
+        : (sources.some(source => source.id === 'daemon') ? 'daemon' : (sources[0]?.id || null));
+    const source = LOG_SOURCES.find(item => item.id === selectedSource);
+    const limit = Math.min(MAX_LIMIT, Math.max(100, Number(params.limit) || DEFAULT_LIMIT));
+    const lines = source ? linesFor(files, source, limit) : [];
+    const selectedMeta = sources.find(item => item.id === selectedSource) || null;
+    return {
+        sources,
+        selectedSource,
+        selectedMeta,
+        limit,
+        lines,
+        updatedAt: Date.now(),
+    };
+}
+export const logsSource = {
+    kind: 'logs',
+    async snapshot(params = {}) {
+        return buildSnapshot(params);
+    },
+    subscribe(params, push) {
+        let stopped = false;
+        let lastSignature = '';
+        const tick = () => {
+            if (stopped)
+                return;
+            try {
+                const snapshot = buildSnapshot(params);
+                const signature = JSON.stringify({
+                    source: snapshot.selectedSource,
+                    meta: snapshot.selectedMeta,
+                    count: snapshot.lines.length,
+                    last: snapshot.lines.at(-1)?.raw || '',
+                });
+                if (signature !== lastSignature) {
+                    lastSignature = signature;
+                    push(snapshot);
+                }
+            }
+            catch { }
+        };
+        const timer = setInterval(tick, 2000);
+        return () => { stopped = true; clearInterval(timer); };
+    },
+};