ec-web 0.0.4 → 0.0.5

package/dist/sources/session-origin.js

@@ -0,0 +1,195 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { readJsonFile, scanChatDirs } from '../fs-utils.js';
+/** Resolve the local Agent's display name for a session binding. */
+export function resolveSessionBindSelfName(bind, names) {
+    if (!bind?.selfAID)
+        return null;
+    return names.get(bind.selfAID) || bind.selfAID.split('.')[0] || bind.selfAID;
+}
+const bindingFileCache = new Map();
+const SHARED_SYNTHETIC_CLI_PREFIXES = [
+    'Use Bash exactly once to run:',
+    'Use the Bash tool now to execute',
+    'Review this change for security vulnerabilities',
+    'You previously flagged these candidate vulnerabilities',
+];
+const CLAUDE_SYNTHETIC_CLI_PREFIXES = ['Base directory for this skill:'];
+const CLAUDE_SYNTHETIC_TAG_RE = /^<\/?(?:local-command|command)-[a-z]+>/i;
+const CLAUDE_SYNTHETIC_SLASH_RE = /^\/(?:resume|clear|compact|model|init|review|cost|config|status|help|agents?|context|memory|export|hooks?|mcp|ide|login|logout|doctor|bug|release-notes|vim|terminal-setup|add-dir|permissions)(?:\s|$)/i;
+const EVOLCORE_ROUTE_PREFIX_RE = /^‹[^›]*·\s*from:[^›]*→[^›]*self:[^›]*›\s*/;
+function normalizePeerType(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return undefined;
+    const key = value.trim().toLowerCase();
+    if (key === 'human' || key === 'person' || key === 'user')
+        return 'human';
+    if (key === 'system' || key === 'trigger' || key === 'scheduler')
+        return 'system';
+    if (key === 'service' || key === 'daemon' || key === 'tool')
+        return 'service';
+    if (key === 'unknown')
+        return 'unknown';
+    return 'agent';
+}
+function classifyBinding(session) {
+    const channelType = String(session.channelType || '').toLowerCase();
+    const channelId = String(session.channelId || '');
+    const threadId = String(session.threadId || '');
+    if (channelType === 'daemon') {
+        return channelId.startsWith('trigger:') || threadId.startsWith('trigger:') ? 'trigger' : 'unknown';
+    }
+    if (channelType === 'aun') {
+        if (session.chatType === 'group')
+            return 'user';
+        const peerKind = normalizePeerType(session.metadata?.peerType);
+        if (peerKind === 'agent')
+            return 'agent';
+        if (peerKind === 'human')
+            return 'user';
+        return 'unknown';
+    }
+    return channelType ? 'user' : 'unknown';
+}
+function toBinding(session, fallback, currentlyBound = false) {
+    if (!session.agentSessionId)
+        return null;
+    const channelType = session.channelType || fallback.channelType;
+    const channelId = session.channelId || fallback.channelId;
+    const chatType = session.chatType || 'private';
+    return {
+        evolSessionId: session.id || null,
+        channelType,
+        channelId,
+        channelKey: session.channel || session.metadata?.channelKey || channelType,
+        selfAID: session.selfAID || fallback.selfAID,
+        chatType,
+        peerId: session.metadata?.peerId || channelId,
+        peerName: session.metadata?.peerName || null,
+        peerType: session.metadata?.peerType || null,
+        ...(chatType === 'group' ? { groupId: session.metadata?.groupId || channelId } : {}),
+        groupName: session.metadata?.groupName || null,
+        displayName: null,
+        name: session.name || null,
+        threadId: session.threadId || '',
+        updatedAt: session.updatedAt || 0,
+        currentlyBound,
+        sourceType: classifyBinding({ ...session, channelType, channelId, chatType }),
+    };
+}
+function parseBindingJsonl(file, fallback) {
+    let stat;
+    try {
+        stat = fs.statSync(file);
+    }
+    catch {
+        bindingFileCache.delete(file);
+        return [];
+    }
+    const cached = bindingFileCache.get(file);
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size)
+        return cached.bindings;
+    const byAgentSessionId = new Map();
+    let finalAgentSessionId = null;
+    try {
+        const lines = fs.readFileSync(file, 'utf8').trimEnd().split(/\r?\n/);
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let session;
+            try {
+                session = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const agentSessionId = session.agentSessionId;
+            finalAgentSessionId = agentSessionId || null;
+            if (!agentSessionId)
+                continue;
+            const binding = toBinding(session, fallback);
+            if (!binding)
+                continue;
+            const existing = byAgentSessionId.get(agentSessionId);
+            if (!existing || binding.updatedAt >= existing.updatedAt)
+                byAgentSessionId.set(agentSessionId, binding);
+        }
+    }
+    catch { }
+    const bindings = Array.from(byAgentSessionId, ([agentSessionId, binding]) => ({
+        agentSessionId,
+        binding: { ...binding, currentlyBound: agentSessionId === finalAgentSessionId },
+    }));
+    bindingFileCache.set(file, { mtimeMs: stat.mtimeMs, size: stat.size, bindings });
+    return bindings;
+}
+function bindingFiles(dirPath) {
+    const files = [];
+    for (const dir of [dirPath, path.join(dirPath, '_threads')]) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isFile() && /^meta_.+\.jsonl$/.test(entry.name))
+                files.push(path.join(dir, entry.name));
+        }
+    }
+    return files;
+}
+export function buildSessionBindMap(sessionsDir = resolvePaths().sessionsDir) {
+    const map = new Map();
+    const liveFiles = new Set();
+    for (const dir of scanChatDirs(sessionsDir)) {
+        const fallback = { channelType: dir.channelType, channelId: dir.channelId, selfAID: dir.selfAID };
+        const active = readJsonFile(path.join(dir.dirPath, 'active.json'));
+        const activeBinding = active ? toBinding(active, fallback, true) : null;
+        if (activeBinding && active?.agentSessionId)
+            map.set(active.agentSessionId, activeBinding);
+        for (const file of bindingFiles(dir.dirPath)) {
+            liveFiles.add(file);
+            for (const { agentSessionId, binding } of parseBindingJsonl(file, fallback)) {
+                const existing = map.get(agentSessionId);
+                if (!existing
+                    || (binding.currentlyBound && !existing.currentlyBound)
+                    || binding.currentlyBound === existing.currentlyBound && binding.updatedAt >= existing.updatedAt) {
+                    map.set(agentSessionId, binding);
+                }
+            }
+        }
+    }
+    for (const file of bindingFileCache.keys()) {
+        if (path.resolve(file).startsWith(`${path.resolve(sessionsDir)}${path.sep}`) && !liveFiles.has(file)) {
+            bindingFileCache.delete(file);
+        }
+    }
+    return map;
+}
+export function isSyntheticCliPrompt(text, backend) {
+    if (typeof text !== 'string' || !text.trim())
+        return false;
+    const trimmed = text.trimStart();
+    const prefixes = backend === 'claude'
+        ? SHARED_SYNTHETIC_CLI_PREFIXES.concat(CLAUDE_SYNTHETIC_CLI_PREFIXES)
+        : SHARED_SYNTHETIC_CLI_PREFIXES;
+    if (prefixes.some(prefix => trimmed.startsWith(prefix)))
+        return true;
+    return backend === 'claude'
+        && (CLAUDE_SYNTHETIC_TAG_RE.test(trimmed) || CLAUDE_SYNTHETIC_SLASH_RE.test(trimmed));
+}
+export function isEvolcoreRoutedMessage(text) {
+    return typeof text === 'string' && EVOLCORE_ROUTE_PREFIX_RE.test(text.trimStart());
+}
+export function classifyTranscriptSource(binding, cliCandidate) {
+    if (binding?.currentlyBound)
+        return binding.sourceType;
+    if (cliCandidate)
+        return 'cli';
+    if (binding)
+        return binding.sourceType;
+    return 'unknown';
+}

package/dist/sources/session.js

@@ -13,8 +13,10 @@
 import fs from 'fs';
 import path from 'path';
 import { resolvePaths, ccProjectsDir } from '../paths.js';
-import { encodePath, scanChatDirs, readJsonFile } from '../fs-utils.js';
+import { encodePath } from '../fs-utils.js';
 import { snapshotCodex, subscribeCodex, setDebugLog as setCodexDebugLog } from './session-codex.js';
+import { getAgentSelfNames } from './msg.js';
+import { buildSessionBindMap, classifyTranscriptSource, isSyntheticCliPrompt, resolveSessionBindSelfName, } from './session-origin.js';
 let _dlog = null;
 export function setDebugLog(log) {
     _dlog = log;
@@ -25,7 +27,7 @@ function dlog(line) { if (_dlog)
         _dlog(line);
     }
     catch { } }
-const CACHE_VERSION = 4;
+const CACHE_VERSION = 5;
 const _metaCache = new Map();
 function cacheDir(encoded) {
     const dataDir = resolvePaths().dataDir;
@@ -120,7 +122,8 @@ function extractMeta(file, id, stat) {
         raw = fs.readFileSync(file, 'utf-8');
     }
     catch { }
-    let title = '', firstUser = '', gitBranch = '', version = '', userMsgs = 0, totalMsgs = 0;
+    let title = '', firstUser = '', gitBranch = '', version = '', entrypoint = '', userMsgs = 0, totalMsgs = 0;
+    let hasRealCliMessage = false, internalSubagent = id.startsWith('agent-');
     for (const line of raw.split('\n')) {
         if (!line)
             continue;
@@ -140,8 +143,20 @@ function extractMeta(file, id, stat) {
             totalMsgs++;
         else if (isUser) {
             totalMsgs++;
-            if (o && isCountableUserMessage(o, id))
-                userMsgs++;
+            if (o) {
+                if (isCountableUserMessage(o, id))
+                    userMsgs++;
+                if (!entrypoint && typeof o.entrypoint === 'string')
+                    entrypoint = o.entrypoint;
+                if (o.isSidechain || o.agentId)
+                    internalSubagent = true;
+                const content = o.message?.content;
+                if (!isToolResultOnly(content)) {
+                    const text = extractMessageText(content);
+                    if (text.trim() && !isSyntheticCliPrompt(text, 'claude'))
+                        hasRealCliMessage = true;
+                }
+            }
         }
         if ((!gitBranch || !version || !firstUser) && (line.indexOf('gitBranch') !== -1 || line.indexOf('"version"') !== -1 || line.indexOf('ai-title') !== -1 || (isUser && !firstUser))) {
             if (!o) {
@@ -165,7 +180,12 @@ function extractMeta(file, id, stat) {
             }
         }
     }
-    return { id, title, firstUser, gitBranch, version, userMsgs, totalMsgs, sizeKB: Math.round(stat.size / 1024), lastActivity: stat.mtimeMs };
+    return {
+        id, title, firstUser, gitBranch, version, userMsgs, totalMsgs,
+        sizeKB: Math.round(stat.size / 1024),
+        lastActivity: stat.mtimeMs,
+        cliCandidate: !internalSubagent && (entrypoint === 'cli' || entrypoint === 'sdk-cli') && hasRealCliMessage,
+    };
 }
 function listTranscripts(encoded) {
     const dir = path.join(ccProjectsDir(), encoded);
@@ -293,25 +313,162 @@ function resolveProject(params, projects) {
     return projects[0] || null;
 }
 export function buildBindMap() {
-    const map = new Map();
+    return buildSessionBindMap();
+}
+// ── EvolCore runner 子任务事件 ──
+const RUNNER_TASK_EVENT_TYPES = new Set([
+    'runner:task-started',
+    'runner:task-progress',
+    'runner:task-notification',
+]);
+const EVENT_LOG_RE = /^events(?:-.+)?\.log$/;
+const _runnerLogCache = new Map();
+function parseRunnerTaskLines(raw) {
+    const events = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.includes('"type":"runner:task-'))
+            continue;
+        try {
+            const event = JSON.parse(line);
+            if (RUNNER_TASK_EVENT_TYPES.has(event.type) && event.sessionId)
+                events.push(event);
+        }
+        catch { }
+    }
+    return events;
+}
+function readRunnerLogFile(file) {
+    let stat;
     try {
-        const p = resolvePaths();
-        for (const dir of scanChatDirs(p.sessionsDir)) {
-            const active = readJsonFile(path.join(dir.dirPath, 'active.json'));
-            if (!active || !active.agentSessionId)
-                continue;
-            map.set(active.agentSessionId, {
-                channelType: active.channelType || dir.channelType,
-                channelId: active.channelId || dir.channelId,
-                selfAID: active.selfAID || dir.selfAID,
-                peerName: (active.metadata && active.metadata.peerName) || null,
-                name: active.name,
-                updatedAt: active.updatedAt || 0,
-            });
+        stat = fs.statSync(file);
+    }
+    catch {
+        _runnerLogCache.delete(file);
+        return [];
+    }
+    let cached = _runnerLogCache.get(file);
+    if (!cached || stat.size < cached.offset)
+        cached = { offset: 0, events: [] };
+    if (stat.size === cached.offset) {
+        _runnerLogCache.set(file, cached);
+        return cached.events;
+    }
+    const bytes = stat.size - cached.offset;
+    const buffer = Buffer.allocUnsafe(bytes);
+    let fd = null;
+    try {
+        fd = fs.openSync(file, 'r');
+        fs.readSync(fd, buffer, 0, bytes, cached.offset);
+    }
+    catch {
+        return cached.events;
+    }
+    finally {
+        if (fd != null)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+    }
+    // 只推进到最后一个完整 JSONL 行，避免 watcher 在写入中途触发时丢事件。
+    const lastBreak = buffer.lastIndexOf(0x0a);
+    if (lastBreak < 0) {
+        _runnerLogCache.set(file, cached);
+        return cached.events;
+    }
+    const parsed = parseRunnerTaskLines(buffer.subarray(0, lastBreak + 1).toString('utf8'));
+    cached = {
+        offset: cached.offset + lastBreak + 1,
+        events: cached.events.concat(parsed),
+    };
+    _runnerLogCache.set(file, cached);
+    return cached.events;
+}
+function runnerEventTimestamp(event) {
+    const timestamp = Number(event.timestamp);
+    if (Number.isFinite(timestamp) && timestamp > 0)
+        return timestamp;
+    const parsed = event.ts ? Date.parse(event.ts) : 0;
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+export function readRunnerTaskTurns(logsDir, evolSessionId) {
+    let files;
+    try {
+        files = fs.readdirSync(logsDir)
+            .filter(name => EVENT_LOG_RE.test(name))
+            .sort()
+            .map(name => path.join(logsDir, name));
+    }
+    catch {
+        return [];
+    }
+    const validFiles = new Set(files);
+    for (const cachedFile of _runnerLogCache.keys()) {
+        if (path.dirname(cachedFile) === logsDir && !validFiles.has(cachedFile))
+            _runnerLogCache.delete(cachedFile);
+    }
+    const events = files
+        .flatMap(readRunnerLogFile)
+        .filter(event => event.sessionId === evolSessionId)
+        .sort((a, b) => runnerEventTimestamp(a) - runnerEventTimestamp(b));
+    const tasks = new Map();
+    for (const event of events) {
+        const taskId = event.taskId || event.toolUseId;
+        if (!taskId)
+            continue;
+        const at = runnerEventTimestamp(event);
+        let task = tasks.get(taskId);
+        if (!task) {
+            task = {
+                taskId,
+                taskKind: event.taskKind || 'agent',
+                toolUseId: event.toolUseId || null,
+                description: event.description || taskId,
+                subagentType: event.subagentType || null,
+                status: 'running',
+                terminalReason: '',
+                progress: '',
+                lastToolName: '',
+                totalTokens: 0,
+                toolUses: 0,
+                durationMs: 0,
+                startedAt: at,
+                updatedAt: at,
+            };
+            tasks.set(taskId, task);
+        }
+        if (event.type === 'runner:task-started') {
+            task.startedAt = task.startedAt ? Math.min(task.startedAt, at) : at;
+            task.status = 'running';
+        }
+        else if (event.type === 'runner:task-progress') {
+            task.progress = event.summary || event.description || task.progress;
         }
+        else if (event.type === 'runner:task-notification') {
+            task.status = event.status || 'completed';
+            task.terminalReason = event.terminalReason || task.terminalReason;
+        }
+        task.updatedAt = Math.max(task.updatedAt || 0, at);
+        task.taskKind = event.taskKind || task.taskKind;
+        task.toolUseId = event.toolUseId || task.toolUseId;
+        task.description = event.type === 'runner:task-progress'
+            ? task.description
+            : (event.description || task.description);
+        task.subagentType = event.subagentType || task.subagentType;
+        task.lastToolName = event.lastToolName || task.lastToolName;
+        task.totalTokens = event.usage?.totalTokens ?? event.totalTokens ?? task.totalTokens;
+        task.toolUses = event.usage?.toolUses ?? event.toolUses ?? task.toolUses;
+        task.durationMs = event.usage?.durationMs ?? event.durationMs ?? task.durationMs;
     }
-    catch { }
-    return map;
+    return Array.from(tasks.values())
+        .sort((a, b) => a.startedAt - b.startedAt)
+        .map(task => ({
+        role: 'system',
+        ts: task.startedAt,
+        uuid: `runner-task:${evolSessionId}:${task.taskId}`,
+        category: 'subtask',
+        blocks: [{ kind: 'subtask', ...task }],
+    }));
 }
 // ── 完整 transcript 解析（省略 tool 参数/chat send 检测等细节，保留费用计算）──
 const PRICING = {
@@ -425,16 +582,24 @@ function readTranscriptFile(file) {
     const shown = turns.length > 500 ? turns.slice(-500) : turns;
     return { turns: shown, totalTurns: turns.length, userMsgs, totalMsgs, counts, inputTokens: inTok, outputTokens: outTok, contextTokens, costUsd, model, gitBranch: branch, version, title, cwd };
 }
-function buildSnapshot(params) {
+async function buildSnapshot(params) {
     const projects = listProjects();
     const bindMap = buildBindMap();
     const project = resolveProject(params, projects);
     if (!project)
         return { baseagent: 'claude', projects: [], project: null, transcripts: [], turns: [], sessionId: null };
     const metas = listTranscripts(project.encoded);
+    const selfNames = await getAgentSelfNames();
     const transcripts = metas.map(m => {
         const bind = bindMap.get(m.id);
-        return { ...m, bound: !!bind, boundChannel: bind?.channelType ?? null, boundPeer: bind ? (bind.peerName || bind.channelId) : null, online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false };
+        return {
+            ...m,
+            sourceType: classifyTranscriptSource(bind, m.cliCandidate),
+            bound: !!bind,
+            boundChannel: bind?.channelType ?? null,
+            boundSelf: resolveSessionBindSelfName(bind, selfNames),
+            online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false,
+        };
     });
     const projList = projects.map(p => ({ encoded: p.encoded, label: p.label, cwd: p.cwd, count: p.count }));
     const sessionId = params.sessionId || null;
@@ -442,8 +607,13 @@ function buildSnapshot(params) {
         return { baseagent: 'claude', projects: projList, project: project.encoded, transcripts, turns: [], sessionId: null };
     const detail = readTranscriptFile(path.join(ccProjectsDir(), project.encoded, `${sessionId}.jsonl`));
     const bind = bindMap.get(sessionId);
-    const header = { sessionId, title: detail.title, model: detail.model, gitBranch: detail.gitBranch, version: detail.version, cwd: detail.cwd || project.cwd, totalTurns: detail.totalTurns, userMsgs: detail.userMsgs, totalMsgs: detail.totalMsgs, counts: detail.counts, inputTokens: detail.inputTokens, outputTokens: detail.outputTokens, contextTokens: detail.contextTokens, costUsd: detail.costUsd, bound: !!bind, boundChannel: bind?.channelType ?? null, boundPeer: bind ? (bind.peerName || bind.channelId) : null, online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false };
-    return { baseagent: 'claude', projects: projList, project: project.encoded, transcripts, turns: detail.turns, sessionId, header };
+    const taskTurns = bind?.evolSessionId ? readRunnerTaskTurns(resolvePaths().logs, bind.evolSessionId) : [];
+    const turns = detail.turns.concat(taskTurns).sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    const shownTurns = turns.length > 500 ? turns.slice(-500) : turns;
+    const counts = { ...detail.counts, subtask: taskTurns.length };
+    const transcript = metas.find(meta => meta.id === sessionId);
+    const header = { sessionId, title: detail.title, model: detail.model, gitBranch: detail.gitBranch, version: detail.version, cwd: detail.cwd || project.cwd, totalTurns: detail.totalTurns, userMsgs: detail.userMsgs, totalMsgs: detail.totalMsgs, counts, inputTokens: detail.inputTokens, outputTokens: detail.outputTokens, contextTokens: detail.contextTokens, costUsd: detail.costUsd, sourceType: classifyTranscriptSource(bind, transcript?.cliCandidate === true), bound: !!bind, boundChannel: bind?.channelType ?? null, boundSelf: resolveSessionBindSelfName(bind, selfNames), online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false };
+    return { baseagent: 'claude', projects: projList, project: project.encoded, transcripts, turns: shownTurns, sessionId, header };
 }
 export const sessionSource = {
     kind: 'session',
@@ -460,12 +630,12 @@ export const sessionSource = {
             return subscribeCodex(params, push);
         }
         const p = resolvePaths();
-        let projectWatcher = null, sessionWatcher = null, debounce = null;
-        const fire = () => { if (debounce)
-            clearTimeout(debounce); debounce = setTimeout(() => { try {
-            push(buildSnapshot(params));
-        }
-        catch { } }, 150); };
+        let projectWatcher = null, sessionWatcher = null, logWatcher = null, debounce = null;
+        const fire = () => {
+            if (debounce)
+                clearTimeout(debounce);
+            debounce = setTimeout(() => { void buildSnapshot(params).then(push).catch(() => { }); }, 150);
+        };
         const projects = listProjects();
         const project = resolveProject(params, projects);
         if (project) {
@@ -481,9 +651,17 @@ export const sessionSource = {
                 fire(); });
         }
         catch { }
+        if (params.sessionId) {
+            try {
+                logWatcher = fs.watch(p.logs, (_evt, filename) => { if (!filename || EVENT_LOG_RE.test(String(filename)))
+                    fire(); });
+            }
+            catch { }
+        }
         return () => { if (projectWatcher)
             projectWatcher.close(); if (sessionWatcher)
-            sessionWatcher.close(); if (debounce)
+            sessionWatcher.close(); if (logWatcher)
+            logWatcher.close(); if (debounce)
             clearTimeout(debounce); };
     },
 };