@qiaolei81/copilot-session-viewer 0.1.9 → 0.2.0

package/lib/parsers/base-parser.js

@@ -0,0 +1,53 @@
+/**
+ * Base Session Parser Interface
+ * 
+ * All session parsers must implement these methods
+ */
+class BaseSessionParser {
+  /**
+   * Detect if this parser can handle the given events
+   * @param {Array<Object>} _events - Raw events from jsonl
+   * @returns {boolean}
+   */
+  canParse(_events) {
+    throw new Error('canParse() must be implemented');
+  }
+
+  /**
+   * Parse raw events into normalized format
+   * @param {Array<Object>} _events - Raw events from jsonl
+   * @returns {Object} Parsed session data
+   */
+  parse(_events) {
+    throw new Error('parse() must be implemented');
+  }
+
+  /**
+   * Get session metadata (sessionId, startTime, model, etc.)
+   * @param {Array<Object>} _events - Raw events
+   * @returns {Object} Session metadata
+   */
+  getMetadata(_events) {
+    throw new Error('getMetadata() must be implemented');
+  }
+
+  /**
+   * Extract turns (user message + assistant response pairs)
+   * @param {Array<Object>} _events - Raw events
+   * @returns {Array<Object>} Array of turns
+   */
+  extractTurns(_events) {
+    throw new Error('extractTurns() must be implemented');
+  }
+
+  /**
+   * Extract tool calls/executions
+   * @param {Array<Object>} _events - Raw events
+   * @returns {Array<Object>} Array of tool calls
+   */
+  extractToolCalls(_events) {
+    throw new Error('extractToolCalls() must be implemented');
+  }
+}
+
+module.exports = BaseSessionParser;

package/lib/parsers/claude-parser.js

@@ -0,0 +1,181 @@
+const BaseSessionParser = require('./base-parser');
+
+/**
+ * Claude Code Session Parser
+ * 
+ * Parses events from Anthropic Claude Code CLI
+ * Format: {type: "user"|"assistant", uuid: "...", parentUuid: "...", message: {...}}
+ */
+class ClaudeSessionParser extends BaseSessionParser {
+  canParse(events) {
+    if (!events || events.length === 0) return false;
+    
+    // Check for Claude Code specific structure
+    return events.some(e => 
+      e.type && ['user', 'assistant'].includes(e.type) &&
+      e.uuid && Object.prototype.hasOwnProperty.call(e, 'parentUuid') && e.sessionId
+    );
+  }
+
+  parse(events) {
+    return {
+      metadata: this.getMetadata(events),
+      turns: this.extractTurns(events),
+      toolCalls: this.extractToolCalls(events),
+      allEvents: events
+    };
+  }
+
+  getMetadata(events) {
+    const firstUserMessage = events.find(e => e.type === 'user');
+    if (!firstUserMessage) return null;
+
+    // Extract model from assistant messages
+    const firstAssistant = events.find(e => e.type === 'assistant' && e.message?.model);
+    const model = firstAssistant?.message?.model || 'unknown';
+
+    return {
+      sessionId: firstUserMessage.sessionId,
+      startTime: firstUserMessage.timestamp,
+      model: model,
+      version: firstUserMessage.version,
+      producer: 'claude-code',
+      cwd: firstUserMessage.cwd,
+      gitRoot: null, // Not available in Claude format
+      branch: firstUserMessage.gitBranch,
+      repository: null // Not available in Claude format
+    };
+  }
+
+  extractTurns(events) {
+    const turns = [];
+    const messageEvents = events.filter(e => 
+      ['user', 'assistant'].includes(e.type) &&
+      e.type !== 'file-history-snapshot' &&
+      e.type !== 'queue-operation'
+    );
+
+    // Build parent-child tree
+    const eventMap = new Map();
+    for (const event of messageEvents) {
+      eventMap.set(event.uuid, event);
+    }
+
+    // Find root user messages (no parentUuid or parent is not a message)
+    const rootMessages = messageEvents.filter(e => 
+      e.type === 'user' && (!e.parentUuid || !eventMap.has(e.parentUuid))
+    );
+
+    for (const userMsg of rootMessages) {
+      const turn = {
+        turnId: userMsg.uuid,
+        userMessage: {
+          id: userMsg.uuid,
+          content: this._extractMessageContent(userMsg.message),
+          timestamp: userMsg.timestamp
+        },
+        assistantMessages: [],
+        toolCalls: []
+      };
+
+      // Find all children of this user message
+      this._collectAssistantResponses(userMsg.uuid, eventMap, turn);
+
+      turns.push(turn);
+    }
+
+    return turns;
+  }
+
+  _collectAssistantResponses(parentUuid, eventMap, turn) {
+    for (const [_uuid, event] of eventMap.entries()) {
+      if (event.parentUuid === parentUuid) {
+        if (event.type === 'assistant') {
+          const assistantMsg = {
+            id: event.uuid,
+            messageId: event.message?.id,
+            content: this._extractMessageContent(event.message),
+            model: event.message?.model,
+            timestamp: event.timestamp
+          };
+
+          // Extract tool calls from content
+          const toolUseBlocks = this._extractToolUse(event.message);
+          if (toolUseBlocks.length > 0) {
+            assistantMsg.toolRequests = toolUseBlocks;
+            turn.toolCalls.push(...toolUseBlocks.map(t => ({
+              toolCallId: t.id,
+              name: t.name,
+              arguments: t.input,
+              parentUuid: event.uuid
+            })));
+          }
+
+          turn.assistantMessages.push(assistantMsg);
+
+          // Recursively collect children (follow-up messages)
+          this._collectAssistantResponses(event.uuid, eventMap, turn);
+        }
+      }
+    }
+  }
+
+  _extractMessageContent(message) {
+    if (!message || !message.content) return '';
+    
+    if (typeof message.content === 'string') {
+      return message.content;
+    }
+
+    if (Array.isArray(message.content)) {
+      return message.content
+        .filter(block => block.type === 'text')
+        .map(block => block.text)
+        .join('\n');
+    }
+
+    return '';
+  }
+
+  _extractToolUse(message) {
+    if (!message || !message.content || !Array.isArray(message.content)) {
+      return [];
+    }
+
+    return message.content
+      .filter(block => block.type === 'tool_use')
+      .map(block => ({
+        id: block.id,
+        name: block.name,
+        input: block.input
+      }));
+  }
+
+  extractToolCalls(events) {
+    const toolCalls = [];
+
+    for (const event of events) {
+      if (event.type === 'assistant' && event.message?.content) {
+        const toolUseBlocks = this._extractToolUse(event.message);
+        
+        for (const tool of toolUseBlocks) {
+          toolCalls.push({
+            toolCallId: tool.id,
+            name: tool.name,
+            arguments: tool.input,
+            parentUuid: event.uuid,
+            timestamp: event.timestamp,
+            // Claude format doesn't have separate execution events
+            // Tool result would be in a following user message with tool_result
+            result: null,
+            exitCode: null
+          });
+        }
+      }
+    }
+
+    return toolCalls;
+  }
+}
+
+module.exports = ClaudeSessionParser;

package/lib/parsers/copilot-parser.js

@@ -0,0 +1,143 @@
+const BaseSessionParser = require('./base-parser');
+
+/**
+ * Copilot CLI Session Parser
+ * 
+ * Parses events from GitHub Copilot CLI (copilot-agent)
+ * Format: {type: "session.start", data: {...}, id: "...", parentId: "..."}
+ */
+class CopilotSessionParser extends BaseSessionParser {
+  canParse(events) {
+    if (!events || events.length === 0) return false;
+    
+    // Check for Copilot CLI specific event types
+    const copilotEventTypes = [
+      'session.start',
+      'user.message',
+      'assistant.turn_start',
+      'assistant.message',
+      'tool.execution_start'
+    ];
+    
+    return events.some(e => 
+      e.type && copilotEventTypes.some(t => e.type.startsWith(t))
+    );
+  }
+
+  parse(events) {
+    return {
+      metadata: this.getMetadata(events),
+      turns: this.extractTurns(events),
+      toolCalls: this.extractToolCalls(events),
+      allEvents: events
+    };
+  }
+
+  getMetadata(events) {
+    const sessionStart = events.find(e => e.type === 'session.start');
+    if (!sessionStart) return null;
+
+    const data = sessionStart.data || {};
+    return {
+      sessionId: data.sessionId,
+      startTime: data.startTime,
+      model: data.selectedModel,
+      version: data.copilotVersion,
+      producer: data.producer,
+      cwd: data.context?.cwd,
+      gitRoot: data.context?.gitRoot,
+      branch: data.context?.branch,
+      repository: data.context?.repository
+    };
+  }
+
+  extractTurns(events) {
+    const turns = [];
+    let currentTurn = null;
+
+    for (const event of events) {
+      if (event.type === 'user.message') {
+        // Start new turn
+        if (currentTurn) {
+          turns.push(currentTurn);
+        }
+        currentTurn = {
+          turnId: event.id,
+          userMessage: {
+            id: event.id,
+            content: event.data?.content || '',
+            transformedContent: event.data?.transformedContent,
+            timestamp: event.timestamp
+          },
+          assistantMessages: [],
+          toolCalls: []
+        };
+      } else if (event.type === 'assistant.message' && currentTurn) {
+        currentTurn.assistantMessages.push({
+          id: event.id,
+          messageId: event.data?.messageId,
+          content: event.data?.content || '',
+          toolRequests: event.data?.toolRequests || [],
+          reasoningText: event.data?.reasoningText,
+          timestamp: event.timestamp
+        });
+      } else if (event.type.startsWith('tool.execution_') && currentTurn) {
+        const toolCallId = event.data?.toolCallId;
+        let toolCall = currentTurn.toolCalls.find(tc => tc.toolCallId === toolCallId);
+        
+        if (!toolCall) {
+          toolCall = { toolCallId, events: [] };
+          currentTurn.toolCalls.push(toolCall);
+        }
+        
+        toolCall.events.push(event);
+        
+        if (event.type === 'tool.execution_start') {
+          toolCall.name = event.data?.toolName;
+          toolCall.arguments = event.data?.arguments;
+        } else if (event.type === 'tool.execution_complete') {
+          toolCall.result = event.data?.result;
+          toolCall.exitCode = event.data?.exitCode;
+        }
+      }
+    }
+
+    // Push last turn
+    if (currentTurn) {
+      turns.push(currentTurn);
+    }
+
+    return turns;
+  }
+
+  extractToolCalls(events) {
+    const toolCalls = [];
+    const toolCallMap = new Map();
+
+    for (const event of events) {
+      if (event.type === 'tool.execution_start') {
+        const toolCallId = event.data?.toolCallId;
+        toolCallMap.set(toolCallId, {
+          toolCallId,
+          name: event.data?.toolName,
+          arguments: event.data?.arguments,
+          startEvent: event,
+          completeEvent: null
+        });
+      } else if (event.type === 'tool.execution_complete') {
+        const toolCallId = event.data?.toolCallId;
+        const toolCall = toolCallMap.get(toolCallId);
+        if (toolCall) {
+          toolCall.completeEvent = event;
+          toolCall.result = event.data?.result;
+          toolCall.exitCode = event.data?.exitCode;
+          toolCalls.push(toolCall);
+        }
+      }
+    }
+
+    return toolCalls;
+  }
+}
+
+module.exports = CopilotSessionParser;

package/lib/parsers/index.js

@@ -0,0 +1,13 @@
+const BaseSessionParser = require('./base-parser');
+const CopilotSessionParser = require('./copilot-parser');
+const ClaudeSessionParser = require('./claude-parser');
+const PiMonoParser = require('./pi-mono-parser');
+const ParserFactory = require('./parser-factory');
+
+module.exports = {
+  BaseSessionParser,
+  CopilotSessionParser,
+  ClaudeSessionParser,
+  PiMonoParser,
+  ParserFactory
+};

package/lib/parsers/parser-factory.js

@@ -0,0 +1,77 @@
+const CopilotSessionParser = require('./copilot-parser');
+const ClaudeSessionParser = require('./claude-parser');
+const PiMonoParser = require('./pi-mono-parser');
+
+/**
+ * Parser Factory
+ * 
+ * Automatically detects the session format and returns the appropriate parser
+ */
+class ParserFactory {
+  constructor() {
+    this.parsers = [
+      new CopilotSessionParser(),
+      new ClaudeSessionParser(),
+      new PiMonoParser()
+    ];
+    
+    // Name-to-parser mapping
+    this.parserMap = {
+      'copilot': new CopilotSessionParser(),
+      'claude': new ClaudeSessionParser(),
+      'pi-mono': new PiMonoParser()
+    };
+  }
+
+  /**
+   * Get parser by name or auto-detect from events
+   * @param {string|Array<Object>} nameOrEvents - Parser name or events array
+   * @returns {BaseSessionParser|null}
+   */
+  getParser(nameOrEvents) {
+    // If it's a string, get parser by name
+    if (typeof nameOrEvents === 'string') {
+      return this.parserMap[nameOrEvents] || null;
+    }
+    
+    // Otherwise, auto-detect from events
+    const events = nameOrEvents;
+    for (const parser of this.parsers) {
+      if (parser.canParse(events)) {
+        return parser;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Parse events using the appropriate parser
+   * @param {Array<Object>} events - Raw events from jsonl
+   * @returns {Object|null} Parsed session data or null if no parser found
+   */
+  parse(events) {
+    const parser = this.getParser(events);
+    if (!parser) {
+      return null;
+    }
+    return parser.parse(events);
+  }
+
+  /**
+   * Get parser type name
+   * @param {Array<Object>} events - Raw events from jsonl
+   * @returns {string|null} Parser name ('copilot', 'claude', 'pi-mono') or null
+   */
+  getParserType(events) {
+    const parser = this.getParser(events);
+    if (!parser) return null;
+    
+    if (parser instanceof CopilotSessionParser) return 'copilot';
+    if (parser instanceof ClaudeSessionParser) return 'claude';
+    if (parser instanceof PiMonoParser) return 'pi-mono';
+    
+    return 'unknown';
+  }
+}
+
+module.exports = ParserFactory;

package/lib/parsers/pi-mono-parser.js

@@ -0,0 +1,119 @@
+/**
+ * Pi-Mono session parser
+ * Parses ~/.pi/agent/sessions/ format
+ */
+
+const BaseParser = require('./base-parser');
+
+class PiMonoParser extends BaseParser {
+  constructor() {
+    super('pi-mono');
+  }
+
+  /**
+   * Parse Pi-Mono session directory
+   * @param {string} sessionDir - e.g., ~/.pi/agent/sessions/--project-path--/
+   * @returns {Object|null} - Session metadata or null if invalid
+   */
+  async parseSessionDir(sessionDir) {
+    const fs = require('fs').promises;
+    const path = require('path');
+
+    try {
+      // List .jsonl files in directory
+      const entries = await fs.readdir(sessionDir);
+      const jsonlFiles = entries.filter(f => f.endsWith('.jsonl'));
+
+      if (jsonlFiles.length === 0) {
+        return null;
+      }
+
+      // Use the latest file for metadata
+      jsonlFiles.sort().reverse();
+      const latestFile = path.join(sessionDir, jsonlFiles[0]);
+      const firstLine = await this._readFirstLine(latestFile);
+
+      if (!firstLine) {
+        return null;
+      }
+
+      const sessionEvent = JSON.parse(firstLine);
+      
+      if (sessionEvent.type !== 'session') {
+        console.warn(`Pi-Mono file ${latestFile} doesn't start with session event`);
+        return null;
+      }
+
+      // Extract project name from directory name
+      const dirName = path.basename(sessionDir);
+      const projectPath = dirName.replace(/^--/, '').replace(/--$/, '');
+
+      return {
+        id: sessionEvent.id,
+        type: 'pi-mono',
+        source: 'pi-mono',
+        cwd: sessionEvent.cwd || projectPath,
+        createdAt: new Date(sessionEvent.timestamp),
+        updatedAt: new Date(sessionEvent.timestamp), // Will be updated when scanning all files
+        summary: `Pi-Mono: ${projectPath}`,
+        fileCount: jsonlFiles.length
+      };
+    } catch (err) {
+      console.error(`Error parsing Pi-Mono session dir ${sessionDir}:`, err.message);
+      return null;
+    }
+  }
+
+  /**
+   * Read first line of a file
+   */
+  async _readFirstLine(filePath) {
+    const fs = require('fs');
+    const readline = require('readline');
+
+    return new Promise((resolve) => {
+      const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+      const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+      rl.on('line', (line) => {
+        rl.close();
+        stream.destroy();
+        resolve(line.trim());
+      });
+
+      rl.on('close', () => resolve(null));
+    });
+  }
+
+  /**
+   * Parse Pi-Mono events from .jsonl file
+   * @param {string} filePath
+   * @returns {Array} - Array of parsed events
+   */
+  async parseEvents(filePath) {
+    const fs = require('fs');
+    const readline = require('readline');
+
+    const events = [];
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+    let lineIndex = 0;
+    for await (const line of rl) {
+      lineIndex++;
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      try {
+        const event = JSON.parse(trimmed);
+        events.push(event);
+      } catch (err) {
+        console.error(`Error parsing Pi-Mono line ${lineIndex}:`, err.message);
+      }
+    }
+
+    return events;
+  }
+}
+
+module.exports = PiMonoParser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qiaolei81/copilot-session-viewer",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Web UI for viewing GitHub Copilot CLI session logs",
   "author": "Lei Qiao <qiaolei81@gmail.com>",
   "license": "MIT",
@@ -40,6 +40,7 @@
     "test:e2e:headed": "playwright test --headed",
     "test:e2e:debug": "playwright test --debug",
     "test:all": "npm test && npm run test:e2e",
+    "test:coverage:all": "npm run test:coverage && npm run test:e2e",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "lint:check": "eslint . --max-warnings 0",
@@ -50,25 +51,32 @@
   },
   "dependencies": {
     "compression": "^1.8.1",
-    "ejs": "^3.1.9",
+    "dompurify": "^3.3.1",
+    "ejs": "^4.0.1",
     "express": "^4.18.2",
     "express-rate-limit": "^8.2.1",
     "helmet": "^8.1.0",
-    "multer": "^2.0.2"
+    "multer": "^2.0.2",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@eslint/css": "^0.14.1",
     "@eslint/js": "^10.0.1",
     "@eslint/json": "^1.0.1",
     "@eslint/markdown": "^7.5.1",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@playwright/test": "^1.58.2",
     "@types/jest": "^30.0.0",
     "adm-zip": "^0.5.16",
     "eslint": "^10.0.0",
     "eslint-plugin-vue": "^10.8.0",
     "globals": "^17.3.0",
+    "istanbul-lib-coverage": "^3.2.2",
     "jest": "^30.2.0",
+    "jsdom": "^28.1.0",
     "nodemon": "^3.0.1",
-    "supertest": "^7.2.2"
+    "nyc": "^17.1.0",
+    "supertest": "^7.2.2",
+    "v8-to-istanbul": "^9.3.0"
   }
 }

package/server.js

@@ -1,4 +1,3 @@
-const path = require('path');
 const createApp = require('./src/app');
 const config = require('./src/config');
 const processManager = require('./src/utils/processManager');
@@ -13,9 +12,25 @@ module.exports = app;
 if (require.main === module) {
   const server = app.listen(config.PORT, () => {
     console.log(`🚀 Copilot Session Viewer running at http://localhost:${config.PORT}`);
-    console.log(`📂 Monitoring: ${process.env.SESSION_DIR || path.join(require('os').homedir(), '.copilot', 'session-state')}`);
+    console.log('📂 Session directories (env vars):');
+    console.log(`   COPILOT_SESSION_DIR=${process.env.COPILOT_SESSION_DIR || 'not set'}`);
+    console.log(`   CLAUDE_SESSION_DIR=${process.env.CLAUDE_SESSION_DIR || 'not set'}`);
+    console.log(`   PI_MONO_SESSION_DIR=${process.env.PI_MONO_SESSION_DIR || 'not set'}`);
+    console.log(`   SESSION_DIR=${process.env.SESSION_DIR || 'not set'} (legacy)`);
     console.log(`🔧 Environment: ${config.NODE_ENV}`);
     console.log(`⚡ Active processes: ${processManager.getActiveCount()}`);
+    
+    // Log sessions found
+    const SessionRepository = require('./src/services/sessionRepository');
+    const repo = new SessionRepository();
+    repo.findAll().then(sessions => {
+      console.log(`📊 Sessions found: ${sessions.length}`);
+      if (sessions.length > 0) {
+        console.log(`   First 5: ${sessions.slice(0, 5).map(s => s.id + ' (' + s.source + ')').join(', ')}`);
+      }
+    }).catch(err => {
+      console.error('❌ Error loading sessions:', err.message);
+    });
   });
 
   // Graceful shutdown