cli-link 0.0.6 → 0.0.8

package/dist/server/codex-history.js

@@ -55,7 +55,7 @@ function localTime(timestamp, fallbackMs) {
         ? 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' });
+    return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hourCycle: 'h23' });
 }
 function cleanTitle(value) {
     const normalized = safeString(value)
@@ -70,6 +70,21 @@ function cleanTitle(value) {
         return 'Codex 会话记录';
     return normalized.length > 60 ? `${normalized.slice(0, 60).trimEnd()}...` : normalized;
 }
+function selectColumn(columns, name, fallbackSql) {
+    return columns.has(name) ? name : `${fallbackSql} AS ${name}`;
+}
+function timestampOrderExpression(columns) {
+    const candidates = [];
+    if (columns.has('updated_at_ms'))
+        candidates.push('updated_at_ms');
+    if (columns.has('updated_at'))
+        candidates.push('updated_at * 1000');
+    if (columns.has('created_at_ms'))
+        candidates.push('created_at_ms');
+    if (columns.has('created_at'))
+        candidates.push('created_at * 1000');
+    return candidates.length > 0 ? `COALESCE(${candidates.join(', ')})` : '0';
+}
 function extractContentText(content) {
     if (typeof content === 'string')
         return content;
@@ -87,15 +102,56 @@ function extractContentText(content) {
         .filter(Boolean)
         .join('\n');
 }
+function objectDetails(details) {
+    return details && typeof details === 'object' && !Array.isArray(details)
+        ? { ...details }
+        : {};
+}
+function setAssistantPhase(message, phase) {
+    const details = objectDetails(message.details);
+    if (typeof details.assistantPhase === 'string')
+        return;
+    message.details = { ...details, assistantPhase: phase };
+}
+function annotateAssistantPhases(messages) {
+    let turnStart = 0;
+    const finalizeTurn = (turnEnd) => {
+        const assistantIndexes = [];
+        for (let i = turnStart; i < turnEnd; i += 1) {
+            const message = messages[i];
+            if (message.type === 'ai_message' || message.type === 'ai') {
+                assistantIndexes.push(i);
+            }
+        }
+        assistantIndexes.forEach((messageIndex, index) => {
+            setAssistantPhase(messages[messageIndex], index === assistantIndexes.length - 1 ? 'final' : 'progress');
+        });
+    };
+    for (let i = 0; i < messages.length; i += 1) {
+        const message = messages[i];
+        if (message.type === 'user_message' || message.type === 'user') {
+            finalizeTurn(i);
+            turnStart = i + 1;
+        }
+    }
+    finalizeTurn(messages.length);
+}
 function parseRolloutMessages(thread) {
     const rolloutPath = thread.rollout_path;
     if (!rolloutPath || !existsSync(rolloutPath))
         return [];
-    if (statSync(rolloutPath).size > MAX_ROLLOUT_BYTES) {
+    let lines;
+    try {
+        if (statSync(rolloutPath).size > MAX_ROLLOUT_BYTES) {
+            return [];
+        }
+        lines = readFileSync(rolloutPath, 'utf8').split(/\r?\n/).filter(Boolean);
+    }
+    catch (err) {
+        console.warn(`[CodexHistory] Failed to read rollout ${rolloutPath}: ${err?.message || err}`);
         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) => {
@@ -116,6 +172,7 @@ function parseRolloutMessages(thread) {
         return next;
     };
     push({
+        id: `codex-${thread.id}-system-init`,
         type: 'system',
         content: `Codex session synced (${thread.id.slice(0, 8)}...)`,
         time: localTime(thread.created_at_ms || startedAt, startedAt),
@@ -129,7 +186,9 @@ function parseRolloutMessages(thread) {
             importedFrom: 'codex-client',
         },
     });
-    for (const line of lines) {
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const lineNo = index + 1;
         let entry;
         try {
             entry = JSON.parse(line);
@@ -145,19 +204,19 @@ function parseRolloutMessages(thread) {
             if (payload.type === 'user_message') {
                 const content = truncate(payload.message, MAX_MESSAGE_CHARS).trim();
                 if (content)
-                    push({ type: 'user_message', content, time });
+                    push({ id: `codex-${thread.id}-event-${lineNo}-user`, 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 });
+                    push({ id: `codex-${thread.id}-event-${lineNo}-agent`, 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 callId = safeString(payload.call_id || payload.id || `line-${lineNo}`);
             const toolName = safeString(payload.name || 'tool');
             const tool = push({
                 id: `codex-${thread.id}-tool-${callId}`,
@@ -182,7 +241,7 @@ function parseRolloutMessages(thread) {
             }
             else {
                 push({
-                    id: `codex-${thread.id}-tool-output-${messages.length + 1}`,
+                    id: `codex-${thread.id}-tool-output-${lineNo}`,
                     type: 'tool_call',
                     content: 'tool',
                     time,
@@ -198,12 +257,13 @@ function parseRolloutMessages(thread) {
             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 });
+                push({ id: `codex-${thread.id}-event-${lineNo}-assistant`, type: 'ai_message', content, time });
             }
         }
     }
     if (thread.tokens_used && thread.tokens_used > 0) {
         push({
+            id: `codex-${thread.id}-system-result`,
             type: 'system',
             content: 'Codex usage summary',
             time: localTime(thread.updated_at_ms || Date.now(), Date.now()),
@@ -216,6 +276,10 @@ function parseRolloutMessages(thread) {
             },
         });
     }
+    if (!messages.some(message => message.type === 'user_message' || message.type === 'user')) {
+        return [];
+    }
+    annotateAssistantPhases(messages);
     return messages;
 }
 export function readCodexHistorySessions(options = {}) {
@@ -225,17 +289,51 @@ export function readCodexHistorySessions(options = {}) {
         return [];
     const limit = normalizeLimit(options.limit);
     const workDir = normalizeWorkDir(options.workDir);
-    const db = new Database(stateDbPath, { readonly: true, fileMustExist: true });
+    let db;
+    try {
+        db = new Database(stateDbPath, { readonly: true, fileMustExist: true });
+    }
+    catch (err) {
+        console.warn(`[CodexHistory] Failed to open ${stateDbPath}: ${err?.message || err}`);
+        return [];
+    }
     try {
+        const columns = new Set(db.prepare(`PRAGMA table_info(threads)`).all()
+            .map(column => column.name));
+        if (!columns.has('id') || !columns.has('rollout_path')) {
+            console.warn('[CodexHistory] Codex threads table is missing required columns');
+            return [];
+        }
+        if (workDir && !columns.has('cwd')) {
+            console.warn('[CodexHistory] Codex threads table has no cwd column; scoped sync skipped');
+            return [];
+        }
+        const selectedColumns = [
+            selectColumn(columns, 'id', "''"),
+            selectColumn(columns, 'rollout_path', "''"),
+            selectColumn(columns, 'created_at', '0'),
+            selectColumn(columns, 'updated_at', '0'),
+            selectColumn(columns, 'created_at_ms', '0'),
+            selectColumn(columns, 'updated_at_ms', '0'),
+            selectColumn(columns, 'title', "''"),
+            selectColumn(columns, 'cwd', 'NULL'),
+            selectColumn(columns, 'source', "''"),
+            selectColumn(columns, 'model', 'NULL'),
+            selectColumn(columns, 'reasoning_effort', 'NULL'),
+            selectColumn(columns, 'tokens_used', '0'),
+            selectColumn(columns, 'first_user_message', "''"),
+        ].join(', ');
+        const where = [
+            'rollout_path IS NOT NULL',
+            "rollout_path != ''",
+        ];
+        if (workDir)
+            where.push('cwd = ?');
         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
+      SELECT ${selectedColumns}
       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
+      WHERE ${where.join(' AND ')}
+      ORDER BY ${timestampOrderExpression(columns)} DESC
       LIMIT ?
     `;
         const params = workDir ? [workDir, limit] : [limit];
@@ -270,6 +368,10 @@ export function readCodexHistorySessions(options = {}) {
             };
         });
     }
+    catch (err) {
+        console.warn(`[CodexHistory] Failed to read Codex history: ${err?.message || err}`);
+        return [];
+    }
     finally {
         db.close();
     }