@siteboon/claude-code-ui 1.25.2 → 1.26.0

package/server/providers/claude/adapter.js

@@ -0,0 +1,278 @@
+/**
+ * Claude provider adapter.
+ *
+ * Normalizes Claude SDK session history into NormalizedMessage format.
+ * @module adapters/claude
+ */
+
+import { getSessionMessages } from '../../projects.js';
+import { createNormalizedMessage, generateMessageId } from '../types.js';
+import { isInternalContent } from '../utils.js';
+
+const PROVIDER = 'claude';
+
+/**
+ * Normalize a raw JSONL message or realtime SDK event into NormalizedMessage(s).
+ * Handles both history entries (JSONL `{ message: { role, content } }`) and
+ * realtime streaming events (`content_block_delta`, `content_block_stop`, etc.).
+ * @param {object} raw - A single entry from JSONL or a live SDK event
+ * @param {string} sessionId
+ * @returns {import('../types.js').NormalizedMessage[]}
+ */
+export function normalizeMessage(raw, sessionId) {
+  // ── Streaming events (realtime) ──────────────────────────────────────────
+  if (raw.type === 'content_block_delta' && raw.delta?.text) {
+    return [createNormalizedMessage({ kind: 'stream_delta', content: raw.delta.text, sessionId, provider: PROVIDER })];
+  }
+  if (raw.type === 'content_block_stop') {
+    return [createNormalizedMessage({ kind: 'stream_end', sessionId, provider: PROVIDER })];
+  }
+
+  // ── History / full-message events ────────────────────────────────────────
+  const messages = [];
+  const ts = raw.timestamp || new Date().toISOString();
+  const baseId = raw.uuid || generateMessageId('claude');
+
+  // User message
+  if (raw.message?.role === 'user' && raw.message?.content) {
+    if (Array.isArray(raw.message.content)) {
+      // Handle tool_result parts
+      for (const part of raw.message.content) {
+        if (part.type === 'tool_result') {
+          messages.push(createNormalizedMessage({
+            id: `${baseId}_tr_${part.tool_use_id}`,
+            sessionId,
+            timestamp: ts,
+            provider: PROVIDER,
+            kind: 'tool_result',
+            toolId: part.tool_use_id,
+            content: typeof part.content === 'string' ? part.content : JSON.stringify(part.content),
+            isError: Boolean(part.is_error),
+            subagentTools: raw.subagentTools,
+            toolUseResult: raw.toolUseResult,
+          }));
+        } else if (part.type === 'text') {
+          // Regular text parts from user
+          const text = part.text || '';
+          if (text && !isInternalContent(text)) {
+            messages.push(createNormalizedMessage({
+              id: `${baseId}_text`,
+              sessionId,
+              timestamp: ts,
+              provider: PROVIDER,
+              kind: 'text',
+              role: 'user',
+              content: text,
+            }));
+          }
+        }
+      }
+
+      // If no text parts were found, check if it's a pure user message
+      if (messages.length === 0) {
+        const textParts = raw.message.content
+          .filter(p => p.type === 'text')
+          .map(p => p.text)
+          .filter(Boolean)
+          .join('\n');
+        if (textParts && !isInternalContent(textParts)) {
+          messages.push(createNormalizedMessage({
+            id: `${baseId}_text`,
+            sessionId,
+            timestamp: ts,
+            provider: PROVIDER,
+            kind: 'text',
+            role: 'user',
+            content: textParts,
+          }));
+        }
+      }
+    } else if (typeof raw.message.content === 'string') {
+      const text = raw.message.content;
+      if (text && !isInternalContent(text)) {
+        messages.push(createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'text',
+          role: 'user',
+          content: text,
+        }));
+      }
+    }
+    return messages;
+  }
+
+  // Thinking message
+  if (raw.type === 'thinking' && raw.message?.content) {
+    messages.push(createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'thinking',
+      content: raw.message.content,
+    }));
+    return messages;
+  }
+
+  // Tool use result (codex-style in Claude)
+  if (raw.type === 'tool_use' && raw.toolName) {
+    messages.push(createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'tool_use',
+      toolName: raw.toolName,
+      toolInput: raw.toolInput,
+      toolId: raw.toolCallId || baseId,
+    }));
+    return messages;
+  }
+
+  if (raw.type === 'tool_result') {
+    messages.push(createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'tool_result',
+      toolId: raw.toolCallId || '',
+      content: raw.output || '',
+      isError: false,
+    }));
+    return messages;
+  }
+
+  // Assistant message
+  if (raw.message?.role === 'assistant' && raw.message?.content) {
+    if (Array.isArray(raw.message.content)) {
+      let partIndex = 0;
+      for (const part of raw.message.content) {
+        if (part.type === 'text' && part.text) {
+          messages.push(createNormalizedMessage({
+            id: `${baseId}_${partIndex}`,
+            sessionId,
+            timestamp: ts,
+            provider: PROVIDER,
+            kind: 'text',
+            role: 'assistant',
+            content: part.text,
+          }));
+        } else if (part.type === 'tool_use') {
+          messages.push(createNormalizedMessage({
+            id: `${baseId}_${partIndex}`,
+            sessionId,
+            timestamp: ts,
+            provider: PROVIDER,
+            kind: 'tool_use',
+            toolName: part.name,
+            toolInput: part.input,
+            toolId: part.id,
+          }));
+        } else if (part.type === 'thinking' && part.thinking) {
+          messages.push(createNormalizedMessage({
+            id: `${baseId}_${partIndex}`,
+            sessionId,
+            timestamp: ts,
+            provider: PROVIDER,
+            kind: 'thinking',
+            content: part.thinking,
+          }));
+        }
+        partIndex++;
+      }
+    } else if (typeof raw.message.content === 'string') {
+      messages.push(createNormalizedMessage({
+        id: baseId,
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'text',
+        role: 'assistant',
+        content: raw.message.content,
+      }));
+    }
+    return messages;
+  }
+
+  return messages;
+}
+
+/**
+ * @type {import('../types.js').ProviderAdapter}
+ */
+export const claudeAdapter = {
+  normalizeMessage,
+
+  /**
+   * Fetch session history from JSONL files, returning normalized messages.
+   */
+  async fetchHistory(sessionId, opts = {}) {
+    const { projectName, limit = null, offset = 0 } = opts;
+    if (!projectName) {
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    }
+
+    let result;
+    try {
+      result = await getSessionMessages(projectName, sessionId, limit, offset);
+    } catch (error) {
+      console.warn(`[ClaudeAdapter] Failed to load session ${sessionId}:`, error.message);
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    }
+
+    // getSessionMessages returns either an array (no limit) or { messages, total, hasMore }
+    const rawMessages = Array.isArray(result) ? result : (result.messages || []);
+    const total = Array.isArray(result) ? rawMessages.length : (result.total || 0);
+    const hasMore = Array.isArray(result) ? false : Boolean(result.hasMore);
+
+    // First pass: collect tool results for attachment to tool_use messages
+    const toolResultMap = new Map();
+    for (const raw of rawMessages) {
+      if (raw.message?.role === 'user' && Array.isArray(raw.message?.content)) {
+        for (const part of raw.message.content) {
+          if (part.type === 'tool_result') {
+            toolResultMap.set(part.tool_use_id, {
+              content: part.content,
+              isError: Boolean(part.is_error),
+              timestamp: raw.timestamp,
+              subagentTools: raw.subagentTools,
+              toolUseResult: raw.toolUseResult,
+            });
+          }
+        }
+      }
+    }
+
+    // Second pass: normalize all messages
+    const normalized = [];
+    for (const raw of rawMessages) {
+      const entries = normalizeMessage(raw, sessionId);
+      normalized.push(...entries);
+    }
+
+    // Attach tool results to their corresponding tool_use messages
+    for (const msg of normalized) {
+      if (msg.kind === 'tool_use' && msg.toolId && toolResultMap.has(msg.toolId)) {
+        const tr = toolResultMap.get(msg.toolId);
+        msg.toolResult = {
+          content: typeof tr.content === 'string' ? tr.content : JSON.stringify(tr.content),
+          isError: tr.isError,
+          toolUseResult: tr.toolUseResult,
+        };
+        msg.subagentTools = tr.subagentTools;
+      }
+    }
+
+    return {
+      messages: normalized,
+      total,
+      hasMore,
+      offset,
+      limit,
+    };
+  },
+};

package/server/providers/codex/adapter.js

@@ -0,0 +1,248 @@
+/**
+ * Codex (OpenAI) provider adapter.
+ *
+ * Normalizes Codex SDK session history into NormalizedMessage format.
+ * @module adapters/codex
+ */
+
+import { getCodexSessionMessages } from '../../projects.js';
+import { createNormalizedMessage, generateMessageId } from '../types.js';
+
+const PROVIDER = 'codex';
+
+/**
+ * Normalize a raw Codex JSONL message into NormalizedMessage(s).
+ * @param {object} raw - A single parsed message from Codex JSONL
+ * @param {string} sessionId
+ * @returns {import('../types.js').NormalizedMessage[]}
+ */
+function normalizeCodexHistoryEntry(raw, sessionId) {
+  const ts = raw.timestamp || new Date().toISOString();
+  const baseId = raw.uuid || generateMessageId('codex');
+
+  // User message
+  if (raw.message?.role === 'user') {
+    const content = typeof raw.message.content === 'string'
+      ? raw.message.content
+      : Array.isArray(raw.message.content)
+        ? raw.message.content.map(p => typeof p === 'string' ? p : p?.text || '').filter(Boolean).join('\n')
+        : String(raw.message.content || '');
+    if (!content.trim()) return [];
+    return [createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'text',
+      role: 'user',
+      content,
+    })];
+  }
+
+  // Assistant message
+  if (raw.message?.role === 'assistant') {
+    const content = typeof raw.message.content === 'string'
+      ? raw.message.content
+      : Array.isArray(raw.message.content)
+        ? raw.message.content.map(p => typeof p === 'string' ? p : p?.text || '').filter(Boolean).join('\n')
+        : '';
+    if (!content.trim()) return [];
+    return [createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'text',
+      role: 'assistant',
+      content,
+    })];
+  }
+
+  // Thinking/reasoning
+  if (raw.type === 'thinking' || raw.isReasoning) {
+    return [createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'thinking',
+      content: raw.message?.content || '',
+    })];
+  }
+
+  // Tool use
+  if (raw.type === 'tool_use' || raw.toolName) {
+    return [createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'tool_use',
+      toolName: raw.toolName || 'Unknown',
+      toolInput: raw.toolInput,
+      toolId: raw.toolCallId || baseId,
+    })];
+  }
+
+  // Tool result
+  if (raw.type === 'tool_result') {
+    return [createNormalizedMessage({
+      id: baseId,
+      sessionId,
+      timestamp: ts,
+      provider: PROVIDER,
+      kind: 'tool_result',
+      toolId: raw.toolCallId || '',
+      content: raw.output || '',
+      isError: Boolean(raw.isError),
+    })];
+  }
+
+  return [];
+}
+
+/**
+ * Normalize a raw Codex event (history JSONL or transformed SDK event) into NormalizedMessage(s).
+ * @param {object} raw - A history entry (has raw.message.role) or transformed SDK event (has raw.type)
+ * @param {string} sessionId
+ * @returns {import('../types.js').NormalizedMessage[]}
+ */
+export function normalizeMessage(raw, sessionId) {
+  // History format: has message.role
+  if (raw.message?.role) {
+    return normalizeCodexHistoryEntry(raw, sessionId);
+  }
+
+  const ts = raw.timestamp || new Date().toISOString();
+  const baseId = raw.uuid || generateMessageId('codex');
+
+  // SDK event format (output of transformCodexEvent)
+  if (raw.type === 'item') {
+    switch (raw.itemType) {
+      case 'agent_message':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'text', role: 'assistant', content: raw.message?.content || '',
+        })];
+      case 'reasoning':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'thinking', content: raw.message?.content || '',
+        })];
+      case 'command_execution':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'tool_use', toolName: 'Bash', toolInput: { command: raw.command },
+          toolId: baseId,
+          output: raw.output, exitCode: raw.exitCode, status: raw.status,
+        })];
+      case 'file_change':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'tool_use', toolName: 'FileChanges', toolInput: raw.changes,
+          toolId: baseId, status: raw.status,
+        })];
+      case 'mcp_tool_call':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'tool_use', toolName: raw.tool || 'MCP', toolInput: raw.arguments,
+          toolId: baseId, server: raw.server, result: raw.result,
+          error: raw.error, status: raw.status,
+        })];
+      case 'web_search':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'tool_use', toolName: 'WebSearch', toolInput: { query: raw.query },
+          toolId: baseId,
+        })];
+      case 'todo_list':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'tool_use', toolName: 'TodoList', toolInput: { items: raw.items },
+          toolId: baseId,
+        })];
+      case 'error':
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'error', content: raw.message?.content || 'Unknown error',
+        })];
+      default:
+        // Unknown item type — pass through as generic tool_use
+        return [createNormalizedMessage({
+          id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+          kind: 'tool_use', toolName: raw.itemType || 'Unknown',
+          toolInput: raw.item || raw, toolId: baseId,
+        })];
+    }
+  }
+
+  if (raw.type === 'turn_complete') {
+    return [createNormalizedMessage({
+      id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+      kind: 'complete',
+    })];
+  }
+  if (raw.type === 'turn_failed') {
+    return [createNormalizedMessage({
+      id: baseId, sessionId, timestamp: ts, provider: PROVIDER,
+      kind: 'error', content: raw.error?.message || 'Turn failed',
+    })];
+  }
+
+  return [];
+}
+
+/**
+ * @type {import('../types.js').ProviderAdapter}
+ */
+export const codexAdapter = {
+  normalizeMessage,
+  /**
+   * Fetch session history from Codex JSONL files.
+   */
+  async fetchHistory(sessionId, opts = {}) {
+    const { limit = null, offset = 0 } = opts;
+
+    let result;
+    try {
+      result = await getCodexSessionMessages(sessionId, limit, offset);
+    } catch (error) {
+      console.warn(`[CodexAdapter] Failed to load session ${sessionId}:`, error.message);
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    }
+
+    const rawMessages = Array.isArray(result) ? result : (result.messages || []);
+    const total = Array.isArray(result) ? rawMessages.length : (result.total || 0);
+    const hasMore = Array.isArray(result) ? false : Boolean(result.hasMore);
+    const tokenUsage = result.tokenUsage || null;
+
+    const normalized = [];
+    for (const raw of rawMessages) {
+      const entries = normalizeCodexHistoryEntry(raw, sessionId);
+      normalized.push(...entries);
+    }
+
+    // Attach tool results to tool_use messages
+    const toolResultMap = new Map();
+    for (const msg of normalized) {
+      if (msg.kind === 'tool_result' && msg.toolId) {
+        toolResultMap.set(msg.toolId, msg);
+      }
+    }
+    for (const msg of normalized) {
+      if (msg.kind === 'tool_use' && msg.toolId && toolResultMap.has(msg.toolId)) {
+        const tr = toolResultMap.get(msg.toolId);
+        msg.toolResult = { content: tr.content, isError: tr.isError };
+      }
+    }
+
+    return {
+      messages: normalized,
+      total,
+      hasMore,
+      offset,
+      limit,
+      tokenUsage,
+    };
+  },
+};