@qiaolei81/copilot-session-viewer 0.3.4 → 0.3.6

package/src/middleware/common.js

@@ -1,67 +0,0 @@
-const config = require('../config');
-const { trackException, isEnabled: isTelemetryEnabled } = require('../telemetry');
-
-// Request timeout middleware
-const requestTimeout = (req, res, next) => {
-  req.setTimeout(config.REQUEST_TIMEOUT_MS);
-  next();
-};
-
-// Telemetry middleware - makes telemetry settings available to templates
-const telemetryLocals = (req, res, next) => {
-  res.locals.telemetryEnabled = isTelemetryEnabled;
-  res.locals.telemetryConnectionString = isTelemetryEnabled
-    ? (process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || 'InstrumentationKey=39f4fbf1-d82f-42c3-b4ef-ea92a1fd82cb;IngestionEndpoint=https://eastus-8.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/;ApplicationId=7d4bb432-f2f5-4526-a5e6-31901e5a2db2')
-    : null;
-  next();
-};
-
-// CORS middleware for development
-const developmentCors = (req, res, next) => {
-  if (config.NODE_ENV === 'development') {
-    const allowedOrigins = ['http://localhost:3838', 'http://127.0.0.1:3838'];
-    const origin = req.headers.origin;
-    if (allowedOrigins.includes(origin)) {
-      res.header('Access-Control-Allow-Origin', origin);
-      res.header('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
-      res.header('Access-Control-Allow-Headers', 'Content-Type');
-    }
-  }
-  next();
-};
-
-// Error handling middleware
-const errorHandler = (err, req, res, _next) => {
-  console.error('Unhandled error:', err.stack);
-
-  // Track exception in Application Insights
-  trackException(err, {
-    url: req.url,
-    method: req.method,
-    statusCode: (err.status || 500).toString(),
-    userAgent: (req.headers && req.headers['user-agent']) || 'unknown'
-  });
-
-  const statusCode = err.status || 500;
-  // Default to production-safe behavior if NODE_ENV is not set
-  const isDevelopment = config.NODE_ENV === 'development';
-  const message = isDevelopment ? err.message : 'Internal server error';
-
-  res.status(statusCode).json({
-    error: message,
-    ...(isDevelopment && { stack: err.stack })
-  });
-};
-
-// 404 handler
-const notFoundHandler = (req, res) => {
-  res.status(404).json({ error: 'Not found' });
-};
-
-module.exports = {
-  requestTimeout,
-  developmentCors,
-  errorHandler,
-  notFoundHandler,
-  telemetryLocals
-};

package/src/middleware/rateLimiting.js

@@ -1,62 +0,0 @@
-const rateLimit = require('express-rate-limit');
-
-// Disable rate limiting in E2E tests (when NODE_ENV is test or when running via Playwright)
-const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.PLAYWRIGHT === '1';
-
-// Global rate limiting for all routes
-const globalLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000, // 15 minutes
-  max: isTestEnvironment ? 10000 : 100, // Much higher limit for tests
-  message: { error: 'Too many requests. Please try again later.' },
-  standardHeaders: true,
-  legacyHeaders: false,
-  skip: (req) => {
-    // Skip rate limiting entirely in test environment
-    if (isTestEnvironment) return true;
-
-    // Skip static files
-    if (req.path.startsWith('/public')) return true;
-
-    // Skip insight status checks (GET requests)
-    if (req.method === 'GET' && req.path.includes('/insight')) return true;
-
-    return false;
-  }
-});
-
-// Rate limiting for insight generation (stricter for POST)
-const insightGenerationLimiter = rateLimit({
-  windowMs: 5 * 60 * 1000, // 5 minutes (shorter window)
-  max: 3, // 3 generations per 5-minute window (expensive operations)
-  message: {
-    error: 'Too many insight generation requests. Please wait 5 minutes before generating another insight.',
-    retryAfter: 5 * 60 // 5 minutes in seconds
-  },
-  standardHeaders: true,
-  legacyHeaders: false
-});
-
-// Rate limiting for insight status/retrieval (very lenient for GET/DELETE)
-const insightAccessLimiter = rateLimit({
-  windowMs: 1 * 60 * 1000, // 1 minute (shorter window)
-  max: 50, // 50 requests per minute (very lenient)
-  message: { error: 'Too many insight requests. Please try again in a minute.' },
-  standardHeaders: true,
-  legacyHeaders: false
-});
-
-// Rate limiting for file uploads (strict)
-const uploadLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000, // 15 minutes
-  max: 5, // 5 uploads per window
-  message: { error: 'Too many upload requests. Please try again later.' },
-  standardHeaders: true,
-  legacyHeaders: false
-});
-
-module.exports = {
-  globalLimiter,
-  insightGenerationLimiter,
-  insightAccessLimiter,
-  uploadLimiter
-};

package/src/models/Session.js

@@ -1,146 +0,0 @@
-const path = require('path');
-
-/**
- * Session domain model
- */
-class Session {
-  constructor(id, type, options = {}) {
-    this.id = id;
-    this.type = type; // 'directory' or 'file'
-    this.source = options.source || 'copilot'; // 'copilot' or 'claude'
-    this.directory = options.directory || null; // Full path to session directory
-    this.filePath = options.filePath || null; // Full path to session file (for file-based sessions)
-    this.workspace = options.workspace || {};
-    this.createdAt = options.createdAt;
-    this.updatedAt = options.updatedAt;
-    this.summary = options.summary || (type === 'file' ? 'Legacy session' : 'No summary');
-    this.hasEvents = options.hasEvents || false;
-    this.eventCount = options.eventCount || 0;
-    this.duration = options.duration || null; // Duration in milliseconds
-    this.isImported = options.isImported || false; // Whether session was imported
-    this.hasInsight = options.hasInsight || false; // Whether session has insight report
-    this.copilotVersion = options.copilotVersion || null; // Copilot CLI version
-    this.selectedModel = options.selectedModel || null; // LLM model used
-    this.sessionStatus = options.sessionStatus || 'completed'; // 'completed' | 'wip'
-  }
-
-  /**
-   * Create Session from directory
-   * @param {string} dirPath - Directory path
-   * @param {string} id - Session ID
-   * @param {object} stats - fs.Stats object
-   * @param {object} workspace - Parsed workspace.yaml
-   * @param {number} eventCount - Number of events
-   * @param {number|null} duration - Duration in milliseconds
-   * @param {boolean} isImported - Whether session was imported
-   * @param {boolean} hasInsight - Whether session has insight report
-   * @param {string|null} copilotVersion - Copilot CLI version
-   * @param {string|null} selectedModel - LLM model used
-   * @param {string} sessionStatus - Session status: 'completed' or 'wip'
-   * @returns {Session}
-   */
-  static fromDirectory(dirPath, id, stats, workspace, eventCount, duration, isImported, hasInsight, copilotVersion, selectedModel, sessionStatus) {
-    const createdAt = workspace?.created_at
-      ? new Date(workspace.created_at)
-      : workspace?.startTime
-        ? new Date(workspace.startTime)
-        : stats.birthtime;
-    const updatedAt = workspace?.updated_at
-      ? new Date(workspace.updated_at)
-      : workspace?.endTime
-        ? new Date(workspace.endTime)
-        : stats.mtime;
-    return new Session(id, 'directory', {
-      directory: dirPath, // Add directory path
-      workspace: workspace,
-      createdAt,
-      updatedAt,
-      summary: workspace?.summary || 'No summary',
-      hasEvents: eventCount > 0,
-      eventCount: eventCount,
-      duration: duration,
-      isImported: isImported,
-      hasInsight: hasInsight,
-      copilotVersion: copilotVersion,
-      selectedModel: selectedModel,
-      sessionStatus: sessionStatus
-    });
-  }
-
-  /**
-   * Create Session from .jsonl file
-   * @param {string} filePath - File path
-   * @param {string} id - Session ID
-   * @param {object} stats - fs.Stats object
-   * @param {number} eventCount - Number of events
-   * @param {string} [summary] - Optional summary (e.g. first user message)
-   * @param {number|null} duration - Duration in milliseconds
-   * @param {string|null} copilotVersion - Copilot CLI version
-   * @param {string|null} selectedModel - LLM model used
-   * @param {string} sessionStatus - Session status: 'completed' or 'wip'
-   * @returns {Session}
-   */
-  static fromFile(filePath, id, stats, eventCount, summary, duration, copilotVersion, selectedModel, sessionStatus) {
-    return new Session(id, 'file', {
-      filePath: filePath,
-      directory: path.dirname(filePath), // Directory containing the file
-      createdAt: stats.birthtime,
-      updatedAt: stats.mtime,
-      summary: summary || 'Legacy session',
-      hasEvents: true,
-      eventCount: eventCount,
-      duration: duration,
-      isImported: false, // .jsonl files can't be imported
-      hasInsight: false,  // .jsonl files don't have insights
-      copilotVersion: copilotVersion,
-      selectedModel: selectedModel,
-      sessionStatus: sessionStatus
-    });
-  }
-
-  /**
-   * Convert to plain object
-   * @returns {object}
-   */
-  toJSON() {
-    // Generate display-ready source metadata (Violation #3 & #5 fix)
-    const sourceMetadata = this._getSourceDisplayMetadata(this.source);
-    
-    return {
-      id: this.id,
-      type: this.type,
-      source: this.source,
-      sourceName: sourceMetadata.name,
-      sourceBadgeClass: sourceMetadata.badgeClass,
-      directory: this.directory, // Include directory path
-      workspace: this.workspace,
-      createdAt: this.createdAt,
-      updatedAt: this.updatedAt,
-      summary: this.summary,
-      hasEvents: this.hasEvents,
-      eventCount: this.eventCount,
-      duration: this.duration,
-      isImported: this.isImported,
-      hasInsight: this.hasInsight,
-      copilotVersion: this.copilotVersion,
-      selectedModel: this.selectedModel,
-      sessionStatus: this.sessionStatus
-    };
-  }
-
-  /**
-   * Get display metadata for source
-   * @private
-   */
-  _getSourceDisplayMetadata(source) {
-    const metadata = {
-      'copilot': { name: 'Copilot CLI', badgeClass: 'source-copilot' },
-      'claude': { name: 'Claude', badgeClass: 'source-claude' },
-      'pi-mono': { name: 'Pi', badgeClass: 'source-pi-mono' },
-      'vscode': { name: 'Copilot Chat', badgeClass: 'source-vscode' }
-    };
-    return metadata[source] || { name: source, badgeClass: 'source-unknown' };
-  }
-}
-
-module.exports = Session;

package/src/routes/api.js

@@ -1,11 +0,0 @@
-const express = require('express');
-const SessionController = require('../controllers/sessionController');
-
-const router = express.Router();
-const sessionController = new SessionController();
-
-// API Routes
-router.get('/sessions', sessionController.getSessions.bind(sessionController));
-router.get('/sessions/:id/events', sessionController.getSessionEvents.bind(sessionController));
-
-module.exports = router;

package/src/routes/insights.js

@@ -1,12 +0,0 @@
-const express = require('express');
-const InsightController = require('../controllers/insightController');
-
-const router = express.Router();
-const insightController = new InsightController();
-
-// Insight Routes
-router.post('/session/:id/insight', insightController.generateInsight.bind(insightController));
-router.get('/session/:id/insight', insightController.getInsightStatus.bind(insightController));
-router.delete('/session/:id/insight', insightController.deleteInsight.bind(insightController));
-
-module.exports = router;

package/src/routes/pages.js

@@ -1,12 +0,0 @@
-const express = require('express');
-const SessionController = require('../controllers/sessionController');
-
-const router = express.Router();
-const sessionController = new SessionController();
-
-// Page Routes
-router.get('/', sessionController.getHomepage.bind(sessionController));
-router.get('/session/:id', sessionController.getSessionDetail.bind(sessionController));
-router.get('/session/:id/time-analyze', sessionController.getTimeAnalysis.bind(sessionController));
-
-module.exports = router;

package/src/routes/uploads.js

@@ -1,14 +0,0 @@
-const express = require('express');
-const UploadController = require('../controllers/uploadController');
-
-const router = express.Router();
-const uploadController = new UploadController();
-
-// Upload Routes
-router.get('/session/:id/share', uploadController.shareSession.bind(uploadController));
-router.post('/session/import',
-  (req, res, next) => uploadController.getUploadMiddleware()(req, res, next),
-  uploadController.importSession.bind(uploadController)
-);
-
-module.exports = router;

package/src/schemas/event.schema.js

@@ -1,73 +0,0 @@
-const { z } = require('zod');
-
-/**
- * Unified Event Schema for Copilot Session Viewer
- * 
- * This schema defines the standardized event format that the API returns to the frontend.
- * Both Copilot and Claude events are normalized to match this schema.
- */
-
-// Tool call schema (unified format for both Copilot and Claude)
-const ToolSchema = z.object({
-  type: z.literal('tool_use'),
-  id: z.string(),
-  name: z.string(),
-  input: z.record(z.any()),
-  result: z.any().optional(), // Tool execution result (when matched)
-  status: z.enum(['success', 'error', 'running']).optional(),
-  error: z.string().optional(),
-  _matched: z.boolean().optional() // Internal flag: whether result was matched
-});
-
-// Subagent metadata (for events belonging to a subagent)
-const SubagentMetadataSchema = z.object({
-  id: z.string(),
-  name: z.string()
-}).optional();
-
-// Event data schema (standardized data field)
-const EventDataSchema = z.object({
-  // Message content (text)
-  message: z.string().optional(),
-  text: z.string().optional(), // Alternative field name (legacy)
-  
-  // Tool calls (unified format)
-  tools: z.array(ToolSchema).optional(),
-  
-  // Original fields preserved for reference
-  // (Copilot-specific fields)
-  messageId: z.string().optional(),
-  content: z.string().optional(), // Original Copilot content field
-  toolRequests: z.array(z.any()).optional(), // Original Copilot toolRequests
-  
-  // (Claude-specific fields)
-  // ... other fields as needed
-}).passthrough(); // Allow additional fields
-
-// Base event schema
-const EventSchema = z.object({
-  // Core fields
-  type: z.string(),
-  id: z.string().optional(),
-  timestamp: z.string(),
-  parentId: z.string().nullable().optional(),
-  
-  // Standardized data
-  data: EventDataSchema.optional(),
-  
-  // Metadata
-  _subagent: SubagentMetadataSchema,
-  _fileIndex: z.number().optional(),
-  
-  // Virtual fields (computed by frontend)
-  stableId: z.string().optional(),
-  virtualIndex: z.number().optional()
-}).passthrough(); // Allow additional fields for flexibility
-
-// Export schemas
-module.exports = {
-  EventSchema,
-  EventDataSchema,
-  ToolSchema,
-  SubagentMetadataSchema
-};

package/src/services/eventNormalizer.js

@@ -1,291 +0,0 @@
-/**
- * EventNormalizer - Unified Event Format Transformer
- *
- * Converts tool events from different AI session formats (Copilot, Claude, Pi-Mono)
- * into a single, consistent schema for frontend consumption.
- *
- * Key transformations:
- * - Normalizes tool call structure to UnifiedToolCall schema
- * - Computes consistent status fields ('pending' | 'running' | 'completed' | 'error')
- * - Adds timing metadata (startTime, endTime, duration)
- * - Handles edge cases (orphaned events, missing fields)
- *
- * Usage:
- *   const normalizer = new EventNormalizer();
- *   const normalizedEvents = normalizer.normalizeEvents(rawEvents, 'copilot');
- */
-
-class EventNormalizer {
-  /**
-   * Normalize all events to unified format
-   * @param {Array} events - Raw events from parsers (after matching)
-   * @param {string} _source - 'copilot' | 'claude' | 'pi-mono'
-   * @returns {Array} - Normalized events
-   */
-  normalizeEvents(events, _source) {
-    if (!Array.isArray(events)) {
-      console.warn('[EventNormalizer] normalizeEvents: events is not an array', typeof events);
-      return [];
-    }
-
-    return events
-      .filter(event => {
-        // Filter out Claude tool_result wrappers (marked by sessionService._matchClaudeToolResults)
-        if (event._isToolResultWrapper) {
-          return false;
-        }
-        return true;
-      })
-      .map(event => this.normalizeEvent(event, _source));
-  }
-
-  /**
-   * Normalize a single event
-   * @param {Object} event - Raw event
-   * @param {string} source - Source format
-   * @returns {Object} - Normalized event
-   */
-  normalizeEvent(event, source) {
-    if (!event || typeof event !== 'object') {
-      console.warn('[EventNormalizer] normalizeEvent: invalid event', event);
-      return event;
-    }
-
-    // Handle assistant messages with tools
-    if (this._isAssistantMessage(event)) {
-      return this._normalizeAssistantMessage(event, source);
-    }
-
-    // Handle timeline events (tool.execution_start/complete, subagent events)
-    if (this._isTimelineEvent(event)) {
-      return this._normalizeTimelineEvent(event, source);
-    }
-
-    // Pass through other events unchanged
-    return event;
-  }
-
-  /**
-   * Check if event is an assistant message with tools (needs normalization)
-   * @private
-   */
-  _isAssistantMessage(event) {
-    // Check if event has tools array (works for all sources)
-    if (event.data?.tools && Array.isArray(event.data.tools) && event.data.tools.length > 0) {
-      return true;
-    }
-    // Fallback: check specific types (Copilot/Claude legacy)
-    return event.type === 'assistant.message' || event.type === 'assistant' || event.type === 'user.message' || event.type === 'user';
-  }
-
-  /**
-   * Check if event is a timeline event (tool/subagent events)
-   * @private
-   */
-  _isTimelineEvent(event) {
-    return event.type?.startsWith('tool.') || event.type?.startsWith('subagent.');
-  }
-
-  /**
-   * Normalize assistant message with embedded tools
-   * @private
-   */
-  _normalizeAssistantMessage(event, source) {
-    const normalized = { ...event };
-
-    // Normalize tools array if present
-    if (event.data?.tools && Array.isArray(event.data.tools)) {
-      normalized.data = {
-        ...event.data,
-        tools: event.data.tools
-          .filter(tool => tool.type !== 'tool_result')  // Filter out orphan tool_result
-          .map(tool => this._normalizeToolCall(tool, source, event.timestamp))
-      };
-    }
-
-    return normalized;
-  }
-
-  /**
-   * Normalize a tool call to unified schema
-   *
-   * UnifiedToolCall schema:
-   * {
-   *   id: string,
-   *   name: string,
-   *   startTime: string (ISO 8601),
-   *   endTime: string | null,
-   *   status: 'pending' | 'running' | 'completed' | 'error',
-   *   input: Record<string, any>,
-   *   result: string | null,
-   *   error: string | null,
-   *   metadata: {
-   *     source: string,
-   *     duration?: number,
-   *     ...
-   *   }
-   * }
-   *
-   * @private
-   */
-  _normalizeToolCall(tool, source, messageTimestamp) {
-    // Handle Copilot/Claude format with _matched flag
-    if (tool.type === 'tool_use') {
-      const status = this._computeStatus(tool);
-      const startTime = messageTimestamp;
-      const endTime = tool._matched ? messageTimestamp : null;
-
-      return {
-        type: 'tool_use',  // Preserve type for frontend compatibility
-        id: tool.id,
-        name: tool.name,
-        startTime,
-        endTime,
-        status,
-        input: tool.input || {},
-        result: tool.result || null,
-        error: tool.error || null,
-        metadata: {
-          source,
-          matched: tool._matched,
-          duration: this._computeDuration(startTime, endTime)
-        }
-      };
-    }
-
-    // Handle Pi-Mono format (already has status)
-    if (tool.name && tool.status) {
-      const startTime = messageTimestamp;
-      // Normalize 'success' to 'completed' for backward compatibility
-      const normalizedStatus = tool.status === 'success' ? 'completed' : tool.status;
-      const endTime = normalizedStatus === 'completed' || normalizedStatus === 'error'
-        ? messageTimestamp
-        : null;
-
-      return {
-        id: tool.id || this._generateToolId(),
-        name: tool.name,
-        startTime,
-        endTime,
-        status: normalizedStatus,
-        input: tool.input || {},
-        result: tool.isError ? null : (tool.result || null),
-        error: tool.isError ? tool.result : null,
-        metadata: {
-          source,
-          duration: this._computeDuration(startTime, endTime)
-        }
-      };
-    }
-
-    // Fallback: minimal normalization for unknown formats
-    console.warn('[EventNormalizer] Unknown tool format, applying fallback normalization', tool);
-    return {
-      id: tool.id || this._generateToolId(),
-      name: tool.name || 'unknown',
-      startTime: messageTimestamp,
-      endTime: null,
-      status: 'running',
-      input: tool.input || {},
-      result: null,
-      error: null,
-      metadata: {
-        source,
-        fallback: true
-      }
-    };
-  }
-
-  /**
-   * Compute tool status from tool object
-   * @private
-   */
-  _computeStatus(tool) {
-    // Explicit error indication
-    if (tool.error) {
-      return 'error';
-    }
-
-    // Has result = completed (regardless of _matched flag)
-    if (tool.result !== undefined && tool.result !== null && tool.result !== '') {
-      return 'completed';
-    }
-
-    // Explicitly unmatched with no result
-    if (tool._matched === false) {
-      return 'running';
-    }
-
-    // Matched = completed
-    if (tool._matched) {
-      return 'completed';
-    }
-
-    // No match info: assume running
-    return 'running';
-  }
-
-  /**
-   * Compute duration in milliseconds from start/end timestamps
-   * @private
-   */
-  _computeDuration(startTime, endTime) {
-    if (!startTime || !endTime) {
-      return undefined;
-    }
-
-    try {
-      const start = new Date(startTime);
-      const end = new Date(endTime);
-
-      if (isNaN(start.getTime()) || isNaN(end.getTime())) {
-        return undefined;
-      }
-
-      const duration = end.getTime() - start.getTime();
-      return duration >= 0 ? duration : undefined;
-    } catch (err) {
-      return undefined;
-    }
-  }
-
-  /**
-   * Generate a unique tool ID
-   * @private
-   */
-  _generateToolId() {
-    return `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Normalize timeline events (tool.execution_start/complete, subagent events)
-   * Ensures consistent schema for these events
-   * @private
-   */
-  _normalizeTimelineEvent(event) {
-    // For tool.execution_start/complete, ensure consistent schema
-    if (event.type === 'tool.execution_start' || event.type === 'tool.execution_complete') {
-      return {
-        ...event,
-        data: {
-          ...event.data,
-          // Normalize field names for consistency
-          toolCallId: event.data?.toolCallId || event.data?.id,
-          toolName: event.data?.toolName || event.data?.tool || event.data?.name,
-          // Preserve original fields
-          ...event.data
-        }
-      };
-    }
-
-    // Subagent events: pass through (already have consistent schema)
-    if (event.type?.startsWith('subagent.')) {
-      return event;
-    }
-
-    // Unknown timeline event: pass through
-    return event;
-  }
-}
-
-module.exports = EventNormalizer;