ec-web 0.0.1 → 0.0.3

package/dist/sources/session.js

@@ -0,0 +1,489 @@
+/**
+ * 会话数据源 — 多 baseagent 支持（Claude / Codex）。
+ *
+ * 根据 params.baseagent 参数路由到对应的实现：
+ * - claude: ~/.claude/projects/<encodedProject>/*.jsonl
+ * - codex: ~/.codex/state_*.sqlite + ~/.codex/sessions/YYYY/MM/DD/*.jsonl
+ *
+ * snapshot:
+ *   - 无 sessionId: 项目列表 + 选中项目的全部 transcript 概要
+ *   - 有 sessionId: 该 transcript 的结构化轮次 + 会话头统计
+ * subscribe: 监听对应目录的文件变化 + evolcore sessionsDir active.json 变化，防抖 150ms。
+ */
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths, ccProjectsDir } from '../paths.js';
+import { encodePath, scanChatDirs, readJsonFile } from '../fs-utils.js';
+import { snapshotCodex, subscribeCodex, setDebugLog as setCodexDebugLog } from './session-codex.js';
+let _dlog = null;
+export function setDebugLog(log) {
+    _dlog = log;
+    setCodexDebugLog(log); // 同步传递给 Codex 模块
+}
+function dlog(line) { if (_dlog)
+    try {
+        _dlog(line);
+    }
+    catch { } }
+const CACHE_VERSION = 4;
+const _metaCache = new Map();
+function cacheDir(encoded) {
+    const dataDir = resolvePaths().dataDir;
+    const currentRoot = path.join(dataDir, 'ecweb-cache');
+    const legacyRoot = path.join(dataDir, 'watch-web-cache');
+    if (!fs.existsSync(currentRoot) && fs.existsSync(legacyRoot)) {
+        try {
+            fs.renameSync(legacyRoot, currentRoot);
+        }
+        catch { }
+    }
+    return path.join(currentRoot, encoded);
+}
+function readDiskCache(encoded, id, mtime, size) {
+    try {
+        const rec = JSON.parse(fs.readFileSync(path.join(cacheDir(encoded), `${id}.json`), 'utf-8'));
+        if (rec.v === CACHE_VERSION && rec.mtime === mtime && rec.size === size && rec.meta)
+            return rec.meta;
+    }
+    catch { }
+    return null;
+}
+function writeDiskCache(encoded, id, mtime, size, meta) {
+    try {
+        const dir = cacheDir(encoded);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = path.join(dir, `${id}.json.tmp`);
+        fs.writeFileSync(tmp, JSON.stringify({ v: CACHE_VERSION, mtime, size, meta }));
+        fs.renameSync(tmp, path.join(dir, `${id}.json`));
+    }
+    catch { }
+}
+function pruneCacheFiles(encoded, validIds) {
+    const dir = cacheDir(encoded);
+    try {
+        for (const name of fs.readdirSync(dir)) {
+            const match = name.match(/^(.+)\.json(?:\.tmp)?$/);
+            if (!match || validIds.has(match[1]))
+                continue;
+            try {
+                fs.unlinkSync(path.join(dir, name));
+            }
+            catch { }
+        }
+        if (fs.readdirSync(dir).length === 0)
+            fs.rmdirSync(dir);
+    }
+    catch { }
+}
+function pruneCacheProjects(validProjects) {
+    const root = path.join(resolvePaths().dataDir, 'ecweb-cache');
+    try {
+        for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name === 'codex' || validProjects.has(entry.name))
+                continue;
+            try {
+                fs.rmSync(path.join(root, entry.name), { recursive: true, force: true });
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+function extractMessageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((x) => x?.type === 'text' && typeof x.text === 'string')
+        .map((x) => x.text)
+        .join('\n');
+}
+function isToolResultOnly(content) {
+    return Array.isArray(content) && content.length > 0 && content.every((x) => x?.type === 'tool_result');
+}
+function isPureUserText(text) {
+    const t = text.trimStart();
+    return !!t && !t.startsWith('<');
+}
+function isCountableUserMessage(event, sessionId) {
+    if (sessionId.startsWith('agent-') || event?.isSidechain)
+        return false;
+    const content = event?.message?.content;
+    if (isToolResultOnly(content))
+        return false;
+    return isPureUserText(extractMessageText(content));
+}
+function extractMeta(file, id, stat) {
+    let raw = '';
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch { }
+    let title = '', firstUser = '', gitBranch = '', version = '', userMsgs = 0, totalMsgs = 0;
+    for (const line of raw.split('\n')) {
+        if (!line)
+            continue;
+        const isAsst = line.indexOf('"type":"assistant"') !== -1;
+        const isUser = !isAsst && line.indexOf('"type":"user"') !== -1;
+        let o;
+        const needsParse = isUser || (!gitBranch || !version || !firstUser) && (line.indexOf('gitBranch') !== -1 || line.indexOf('"version"') !== -1 || line.indexOf('ai-title') !== -1);
+        if (needsParse) {
+            try {
+                o = JSON.parse(line);
+            }
+            catch {
+                o = null;
+            }
+        }
+        if (isAsst)
+            totalMsgs++;
+        else if (isUser) {
+            totalMsgs++;
+            if (o && isCountableUserMessage(o, id))
+                userMsgs++;
+        }
+        if ((!gitBranch || !version || !firstUser) && (line.indexOf('gitBranch') !== -1 || line.indexOf('"version"') !== -1 || line.indexOf('ai-title') !== -1 || (isUser && !firstUser))) {
+            if (!o) {
+                try {
+                    o = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!gitBranch && o.gitBranch)
+                gitBranch = o.gitBranch;
+            if (!version && o.version)
+                version = o.version;
+            if (o.type === 'ai-title' && o.title)
+                title = o.title;
+            if (!firstUser && o.type === 'user' && o.message) {
+                const t = extractMessageText(o.message.content);
+                if (isPureUserText(t))
+                    firstUser = t.replace(/\s+/g, ' ').trim().slice(0, 120);
+            }
+        }
+    }
+    return { id, title, firstUser, gitBranch, version, userMsgs, totalMsgs, sizeKB: Math.round(stat.size / 1024), lastActivity: stat.mtimeMs };
+}
+function listTranscripts(encoded) {
+    const dir = path.join(ccProjectsDir(), encoded);
+    let files;
+    try {
+        files = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+    }
+    catch {
+        return [];
+    }
+    pruneCacheFiles(encoded, new Set(files.map(file => file.replace(/\.jsonl$/, ''))));
+    const out = [];
+    let parsed = 0, hitMem = 0, hitDisk = 0;
+    for (const f of files) {
+        const file = path.join(dir, f);
+        const id = f.replace(/\.jsonl$/, '');
+        let stat;
+        try {
+            stat = fs.statSync(file);
+        }
+        catch {
+            continue;
+        }
+        const mtime = stat.mtimeMs;
+        const mem = _metaCache.get(file);
+        if (mem && mem.mtime === mtime) {
+            out.push(mem.meta);
+            hitMem++;
+            continue;
+        }
+        const disk = readDiskCache(encoded, id, mtime, stat.size);
+        if (disk) {
+            _metaCache.set(file, { mtime, meta: disk });
+            out.push(disk);
+            hitDisk++;
+            continue;
+        }
+        const meta = extractMeta(file, id, stat);
+        _metaCache.set(file, { mtime, meta });
+        writeDiskCache(encoded, id, mtime, stat.size, meta);
+        out.push(meta);
+        parsed++;
+    }
+    dlog(`[session] listTranscripts ${encoded.slice(-20)}: ${files.length} files (mem=${hitMem} disk=${hitDisk} parsed=${parsed})`);
+    out.sort((a, b) => b.lastActivity - a.lastActivity);
+    return out;
+}
+function listProjects() {
+    const base = ccProjectsDir();
+    let dirs;
+    try {
+        dirs = fs.readdirSync(base, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const d of dirs) {
+        if (!d.isDirectory())
+            continue;
+        const dirPath = path.join(base, d.name);
+        let files;
+        try {
+            files = fs.readdirSync(dirPath).filter(f => f.endsWith('.jsonl'));
+        }
+        catch {
+            continue;
+        }
+        if (!files.length)
+            continue;
+        let last = 0;
+        for (const f of files) {
+            try {
+                const m = fs.statSync(path.join(dirPath, f)).mtimeMs;
+                if (m > last)
+                    last = m;
+            }
+            catch { }
+        }
+        let cwd = d.name;
+        try {
+            const newest = files.map(f => ({ f, m: fs.statSync(path.join(dirPath, f)).mtimeMs })).sort((a, b) => b.m - a.m)[0];
+            if (newest) {
+                const fd = fs.openSync(path.join(dirPath, newest.f), 'r');
+                const buf = Buffer.alloc(16384);
+                const n = fs.readSync(fd, buf, 0, 16384, 0);
+                fs.closeSync(fd);
+                for (const line of buf.toString('utf-8', 0, n).split('\n')) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const o = JSON.parse(line);
+                        if (o.cwd) {
+                            cwd = o.cwd;
+                            break;
+                        }
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch { }
+        out.push({ encoded: d.name, cwd, label: cwd.replace(/[/\\]+$/, '').split(/[/\\]/).pop() || d.name, count: files.length, lastActivity: last });
+    }
+    pruneCacheProjects(new Set(out.map(project => project.encoded)));
+    out.sort((a, b) => b.lastActivity - a.lastActivity);
+    return out;
+}
+function resolveProject(params, projects) {
+    if (params.project) {
+        const found = projects.find(p => p.encoded === params.project);
+        if (found) {
+            dlog(`[session] resolveProject: matched param project=${params.project.slice(-24)}`);
+            return found;
+        }
+        dlog(`[session] resolveProject: param project=${params.project.slice(-24)} NOT in ${projects.length} projects → falling back`);
+    }
+    const curEncoded = encodePath(process.cwd());
+    const cur = projects.find(p => p.encoded === curEncoded);
+    if (cur) {
+        dlog(`[session] resolveProject: default to cwd project=${curEncoded.slice(-24)}`);
+        return cur;
+    }
+    dlog(`[session] resolveProject: cwd project=${curEncoded.slice(-24)} not found → using first=${projects[0]?.encoded.slice(-24)}`);
+    return projects[0] || null;
+}
+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;
+}
+// ── 完整 transcript 解析（省略 tool 参数/chat send 检测等细节，保留费用计算）──
+const PRICING = {
+    'claude-opus-4-8': [5, 6.25, 0.5, 25], 'claude-opus-4': [5, 6.25, 0.5, 25],
+    'claude-sonnet-4-6': [3, 3.75, 0.3, 15], 'claude-sonnet-4': [3, 3.75, 0.3, 15],
+    'claude-haiku-4-5-20251001': [0.8, 1, 0.08, 4],
+};
+function pricingFor(model) {
+    for (const key of Object.keys(PRICING))
+        if (model.startsWith(key))
+            return PRICING[key];
+    if (model.includes('sonnet'))
+        return PRICING['claude-sonnet-4-6'];
+    if (model.includes('haiku'))
+        return PRICING['claude-haiku-4-5-20251001'];
+    return PRICING['claude-opus-4-8'];
+}
+function readTranscriptFile(file) {
+    const empty = { turns: [], totalTurns: 0, userMsgs: 0, totalMsgs: 0, counts: { userInput: 0, modelOutput: 0, toolCall: 0, toolResult: 0, msgSend: 0 }, inputTokens: 0, outputTokens: 0, contextTokens: 0, costUsd: 0, model: '', gitBranch: '', version: '', title: '', cwd: '' };
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return empty;
+    }
+    const turns = [];
+    const counts = { userInput: 0, modelOutput: 0, toolCall: 0, toolResult: 0, msgSend: 0 };
+    let inTok = 0, outTok = 0, model = '', branch = '', version = '', title = '', cwd = '', userMsgs = 0, totalMsgs = 0, contextTokens = 0, costUsd = 0, lastUsageKey = '';
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        const isAsst = line.indexOf('"type":"assistant"') !== -1;
+        const isUser = !isAsst && line.indexOf('"type":"user"') !== -1;
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (isAsst)
+            totalMsgs++;
+        else if (isUser) {
+            totalMsgs++;
+            if (isCountableUserMessage(o, path.basename(file, '.jsonl')))
+                userMsgs++;
+        }
+        if (!branch && o.gitBranch)
+            branch = o.gitBranch;
+        if (!version && o.version)
+            version = o.version;
+        if (!cwd && o.cwd)
+            cwd = o.cwd;
+        if (o.type === 'ai-title' && o.title)
+            title = o.title;
+        if (o.type === 'assistant' && o.message?.usage) {
+            const u = o.message.usage;
+            const inp = u.input_tokens || 0, cr = u.cache_read_input_tokens || 0, cc = u.cache_creation_input_tokens || 0, out = u.output_tokens || 0;
+            contextTokens = inp + cr + cc;
+            const key = `${inp},${cr},${cc},${out}`;
+            if (key !== lastUsageKey) {
+                lastUsageKey = key;
+                const [pi, pcw, pcr, po] = pricingFor(model || o.message.model);
+                costUsd += (inp * pi + cc * pcw + cr * pcr + out * po) / 1_000_000;
+            }
+            if (u.input_tokens)
+                inTok += u.input_tokens;
+            if (u.output_tokens)
+                outTok += u.output_tokens;
+            if (o.message.model)
+                model = o.message.model;
+        }
+        if (o.type === 'user' || o.type === 'assistant') {
+            const content = o.message?.content;
+            const arr = typeof content === 'string' ? [{ type: 'text', text: content }] : (Array.isArray(content) ? content : []);
+            const blocks = [];
+            let hasToolUse = false, hasToolResult = false;
+            for (const item of arr) {
+                if (!item || typeof item !== 'object')
+                    continue;
+                if (item.type === 'text' && item.text) {
+                    blocks.push({ kind: 'text', text: item.text });
+                }
+                else if (item.type === 'thinking' && item.thinking) {
+                    blocks.push({ kind: 'thinking', text: item.thinking });
+                }
+                else if (item.type === 'tool_use') {
+                    const inputStr = item.input ? JSON.stringify(item.input, null, 2) : '';
+                    blocks.push({ kind: 'tool_use', name: item.name || '', input: item.input || {}, inputStr });
+                    hasToolUse = true;
+                }
+                else if (item.type === 'tool_result') {
+                    const c = item.content;
+                    const text = typeof c === 'string' ? c : (Array.isArray(c) ? c.filter((x) => x?.type === 'text').map((x) => x.text).join('\n') : '');
+                    blocks.push({ kind: 'tool_result', text, isError: !!item.is_error });
+                    hasToolResult = true;
+                }
+            }
+            let category;
+            if (o.type === 'user') {
+                category = hasToolResult ? 'tool_result' : 'user_input';
+            }
+            else {
+                category = hasToolUse ? 'tool_call' : 'model_output';
+            }
+            counts[category === 'user_input' ? 'userInput' : category === 'model_output' ? 'modelOutput' : category === 'tool_call' ? 'toolCall' : 'toolResult']++;
+            turns.push({ role: o.type, ts: o.timestamp ? Date.parse(o.timestamp) : 0, uuid: o.uuid, category, blocks });
+        }
+    }
+    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) {
+    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 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 };
+    });
+    const projList = projects.map(p => ({ encoded: p.encoded, label: p.label, cwd: p.cwd, count: p.count }));
+    const sessionId = params.sessionId || null;
+    if (!sessionId)
+        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 };
+}
+export const sessionSource = {
+    kind: 'session',
+    async snapshot(params = {}) {
+        const baseagent = params.baseagent || 'claude';
+        if (baseagent === 'codex') {
+            return snapshotCodex(params);
+        }
+        return buildSnapshot(params);
+    },
+    subscribe(params, push) {
+        const baseagent = params.baseagent || 'claude';
+        if (baseagent === 'codex') {
+            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); };
+        const projects = listProjects();
+        const project = resolveProject(params, projects);
+        if (project) {
+            const dir = path.join(ccProjectsDir(), project.encoded);
+            try {
+                projectWatcher = fs.watch(dir, (_evt, filename) => { if (filename && String(filename).endsWith('.jsonl'))
+                    fire(); });
+            }
+            catch { }
+        }
+        try {
+            sessionWatcher = fs.watch(p.sessionsDir, { recursive: true }, (_evt, filename) => { if (filename && String(filename).endsWith('active.json'))
+                fire(); });
+        }
+        catch { }
+        return () => { if (projectWatcher)
+            projectWatcher.close(); if (sessionWatcher)
+            sessionWatcher.close(); if (debounce)
+            clearTimeout(debounce); };
+    },
+};