cli-link 0.0.1

package/dist/server/codex-history.js

@@ -0,0 +1,280 @@
+import Database from 'better-sqlite3';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join, resolve } from 'path';
+import * as store from './store.js';
+const DEFAULT_LIMIT = 500;
+const MAX_ROLLOUT_BYTES = 25 * 1024 * 1024;
+const MAX_MESSAGE_CHARS = 120_000;
+const MAX_TOOL_CHARS = 180_000;
+function resolveCodexHome(raw) {
+    if (!raw || raw === '~/.codex')
+        return join(homedir(), '.codex');
+    if (raw === '~')
+        return homedir();
+    if (raw.startsWith('~/'))
+        return join(homedir(), raw.slice(2));
+    return resolve(raw);
+}
+function normalizeLimit(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_LIMIT;
+    return Math.min(2000, Math.floor(parsed));
+}
+function normalizeWorkDir(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    const trimmed = value.trim();
+    if (trimmed === '~')
+        return homedir();
+    if (trimmed.startsWith('~/'))
+        return join(homedir(), trimmed.slice(2));
+    return resolve(trimmed);
+}
+function safeString(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value == null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function truncate(value, maxChars) {
+    const text = safeString(value);
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}\n\n[truncated ${text.length - maxChars} chars]`;
+}
+function localTime(timestamp, fallbackMs) {
+    const ms = typeof timestamp === 'string'
+        ? new Date(timestamp).getTime()
+        : Number(timestamp);
+    const date = Number.isFinite(ms) && ms > 0 ? new Date(ms) : new Date(fallbackMs || Date.now());
+    return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+}
+function cleanTitle(value) {
+    const normalized = safeString(value)
+        .replace(/```[\s\S]*?```/g, ' ')
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!normalized)
+        return 'Codex 会话记录';
+    return normalized.length > 60 ? `${normalized.slice(0, 60).trimEnd()}...` : normalized;
+}
+function extractContentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return safeString(content);
+    return content
+        .map((part) => {
+        if (typeof part === 'string')
+            return part;
+        if (!part || typeof part !== 'object')
+            return safeString(part);
+        const record = part;
+        return safeString(record.text || record.content || record.output_text || record.summary || '');
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function parseRolloutMessages(thread) {
+    const rolloutPath = thread.rollout_path;
+    if (!rolloutPath || !existsSync(rolloutPath))
+        return [];
+    if (statSync(rolloutPath).size > MAX_ROLLOUT_BYTES) {
+        return [];
+    }
+    const startedAt = thread.created_at_ms || (thread.created_at || 0) * 1000 || Date.now();
+    const lines = readFileSync(rolloutPath, 'utf8').split(/\r?\n/).filter(Boolean);
+    const messages = [];
+    const toolByCallId = new Map();
+    const push = (message) => {
+        const next = {
+            id: message.id || `codex-${thread.id}-${messages.length + 1}`,
+            type: message.type,
+            content: message.content,
+            time: message.time,
+            status: message.status,
+            toolName: message.toolName,
+            toolDetails: message.toolDetails,
+            toolUseId: message.toolUseId,
+            toolResult: message.toolResult,
+            permission: message.permission,
+            details: message.details,
+        };
+        messages.push(next);
+        return next;
+    };
+    push({
+        type: 'system',
+        content: `Codex session synced (${thread.id.slice(0, 8)}...)`,
+        time: localTime(thread.created_at_ms || startedAt, startedAt),
+        details: {
+            subtype: 'init',
+            session_id: thread.id,
+            model: thread.model || undefined,
+            reasoningEffort: thread.reasoning_effort || undefined,
+            cwd: thread.cwd || undefined,
+            source: thread.source || undefined,
+            importedFrom: 'codex-client',
+        },
+    });
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const payload = entry?.payload;
+        const time = localTime(entry?.timestamp, startedAt);
+        if (!payload || typeof payload !== 'object')
+            continue;
+        if (entry.type === 'event_msg') {
+            if (payload.type === 'user_message') {
+                const content = truncate(payload.message, MAX_MESSAGE_CHARS).trim();
+                if (content)
+                    push({ type: 'user_message', content, time });
+            }
+            else if (payload.type === 'agent_message') {
+                const content = truncate(payload.message, MAX_MESSAGE_CHARS).trim();
+                if (content)
+                    push({ type: 'ai_message', content, time });
+            }
+            continue;
+        }
+        if (entry.type !== 'response_item')
+            continue;
+        if (payload.type === 'function_call') {
+            const callId = safeString(payload.call_id || payload.id || `call-${messages.length + 1}`);
+            const toolName = safeString(payload.name || 'tool');
+            const tool = push({
+                id: `codex-${thread.id}-tool-${callId}`,
+                type: 'tool_call',
+                content: toolName,
+                time,
+                status: 'running',
+                toolName,
+                toolDetails: truncate(payload.arguments || payload.input || '', MAX_TOOL_CHARS),
+                toolUseId: callId,
+            });
+            toolByCallId.set(callId, tool);
+            continue;
+        }
+        if (payload.type === 'function_call_output') {
+            const callId = safeString(payload.call_id || payload.id || '');
+            const output = truncate(payload.output || payload.result || payload.content || '', MAX_TOOL_CHARS);
+            const existing = callId ? toolByCallId.get(callId) : undefined;
+            if (existing) {
+                existing.status = 'success';
+                existing.toolResult = output;
+            }
+            else {
+                push({
+                    id: `codex-${thread.id}-tool-output-${messages.length + 1}`,
+                    type: 'tool_call',
+                    content: 'tool',
+                    time,
+                    status: 'success',
+                    toolName: 'tool',
+                    toolUseId: callId || undefined,
+                    toolResult: output,
+                });
+            }
+            continue;
+        }
+        if (payload.type === 'message' && payload.role === 'assistant') {
+            const content = truncate(extractContentText(payload.content), MAX_MESSAGE_CHARS).trim();
+            const last = messages[messages.length - 1];
+            if (content && !(last?.type === 'ai_message' && last.content === content)) {
+                push({ type: 'ai_message', content, time });
+            }
+        }
+    }
+    if (thread.tokens_used && thread.tokens_used > 0) {
+        push({
+            type: 'system',
+            content: 'Codex usage summary',
+            time: localTime(thread.updated_at_ms || Date.now(), Date.now()),
+            details: {
+                subtype: 'result',
+                session_id: thread.id,
+                model: thread.model || undefined,
+                inputTokens: thread.tokens_used,
+                outputTokens: 0,
+            },
+        });
+    }
+    return messages;
+}
+export function readCodexHistorySessions(options = {}) {
+    const codexHome = resolveCodexHome(options.codexHome);
+    const stateDbPath = join(codexHome, 'state_5.sqlite');
+    if (!existsSync(stateDbPath))
+        return [];
+    const limit = normalizeLimit(options.limit);
+    const workDir = normalizeWorkDir(options.workDir);
+    const db = new Database(stateDbPath, { readonly: true, fileMustExist: true });
+    try {
+        const query = `
+      SELECT id, rollout_path, created_at, updated_at, created_at_ms, updated_at_ms,
+             title, cwd, source, model, reasoning_effort, tokens_used, first_user_message
+      FROM threads
+      WHERE rollout_path IS NOT NULL
+        AND rollout_path != ''
+        AND has_user_event = 1
+        ${workDir ? 'AND cwd = ?' : ''}
+      ORDER BY COALESCE(updated_at_ms, updated_at * 1000, created_at_ms, created_at * 1000) DESC
+      LIMIT ?
+    `;
+        const params = workDir ? [workDir, limit] : [limit];
+        const rows = db.prepare(query).all(...params);
+        return rows.map((thread) => {
+            const startedAt = thread.created_at_ms || (thread.created_at || 0) * 1000 || Date.now();
+            const endedAt = thread.updated_at_ms || (thread.updated_at || 0) * 1000 || startedAt;
+            const title = cleanTitle(thread.title || thread.first_user_message);
+            const messages = parseRolloutMessages(thread);
+            return {
+                sessionId: `codex-${thread.id}`,
+                taskId: `codex-task-${thread.id}`,
+                title,
+                workDir: thread.cwd || null,
+                startedAt,
+                endedAt,
+                createdAt: endedAt,
+                status: 'completed',
+                cliConfig: {
+                    cliType: 'codex',
+                    cliCommand: 'codex',
+                    workDir: normalizeWorkDir(thread.cwd) || thread.cwd || process.cwd(),
+                    confirmMode: 'key',
+                    cliArgs: [],
+                    runMode: 'print',
+                    cliSessionId: thread.id,
+                    model: thread.model || undefined,
+                    reasoningEffort: thread.reasoning_effort || undefined,
+                    importedFrom: 'codex-client',
+                },
+                messages,
+            };
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+export function syncCodexHistory(options = {}) {
+    const sessions = readCodexHistorySessions(options);
+    return store.importCodexSessions(sessions);
+}