@myagentroam/node 0.1.0

package/dist/native-session-history.js

@@ -0,0 +1,647 @@
+import { createHash } from 'node:crypto';
+import { open, readdir, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+const DISCOVERY_READ_BYTES = 128 * 1024;
+const TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
+const CONTEXT_USAGE_READ_BYTES = 256 * 1024;
+const TASK_ACTIVITY_READ_BYTES = 32 * 1024 * 1024;
+const transcriptIndex = new Map();
+/** Reads the latest durable Codex task lifecycle event without exposing it. */
+export async function readCodexNativeTaskActivity(workspacePath, externalSessionId, now = Date.now()) {
+    const wanted = canonical(workspacePath);
+    let path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
+    if (path === undefined) {
+        await discoverNativeSessions('codex', workspacePath);
+        path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
+    }
+    if (path === undefined)
+        return undefined;
+    let content;
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            const start = Math.max(0, metadata.size - TASK_ACTIVITY_READ_BYTES);
+            const buffer = Buffer.alloc(metadata.size - start);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+            content = buffer.subarray(0, bytesRead).toString('utf8');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+    let latest;
+    for (const line of content.split('\n')) {
+        try {
+            const value = JSON.parse(line);
+            const payload = value.type === 'event_msg' && isRecord(value.payload) ? value.payload : undefined;
+            if (payload?.type !== 'task_started' && payload?.type !== 'task_complete')
+                continue;
+            const seconds = payload.type === 'task_started' ? payload.started_at : payload.completed_at;
+            const at = typeof seconds === 'number' ? seconds * 1000 : 0;
+            latest = { state: payload.type === 'task_started' ? 'ACTIVE' : 'IDLE', at };
+        }
+        catch {
+            // 单条损坏的 JSONL 记录不影响后续活动状态记录。
+        }
+    }
+    if (latest === undefined)
+        return undefined;
+    return latest.state === 'ACTIVE' && now - latest.at > 60 * 60_000 ? 'STALE' : latest.state;
+}
+/**
+ * Read-only adapter for the supported vendor JSONL stores.  It requires an
+ * explicit cwd on the record and returns normalized visible messages and tool
+ * cards; no raw vendor events or hidden reasoning are exposed to the Workbench.
+ */
+export async function discoverNativeSessions(runner, workspacePath) {
+    const wanted = canonical(workspacePath);
+    return (await discoverAllNativeSessions(runner)).filter((value) => canonical(value.cwd) === wanted);
+}
+/**
+ * Reads every supported transcript header before applying a Workspace filter.
+ * The caller owns in-process caching; a fixed file-count cutoff would silently
+ * hide older sessions from a project with a large global history.
+ */
+export async function discoverAllNativeSessions(runner) {
+    const found = new Map();
+    const files = await listJsonl(transcriptRoot(runner));
+    const parsedFiles = await readDiscoveryHeaders(files, runner);
+    for (const [index, parsed] of parsedFiles.entries()) {
+        // Discovery only needs a session identity, cwd and an optional early
+        // title. Loading entire JSONL files here made opening a Workspace depend
+        // on the total history of every other project on the Node.
+        if (parsed === undefined)
+            continue;
+        const cwd = canonical(parsed.cwd);
+        transcriptIndex.set(indexKey(runner, cwd, parsed.externalSessionId), files[index]);
+        found.set(`${cwd}\u0000${parsed.externalSessionId}`, parsed);
+    }
+    return [...found.values()];
+}
+async function readDiscoveryHeaders(files, runner) {
+    const values = Array.from({ length: files.length });
+    let next = 0;
+    const worker = async () => {
+        while (true) {
+            const index = next;
+            next += 1;
+            if (index >= files.length)
+                return;
+            values[index] = await readTranscript(files[index], runner, DISCOVERY_READ_BYTES);
+        }
+    };
+    // Header reads are independent. Bounded concurrency avoids serial startup
+    // delays without opening an unbounded number of descriptors on large homes.
+    await Promise.all(Array.from({ length: Math.min(32, files.length) }, worker));
+    return values;
+}
+/** Reads one already-discovered external session again to follow appended JSONL records. */
+export async function readNativeSession(runner, workspacePath, externalSessionId) {
+    const wanted = canonical(workspacePath);
+    const path = transcriptIndex.get(indexKey(runner, wanted, externalSessionId));
+    if (path === undefined)
+        return undefined;
+    const parsed = await readTranscript(path, runner, TRANSCRIPT_READ_BYTES);
+    if (parsed === undefined ||
+        parsed.externalSessionId !== externalSessionId ||
+        canonical(parsed.cwd) !== wanted) {
+        transcriptIndex.delete(indexKey(runner, wanted, externalSessionId));
+        return undefined;
+    }
+    return parsed;
+}
+/**
+ * Codex records the most recent prompt token count alongside the model context
+ * window in `event_msg/token_count`.  Read only the tail of an already
+ * discovered transcript: the count is append-only and never needs a costly
+ * full-history scan.
+ */
+export async function readCodexNativeContextUsage(workspacePath, externalSessionId) {
+    const wanted = canonical(workspacePath);
+    let path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
+    if (path === undefined) {
+        await discoverNativeSessions('codex', workspacePath);
+        path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
+    }
+    if (path === undefined)
+        return undefined;
+    let content;
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            const start = Math.max(0, metadata.size - CONTEXT_USAGE_READ_BYTES);
+            const buffer = Buffer.alloc(metadata.size - start);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+            content = buffer.subarray(0, bytesRead).toString('utf8');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+    let usage;
+    for (const line of content.split('\n')) {
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const next = codexContextUsage(record);
+        if (next !== undefined)
+            usage = next;
+    }
+    return usage;
+}
+/**
+ * Permanently removes exactly one previously discovered transcript. The
+ * caller supplies no path: the in-process discovery index resolves it, then
+ * the record is re-read and its runner/cwd/native ID are checked again before
+ * unlinking. This keeps a destructive operation bounded to one known file.
+ */
+export async function removeNativeSession(runner, workspacePath, externalSessionId) {
+    const wanted = canonical(workspacePath);
+    let path = transcriptIndex.get(indexKey(runner, wanted, externalSessionId));
+    if (path === undefined) {
+        await discoverNativeSessions(runner, workspacePath);
+        path = transcriptIndex.get(indexKey(runner, wanted, externalSessionId));
+    }
+    if (path === undefined)
+        throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+    const parsed = await readTranscript(path, runner, TRANSCRIPT_READ_BYTES);
+    if (parsed === undefined ||
+        parsed.externalSessionId !== externalSessionId ||
+        canonical(parsed.cwd) !== wanted) {
+        transcriptIndex.delete(indexKey(runner, wanted, externalSessionId));
+        throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+    }
+    try {
+        await unlink(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        throw error;
+    }
+    transcriptIndex.delete(indexKey(runner, wanted, externalSessionId));
+}
+function transcriptRoot(runner) {
+    return runner === 'codex'
+        ? join(homedir(), '.codex', 'sessions')
+        : join(homedir(), '.claude', 'projects');
+}
+async function listJsonl(directory) {
+    const files = [];
+    const walk = async (current) => {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const path = join(current, entry.name);
+            if (entry.isDirectory())
+                await walk(path);
+            else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+                files.push(path);
+        }
+    };
+    await walk(directory);
+    return files;
+}
+async function readTranscript(path, runner, byteLimit) {
+    let content;
+    let truncated = false;
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            const headSize = Math.min(byteLimit, metadata.size);
+            const head = Buffer.alloc(headSize);
+            const { bytesRead: headBytesRead } = await handle.read(head, 0, head.length, 0);
+            if (headSize === metadata.size) {
+                content = head.subarray(0, headBytesRead).toString('utf8');
+            }
+            else {
+                // Discovery needs identity from the header and genuine recency from
+                // the latest visible records.  Keep both bounded instead of falling
+                // back to mtime, whose changes do not necessarily mean a new chat.
+                const tailSize = Math.min(byteLimit, metadata.size - headSize);
+                truncated = headSize + tailSize < metadata.size;
+                const tail = Buffer.alloc(tailSize);
+                const { bytesRead: tailBytesRead } = await handle.read(tail, 0, tail.length, metadata.size - tailSize);
+                content = `${head.subarray(0, headBytesRead).toString('utf8')}\n${tail
+                    .subarray(0, tailBytesRead)
+                    .toString('utf8')}`;
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+    let cwd;
+    let id;
+    const items = [];
+    const toolIndexes = new Map();
+    const pendingToolResults = new Map();
+    const metaRecordIds = new Set();
+    for (const line of content.split('\n')) {
+        if (line.length === 0)
+            continue;
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(value))
+            continue;
+        cwd ??= workspacePath(value);
+        id ??= sessionId(value);
+        const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
+        const parentId = typeof value['parentUuid'] === 'string' ? value['parentUuid'] : undefined;
+        if (value['isMeta'] === true && recordId !== undefined)
+            metaRecordIds.add(recordId);
+        if (isHiddenTranscriptRecord(value) ||
+            (parentId !== undefined && metaRecordIds.has(parentId))) {
+            continue;
+        }
+        for (const item of transcriptItems(value)) {
+            if (item.kind === 'tool_result') {
+                const toolIndex = toolIndexes.get(item.toolUseId);
+                if (toolIndex === undefined)
+                    pendingToolResults.set(item.toolUseId, item);
+                else
+                    items[toolIndex] = withToolResult(items[toolIndex], item);
+                continue;
+            }
+            if (item.kind === 'tool_call') {
+                const pending = pendingToolResults.get(item.toolUseId);
+                const completed = pending === undefined ? item : withToolResult(item, pending);
+                pendingToolResults.delete(item.toolUseId);
+                toolIndexes.set(item.toolUseId, items.length);
+                items.push(completed);
+                continue;
+            }
+            items.push(item);
+        }
+    }
+    for (const result of pendingToolResults.values())
+        items.push({
+            kind: 'tool_call',
+            toolUseId: result.toolUseId,
+            toolName: '工具',
+            input: null,
+            inputSummary: null,
+            inputTruncated: false,
+            outputSummary: result.output,
+            outputTruncated: result.truncated,
+            failed: result.failed,
+            createdAt: result.createdAt
+        });
+    if (cwd === undefined)
+        return undefined;
+    const title = items.find((item) => item.kind === 'message' && item.role === 'USER')?.text;
+    return {
+        runner,
+        externalSessionId: id ?? basename(path, '.jsonl'),
+        cwd,
+        ...(title === undefined ? {} : { title: compact(title) }),
+        digest: createHash('sha256').update(content).digest('hex'),
+        items,
+        lastActivityAt: Math.max(0, ...items.map((item) => item.createdAt ?? 0)),
+        truncated
+    };
+}
+function workspacePath(record) {
+    return (firstString(record, ['cwd', 'working_directory', 'workspacePath']) ??
+        nestedString(record, ['payload', 'cwd']) ??
+        nestedString(record, ['message', 'cwd']));
+}
+function sessionId(record) {
+    // A Codex sub-agent transcript records its own thread in `payload.id`, but
+    // retains the parent thread in `payload.session_id`.  Treating the latter
+    // as this file's identity makes the child file overwrite the parent thread
+    // in the discovery index, which then shows unrelated messages for the
+    // parent Chat.
+    if (record['type'] === 'session_meta') {
+        const transcriptId = nestedString(record, ['payload', 'id']);
+        if (transcriptId !== undefined)
+            return transcriptId;
+    }
+    return (firstString(record, ['sessionId', 'session_id', 'thread_id', 'conversationId']) ??
+        nestedString(record, ['payload', 'id']) ??
+        nestedString(record, ['payload', 'session_id']) ??
+        nestedString(record, ['payload', 'thread_id']));
+}
+function codexContextUsage(value) {
+    if (!isRecord(value) || value.type !== 'event_msg' || !isRecord(value.payload))
+        return undefined;
+    const payload = value.payload;
+    if (payload.type !== 'token_count' || !isRecord(payload.info))
+        return undefined;
+    const promptUsage = payload.info.last_token_usage;
+    const maxTokens = payload.info.model_context_window;
+    if (!isRecord(promptUsage) ||
+        typeof promptUsage.input_tokens !== 'number' ||
+        typeof maxTokens !== 'number')
+        return undefined;
+    if (!Number.isFinite(promptUsage.input_tokens) ||
+        !Number.isInteger(promptUsage.input_tokens) ||
+        !Number.isFinite(maxTokens) ||
+        !Number.isInteger(maxTokens) ||
+        maxTokens <= 0 ||
+        promptUsage.input_tokens < 0)
+        return undefined;
+    return { usedTokens: promptUsage.input_tokens, maxTokens };
+}
+function transcriptItems(record) {
+    const createdAt = timestampOf(record);
+    const results = [...toolResultsOf(record, createdAt), ...codexToolResultsOf(record, createdAt)];
+    if (results.length > 0)
+        return results;
+    const values = [
+        ...toolUsesOf(record, createdAt),
+        ...codexToolUsesOf(record, createdAt)
+    ];
+    const role = roleOf(record);
+    if (role === undefined)
+        return values;
+    const text = messageText(textOf(record) ?? '');
+    if (text.length === 0)
+        return values;
+    // Codex transcripts can contain the host's injected AGENTS.md and runtime
+    // context as a `user` item before the first actual prompt.  It is neither a
+    // user-visible chat turn nor a meaningful session title.
+    if (role === 'USER' && isInjectedContextPrompt(text))
+        return values;
+    values.unshift({ kind: 'message', role, text, createdAt });
+    return values;
+}
+function toolUsesOf(record, createdAt) {
+    return contentBlocks(record).flatMap((block) => {
+        if (block['type'] !== 'tool_use' ||
+            typeof block['id'] !== 'string' ||
+            typeof block['name'] !== 'string')
+            return [];
+        const input = block['input'];
+        const summary = compactValue(input, 10_000);
+        return [
+            {
+                kind: 'tool_call',
+                toolUseId: block['id'],
+                toolName: compact(block['name']).slice(0, 128),
+                input,
+                inputSummary: summary.text || null,
+                inputTruncated: summary.truncated,
+                outputSummary: null,
+                outputTruncated: false,
+                failed: false,
+                createdAt
+            }
+        ];
+    });
+}
+function toolResultsOf(record, createdAt) {
+    return contentBlocks(record).flatMap((block) => {
+        if (block['type'] !== 'tool_result' || typeof block['tool_use_id'] !== 'string')
+            return [];
+        const output = compactValue(block['content'], 10_000);
+        return [
+            {
+                kind: 'tool_result',
+                toolUseId: block['tool_use_id'],
+                output: output.text,
+                failed: block['is_error'] === true,
+                truncated: output.truncated,
+                createdAt
+            }
+        ];
+    });
+}
+/**
+ * Codex persists custom and standard function tools as paired `response_item`
+ * records. Their record IDs differ, while `call_id` is the stable identifier
+ * shared by invocation and result. Normalize on that key so JSONL fallback
+ * history has the same single-card shape as live events.
+ */
+function codexToolUsesOf(record, createdAt) {
+    const payload = codexToolPayload(record);
+    if (payload?.['type'] !== 'custom_tool_call' && payload?.['type'] !== 'function_call')
+        return [];
+    const toolUseId = firstString(payload, ['call_id', 'id']);
+    const toolName = firstString(payload, ['name', 'tool']);
+    if (toolUseId === undefined || toolName === undefined)
+        return [];
+    const input = payload['input'] ?? payload['arguments'];
+    const summary = compactValue(input, 10_000);
+    return [
+        {
+            kind: 'tool_call',
+            toolUseId,
+            toolName: compact(toolName).slice(0, 128),
+            input,
+            inputSummary: summary.text || null,
+            inputTruncated: summary.truncated,
+            outputSummary: null,
+            outputTruncated: false,
+            failed: false,
+            createdAt
+        }
+    ];
+}
+function codexToolResultsOf(record, createdAt) {
+    const payload = codexToolPayload(record);
+    if (payload?.['type'] !== 'custom_tool_call_output' &&
+        payload?.['type'] !== 'function_call_output')
+        return [];
+    const toolUseId = firstString(payload, ['call_id', 'id']);
+    if (toolUseId === undefined)
+        return [];
+    const output = compactValue(codexToolOutput(payload['output'] ?? payload['contentItems']), 10_000);
+    return [
+        {
+            kind: 'tool_result',
+            toolUseId,
+            output: output.text,
+            failed: payload['status'] === 'failed' || payload['error'] !== undefined,
+            truncated: output.truncated,
+            createdAt
+        }
+    ];
+}
+function codexToolPayload(record) {
+    return record['type'] === 'response_item' && isRecord(record['payload'])
+        ? record['payload']
+        : undefined;
+}
+/** Extract Codex output text blocks instead of rendering their JSON envelopes. */
+function codexToolOutput(value) {
+    if (!Array.isArray(value))
+        return value;
+    const text = value.flatMap((block) => {
+        if (typeof block === 'string')
+            return [block];
+        if (!isRecord(block))
+            return [];
+        const direct = firstString(block, ['text', 'content']);
+        return direct === undefined ? [] : [direct];
+    });
+    return text.length > 0 ? text.join('') : value;
+}
+function withToolResult(call, result) {
+    return {
+        ...call,
+        outputSummary: result.output,
+        outputTruncated: result.truncated,
+        failed: result.failed
+    };
+}
+function isInjectedContextPrompt(text) {
+    const normalized = text.replace(/\s+/g, ' ').trim();
+    if (normalized.startsWith('<codex_internal_context'))
+        return true;
+    return (normalized.startsWith('# AGENTS.md instructions') &&
+        (normalized.includes('<INSTRUCTIONS>') || normalized.includes('<environment_context>')));
+}
+function isHiddenTranscriptRecord(record) {
+    if (contentBlocks(record).some((block) => block['type'] === 'tool_result'))
+        return false;
+    if (record['interruptedByShutdown'] === true ||
+        record['isMeta'] === true ||
+        record['isVisibleInTranscriptOnly'] === true ||
+        record['isCompactSummary'] === true)
+        return true;
+    const text = textOf(record)?.trim() ?? '';
+    return (text.startsWith('<local-command-') ||
+        text.startsWith('<command-name>') ||
+        text.startsWith('<command-message>'));
+}
+function roleOf(record) {
+    const candidates = [
+        firstString(record, ['role']),
+        nestedString(record, ['message', 'role']),
+        nestedString(record, ['payload', 'role']),
+        firstString(record, ['type']),
+        nestedString(record, ['payload', 'type'])
+    ];
+    if (candidates.some((value) => value === 'user' || value === 'human' || value === 'input'))
+        return 'USER';
+    if (candidates.some((value) => value === 'assistant' || value === 'agent' || value === 'output'))
+        return 'ASSISTANT';
+    return undefined;
+}
+function textOf(record) {
+    return (firstString(record, ['content', 'text']) ??
+        nestedText(record['message']) ??
+        nestedText(record['payload']));
+}
+function nestedText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!isRecord(value))
+        return undefined;
+    const direct = firstString(value, ['content', 'text', 'message']);
+    if (direct !== undefined)
+        return direct;
+    if (Array.isArray(value['content'])) {
+        const parts = value['content'].flatMap((part) => {
+            if (typeof part === 'string')
+                return [part];
+            if (!isRecord(part))
+                return [];
+            return [firstString(part, ['text', 'content'])].filter((text) => text !== undefined);
+        });
+        return parts.join('\n');
+    }
+    return undefined;
+}
+function contentBlocks(record) {
+    const values = [record['message'], record['payload']];
+    for (const value of values)
+        if (isRecord(value) && Array.isArray(value['content']))
+            return value['content'].filter(isRecord);
+    return [];
+}
+function compactValue(value, limit) {
+    if (value === undefined || value === null)
+        return { text: '', truncated: false };
+    let text;
+    if (typeof value === 'string')
+        text = value;
+    else {
+        try {
+            text = JSON.stringify(value);
+        }
+        catch {
+            return { text: '（无法显示）', truncated: false };
+        }
+    }
+    return {
+        text: text.length <= limit ? text : `${text.slice(0, Math.max(0, limit - 1))}…`,
+        truncated: text.length > limit
+    };
+}
+function timestampOf(record) {
+    const raw = record['timestamp'] ?? record['created_at'] ?? record['createdAt'];
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return raw < 10_000_000_000 ? raw * 1_000 : raw;
+    if (typeof raw === 'string') {
+        const value = Date.parse(raw);
+        return Number.isNaN(value) ? null : value;
+    }
+    return null;
+}
+function firstString(value, keys) {
+    for (const key of keys)
+        if (typeof value[key] === 'string' && value[key].length > 0)
+            return value[key];
+    return undefined;
+}
+function nestedString(value, keys) {
+    let current = value;
+    for (const key of keys) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[key];
+    }
+    return typeof current === 'string' && current.length > 0 ? current : undefined;
+}
+function compact(value) {
+    return value.replace(/\s+/g, ' ').trim().slice(0, 16_000);
+}
+/** 对话正文可能是 Markdown，不能像标题一样压缩内部空白。 */
+function messageText(value) {
+    return value.trim().slice(0, 16_000);
+}
+function canonical(value) {
+    try {
+        const normalized = resolve(value).replace(/[\\/]+$/, '');
+        return process.platform === 'win32' ? normalized.toLocaleLowerCase() : normalized;
+    }
+    catch {
+        return value;
+    }
+}
+function indexKey(runner, cwd, externalSessionId) {
+    return `${runner}\u0000${cwd}\u0000${externalSessionId}`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=native-session-history.js.map