ec-web 0.0.4 → 0.0.6

package/dist/sources/session-codex.js

@@ -12,7 +12,10 @@ import path from 'path';
 import os from 'os';
 import { createRequire } from 'module';
 import { resolvePaths } from '../paths.js';
-import { encodePath, scanChatDirs, readJsonFile } from '../fs-utils.js';
+import { encodePath } from '../fs-utils.js';
+import { getAgentSelfNames } from './msg.js';
+import { parseTranscriptResultKey, previewLargeToolResults, windowTranscriptTurns } from './transcript-window.js';
+import { buildSessionBindMap, classifyTranscriptSource, isEvolcoreRoutedMessage, isSyntheticCliPrompt, resolveSessionBindSelfName, } from './session-origin.js';
 const requireFromHere = createRequire(import.meta.url);
 let _dlog = null;
 export function setDebugLog(log) { _dlog = log; }
@@ -107,8 +110,10 @@ function listProjects() {
     }
 }
 // ── 会话列表 ──
-const CACHE_VERSION = 1;
+const CACHE_VERSION = 2;
 const _metaCache = new Map();
+const _detailCache = new Map();
+const MAX_DETAIL_CACHE_ENTRIES = 6;
 function cacheDir(encoded) {
     const dataDir = resolvePaths().dataDir;
     return path.join(dataDir, 'ecweb-cache', 'codex', encoded);
@@ -132,6 +137,16 @@ function writeDiskCache(encoded, id, mtime, size, meta) {
     }
     catch { }
 }
+function cacheTranscriptDetail(file, mtime, size, detail) {
+    _detailCache.delete(file);
+    _detailCache.set(file, { mtime, size, detail });
+    while (_detailCache.size > MAX_DETAIL_CACHE_ENTRIES) {
+        const oldest = _detailCache.keys().next().value;
+        if (!oldest)
+            break;
+        _detailCache.delete(oldest);
+    }
+}
 function pruneCacheFiles(encoded, validIds) {
     const dir = cacheDir(encoded);
     try {
@@ -170,6 +185,7 @@ function extractMetaFromRollout(file, id) {
     }
     catch { }
     let title = '', firstUser = '', gitBranch = '', version = '', userMsgs = 0, totalMsgs = 0;
+    let hasRealUserInput = false;
     const lines = raw.split('\n');
     for (const line of lines) {
         if (!line.trim())
@@ -187,6 +203,8 @@ function extractMetaFromRollout(file, id) {
             if (event.type === 'event_msg' && event.payload?.type === 'user_message' && event.payload.message) {
                 totalMsgs++;
                 userMsgs++;
+                if (!isSyntheticCliPrompt(event.payload.message, 'codex'))
+                    hasRealUserInput = true;
                 if (!firstUser) {
                     const text = event.payload.message.trim().replace(/\s+/g, ' ');
                     firstUser = text.substring(0, 120);
@@ -216,15 +234,34 @@ function extractMetaFromRollout(file, id) {
         totalMsgs,
         sizeKB: Math.round(stat.size / 1024),
         lastActivity: stat.mtimeMs,
+        hasRealUserInput,
+        backendSource: '',
+        threadSource: '',
+        evolcoreRouted: false,
     };
 }
+function withThreadSource(meta, row) {
+    return {
+        ...meta,
+        backendSource: typeof row.source === 'string' ? row.source : '',
+        threadSource: typeof row.thread_source === 'string' ? row.thread_source : '',
+        evolcoreRouted: isEvolcoreRoutedMessage(row.first_user_message),
+    };
+}
+function isCodexCliCandidate(meta) {
+    if (meta.threadSource === 'subagent')
+        return false;
+    if (meta.backendSource !== 'cli' && meta.backendSource !== 'vscode')
+        return false;
+    return meta.hasRealUserInput && !meta.evolcoreRouted;
+}
 function listTranscripts(encoded, cwd) {
     const db = getDb();
     if (!db)
         return [];
     try {
         const rows = db.prepare(`
-      SELECT id, title, first_user_message, updated_at, rollout_path
+      SELECT id, title, first_user_message, updated_at, rollout_path, source, thread_source
       FROM threads
       WHERE cwd = ? AND archived = 0
       ORDER BY updated_at DESC
@@ -248,6 +285,10 @@ function listTranscripts(encoded, cwd) {
                     totalMsgs: 0,
                     sizeKB: 0,
                     lastActivity: (row.updated_at || 0) * 1000,
+                    hasRealUserInput: !!firstUser && !isSyntheticCliPrompt(firstUser, 'codex'),
+                    backendSource: typeof row.source === 'string' ? row.source : '',
+                    threadSource: typeof row.thread_source === 'string' ? row.thread_source : '',
+                    evolcoreRouted: isEvolcoreRoutedMessage(row.first_user_message),
                 });
                 continue;
             }
@@ -261,21 +302,21 @@ function listTranscripts(encoded, cwd) {
             const mtime = stat.mtimeMs;
             const mem = _metaCache.get(rolloutPath);
             if (mem && mem.mtime === mtime) {
-                out.push(mem.meta);
+                out.push(withThreadSource(mem.meta, row));
                 hitMem++;
                 continue;
             }
             const disk = readDiskCache(encoded, id, mtime, stat.size);
             if (disk) {
                 _metaCache.set(rolloutPath, { mtime, meta: disk });
-                out.push(disk);
+                out.push(withThreadSource(disk, row));
                 hitDisk++;
                 continue;
             }
             const meta = extractMetaFromRollout(rolloutPath, id);
             _metaCache.set(rolloutPath, { mtime, meta });
             writeDiskCache(encoded, id, mtime, stat.size, meta);
-            out.push(meta);
+            out.push(withThreadSource(meta, row));
             parsed++;
         }
         dlog(`[codex] listTranscripts ${cwd.slice(-20)}: ${rows.length} threads (mem=${hitMem} disk=${hitDisk} parsed=${parsed})`);
@@ -288,25 +329,7 @@ function listTranscripts(encoded, cwd) {
 }
 // ── 绑定关系 ──
 export function buildBindMap() {
-    const map = new Map();
-    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,
-            });
-        }
-    }
-    catch { }
-    return map;
+    return buildSessionBindMap();
 }
 // ── 项目解析 ──
 function resolveProject(params, projects) {
@@ -452,7 +475,7 @@ export function parseCodexToolEvent(event) {
     }
     return null;
 }
-function readTranscriptFile(threadId, cwd) {
+function readTranscriptFile(threadId, cwd, readStats) {
     const empty = {
         turns: [],
         totalTurns: 0,
@@ -485,6 +508,21 @@ function readTranscriptFile(threadId, cwd) {
     }
     if (!fs.existsSync(rolloutPath))
         return empty;
+    let stat;
+    try {
+        stat = fs.statSync(rolloutPath);
+    }
+    catch {
+        return empty;
+    }
+    const cached = _detailCache.get(rolloutPath);
+    if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
+        _detailCache.delete(rolloutPath);
+        _detailCache.set(rolloutPath, cached);
+        if (readStats)
+            readStats.detailCacheHit = true;
+        return { ...cached.detail, title: empty.title || cached.detail.title, cwd };
+    }
     let raw;
     try {
         raw = fs.readFileSync(rolloutPath, 'utf-8');
@@ -592,9 +630,8 @@ function readTranscriptFile(threadId, cwd) {
             }
         }
     }
-    const shown = turns.length > 500 ? turns.slice(-500) : turns;
-    return {
-        turns: shown,
+    const detail = {
+        turns,
         totalTurns: turns.length,
         userMsgs,
         totalMsgs,
@@ -609,13 +646,41 @@ function readTranscriptFile(threadId, cwd) {
         title: empty.title,
         cwd,
     };
+    cacheTranscriptDetail(rolloutPath, stat.mtimeMs, stat.size, detail);
+    return detail;
+}
+export function readCodexSessionResult(params) {
+    const projects = listProjects();
+    const project = resolveProject(params, projects);
+    const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
+    const key = parseTranscriptResultKey(params.resultKey);
+    if (!project || !sessionId || !key || !/^[A-Za-z0-9-]+$/.test(sessionId))
+        return null;
+    const detail = readTranscriptFile(sessionId, project.cwd);
+    const block = detail.turns[key[0]]?.blocks?.[key[1]];
+    return block?.kind === 'tool_result' && typeof block.text === 'string' ? block.text : null;
 }
 // ── Snapshot ──
-function buildSnapshot(params) {
+async function buildSnapshot(params) {
+    const startedAt = Date.now();
+    const metrics = {
+        baseagent: 'codex',
+        projectMs: 0,
+        bindingsMs: 0,
+        transcriptListMs: 0,
+        detailMs: 0,
+        totalMs: 0,
+        detailCacheHit: false,
+    };
+    const projectStartedAt = Date.now();
     const projects = listProjects();
+    metrics.projectMs = Date.now() - projectStartedAt;
+    const bindingsStartedAt = Date.now();
     const bindMap = buildBindMap();
+    metrics.bindingsMs = Date.now() - bindingsStartedAt;
     const project = resolveProject(params, projects);
     if (!project) {
+        metrics.totalMs = Date.now() - startedAt;
         return {
             baseagent: 'codex',
             projects: [],
@@ -623,16 +688,22 @@ function buildSnapshot(params) {
             transcripts: [],
             turns: [],
             sessionId: null,
+            metrics,
         };
     }
+    const transcriptListStartedAt = Date.now();
     const metas = listTranscripts(project.encoded, project.cwd);
+    metrics.transcriptListMs = Date.now() - transcriptListStartedAt;
+    const selfNames = await getAgentSelfNames();
     const transcripts = metas.map(m => {
         const bind = bindMap.get(m.id);
+        metrics.totalMs = Date.now() - startedAt;
         return {
             ...m,
+            sourceType: classifyTranscriptSource(bind, isCodexCliCandidate(m)),
             bound: !!bind,
             boundChannel: bind?.channelType ?? null,
-            boundPeer: bind ? (bind.peerName || bind.channelId) : null,
+            boundSelf: resolveSessionBindSelfName(bind, selfNames),
             online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false,
         };
     });
@@ -651,10 +722,15 @@ function buildSnapshot(params) {
             transcripts,
             turns: [],
             sessionId: null,
+            metrics,
         };
     }
-    const detail = readTranscriptFile(sessionId, project.cwd);
+    const detailStartedAt = Date.now();
+    const detail = readTranscriptFile(sessionId, project.cwd, metrics);
+    metrics.detailMs = Date.now() - detailStartedAt;
+    const page = windowTranscriptTurns(detail.turns, params.turnLimit, params.turnBefore);
     const bind = bindMap.get(sessionId);
+    const transcript = metas.find(meta => meta.id === sessionId);
     const header = {
         sessionId,
         title: detail.title,
@@ -670,19 +746,23 @@ function buildSnapshot(params) {
         outputTokens: detail.outputTokens,
         contextTokens: detail.contextTokens,
         costUsd: detail.costUsd,
+        sourceType: classifyTranscriptSource(bind, transcript ? isCodexCliCandidate(transcript) : false),
         bound: !!bind,
         boundChannel: bind?.channelType ?? null,
-        boundPeer: bind ? (bind.peerName || bind.channelId) : null,
+        boundSelf: resolveSessionBindSelfName(bind, selfNames),
         online: bind ? (Date.now() - bind.updatedAt < 5 * 60 * 1000) : false,
     };
+    metrics.totalMs = Date.now() - startedAt;
     return {
         baseagent: 'codex',
         projects: projList,
         project: project.encoded,
         transcripts,
-        turns: detail.turns,
+        turns: previewLargeToolResults(page.turns, page.turnPage.start),
+        turnPage: page.turnPage,
         sessionId,
         header,
+        metrics,
     };
 }
 // ── Export ──
@@ -699,7 +779,7 @@ export function subscribeCodex(params, push) {
             clearTimeout(debounce);
         debounce = setTimeout(() => {
             try {
-                push(buildSnapshot(params));
+                void buildSnapshot(params).then(push).catch(() => { });
             }
             catch { }
         }, 150);

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';
+}