@qiaolei81/copilot-session-viewer 0.3.4 → 0.3.6

package/src/services/tagService.js

@@ -1,205 +0,0 @@
-const fs = require('fs').promises;
-const path = require('path');
-const os = require('os');
-
-/**
- * Service for managing session tags
- * - Per-session tags: stored in {session.directory}/tags.json as ["tag1", "tag2"]
- * - Global known tags: stored in ~/.session-viewer/known-tags.json as ["tag1", "tag2", ...]
- */
-class TagService {
-  constructor() {
-    this.knownTagsDir = path.join(os.homedir(), '.session-viewer');
-    this.knownTagsFilePath = path.join(this.knownTagsDir, 'known-tags.json');
-  }
-
-  /**
-   * Ensure known-tags directory and file exist
-   */
-  async ensureKnownTagsFile() {
-    try {
-      await fs.access(this.knownTagsFilePath);
-    } catch (err) {
-      // File doesn't exist, create directory and empty array
-      await fs.mkdir(this.knownTagsDir, { recursive: true });
-      await fs.writeFile(this.knownTagsFilePath, JSON.stringify([]), 'utf8');
-    }
-  }
-
-  /**
-   * Read known tags from global file
-   * @returns {Promise<string[]>} Array of known tags
-   */
-  async readKnownTagsFile() {
-    await this.ensureKnownTagsFile();
-    try {
-      const content = await fs.readFile(this.knownTagsFilePath, 'utf8');
-      return JSON.parse(content);
-    } catch (err) {
-      console.error('Error reading known tags file:', err);
-      return [];
-    }
-  }
-
-  /**
-   * Write known tags to global file
-   * @param {string[]} tags - Array of known tags
-   */
-  async writeKnownTagsFile(tags) {
-    await this.ensureKnownTagsFile();
-    await fs.writeFile(this.knownTagsFilePath, JSON.stringify(tags, null, 2), 'utf8');
-  }
-
-  /**
-   * Get tags file path for a session
-   * @param {Session} session - Session object with directory field
-   * @returns {string} Path to tags.json
-   */
-  getSessionTagsFilePath(session) {
-    // File-based sessions (e.g. Claude .jsonl): per-file tags to avoid sharing
-    if (session.filePath) {
-      const dir = path.dirname(session.filePath);
-      const base = path.basename(session.filePath, path.extname(session.filePath));
-      return path.join(dir, `${base}.tags.json`);
-    }
-    // Directory-based sessions (e.g. Copilot CLI): tags.json inside session dir
-    if (session.directory) {
-      return path.join(session.directory, 'tags.json');
-    }
-    // Fallback: store in central location by session id
-    return path.join(this.knownTagsDir, 'session-tags', `${session.id}.tags.json`);
-  }
-
-  /**
-   * Normalize tag name (lowercase, trim, max 30 chars)
-   * @param {string} tag - Tag name
-   * @returns {string} Normalized tag
-   */
-  normalizeTag(tag) {
-    return tag.trim().toLowerCase().substring(0, 30);
-  }
-
-  /**
-   * Get all known tags for autocomplete
-   * @returns {Promise<string[]>} Array of unique tags
-   */
-  async getAllKnownTags() {
-    const tags = await this.readKnownTagsFile();
-    return tags.sort();
-  }
-
-  /**
-   * Get tags for a specific session
-   * @param {Session} session - Session object with directory field
-   * @returns {Promise<string[]>} Array of tags
-   */
-  async getSessionTags(session) {
-    const tagsFilePath = this.getSessionTagsFilePath(session);
-
-    try {
-      await fs.access(tagsFilePath);
-      const content = await fs.readFile(tagsFilePath, 'utf8');
-      return JSON.parse(content);
-    } catch (err) {
-      // File doesn't exist or can't be read, return empty array
-      return [];
-    }
-  }
-
-  /**
-   * Set tags for a specific session
-   * @param {Session} session - Session object with directory field
-   * @param {string[]} tags - Array of tag names
-   * @returns {Promise<string[]>} Normalized and saved tags
-   */
-  async setSessionTags(session, tags) {
-    if (!Array.isArray(tags)) {
-      throw new Error('Tags must be an array');
-    }
-
-    // Normalize tags (lowercase, trim, max 30 chars)
-    const normalizedTags = tags
-      .map(tag => this.normalizeTag(tag))
-      .filter(tag => tag.length > 0)
-      .filter((tag, index, self) => self.indexOf(tag) === index); // Remove duplicates
-
-    // Enforce max 10 tags per session
-    if (normalizedTags.length > 10) {
-      throw new Error('Maximum 10 tags per session');
-    }
-
-    const tagsFilePath = this.getSessionTagsFilePath(session);
-
-    if (normalizedTags.length === 0) {
-      // Remove tags file if no tags
-      try {
-        await fs.unlink(tagsFilePath);
-      } catch (err) {
-        // File doesn't exist, ignore
-      }
-    } else {
-      // Ensure directory exists for tags file
-      await fs.mkdir(path.dirname(tagsFilePath), { recursive: true });
-      // Write tags to session directory
-      await fs.writeFile(tagsFilePath, JSON.stringify(normalizedTags, null, 2), 'utf8');
-
-      // Update known tags (append and deduplicate)
-      await this.updateKnownTags(normalizedTags);
-    }
-
-    return normalizedTags;
-  }
-
-  /**
-   * Update known tags by appending new tags and deduplicating
-   * @param {string[]} newTags - New tags to add to known tags
-   */
-  async updateKnownTags(newTags) {
-    const knownTags = await this.readKnownTagsFile();
-    const allTags = [...knownTags, ...newTags];
-    const uniqueTags = [...new Set(allTags)];
-    await this.writeKnownTagsFile(uniqueTags);
-  }
-
-  /**
-   * Add tags to a session (merge with existing)
-   * @param {Session} session - Session object with directory field
-   * @param {string[]} newTags - Tags to add
-   * @returns {Promise<string[]>} Updated tags array
-   */
-  async addSessionTags(session, newTags) {
-    const existingTags = await this.getSessionTags(session);
-    const mergedTags = [...existingTags, ...newTags];
-    return await this.setSessionTags(session, mergedTags);
-  }
-
-  /**
-   * Remove tags from a session
-   * @param {Session} session - Session object with directory field
-   * @param {string[]} tagsToRemove - Tags to remove
-   * @returns {Promise<string[]>} Updated tags array
-   */
-  async removeSessionTags(session, tagsToRemove) {
-    const existingTags = await this.getSessionTags(session);
-    const normalizedToRemove = tagsToRemove.map(tag => this.normalizeTag(tag));
-    const updatedTags = existingTags.filter(tag => !normalizedToRemove.includes(tag));
-    return await this.setSessionTags(session, updatedTags);
-  }
-
-  /**
-   * Get tags for multiple sessions (batch)
-   * @param {Session[]} sessions - Array of session objects
-   * @returns {Promise<Object>} Map of sessionId -> tags array
-   */
-  async getMultipleSessionTags(sessions) {
-    const result = {};
-
-    for (const session of sessions) {
-      result[session.id] = await this.getSessionTags(session);
-    }
-
-    return result;
-  }
-}
-
-module.exports = TagService;

package/src/telemetry.js

@@ -1,152 +0,0 @@
-/**
- * Application Insights Telemetry Module
- *
- * This module initializes and configures Application Insights for telemetry tracking.
- * Must be required BEFORE any other modules (especially Express) in server.js.
- *
- * Features:
- * - Auto-collection of requests, dependencies, exceptions, and performance counters
- * - Custom event and metric tracking
- * - Automatic disabling in test environments
- * - Support for manual disabling via DISABLE_TELEMETRY env var
- */
-
-const appInsights = require('applicationinsights');
-
-// Determine if telemetry should be disabled
-const isTestEnvironment = process.env.NODE_ENV === 'test';
-const isDisabled = process.env.DISABLE_TELEMETRY === 'true' || isTestEnvironment;
-
-// Default connection string (can be overridden via env var)
-const DEFAULT_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';
-
-let client = null;
-
-if (!isDisabled) {
-  try {
-    // Get connection string from environment or use default
-    const connectionString = process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || DEFAULT_CONNECTION_STRING;
-
-    // Setup and start Application Insights
-    appInsights.setup(connectionString)
-      .setAutoDependencyCorrelation(true)
-      .setAutoCollectRequests(true)
-      .setAutoCollectPerformance(true, true)
-      .setAutoCollectExceptions(true)
-      .setAutoCollectDependencies(true)
-      .setAutoCollectConsole(false) // Disable console tracking to avoid noise
-      .setUseDiskRetryCaching(true)
-      .setSendLiveMetrics(false) // Disable live metrics for local dev tool
-      .setDistributedTracingMode(appInsights.DistributedTracingModes.AI_AND_W3C)
-      .start();
-
-    client = appInsights.defaultClient;
-
-    // Set context properties
-    client.context.tags[client.context.keys.cloudRole] = 'copilot-session-viewer';
-    client.context.tags[client.context.keys.cloudRoleInstance] = require('os').hostname();
-
-    console.log('✅ Application Insights telemetry initialized');
-  } catch (error) {
-    console.error('❌ Failed to initialize Application Insights:', error.message);
-    // Continue without telemetry rather than crashing
-    client = createNoOpClient();
-  }
-} else {
-  // Return no-op client for test environment or when disabled
-  client = createNoOpClient();
-
-  if (isTestEnvironment) {
-    console.log('📊 Telemetry disabled (test environment)');
-  } else {
-    console.log('📊 Telemetry disabled (DISABLE_TELEMETRY=true)');
-  }
-}
-
-/**
- * Creates a no-op client that safely ignores all telemetry calls
- * Used when telemetry is disabled or in test environments
- */
-function createNoOpClient() {
-  return {
-    trackEvent: () => {},
-    trackMetric: () => {},
-    trackException: () => {},
-    trackTrace: () => {},
-    trackDependency: () => {},
-    trackRequest: () => {},
-    flush: (callback) => {
-      if (callback) callback();
-    }
-  };
-}
-
-/**
- * Track a custom event
- * @param {string} name - Event name
- * @param {Object} properties - Event properties
- */
-function trackEvent(name, properties = {}) {
-  if (client && client.trackEvent) {
-    client.trackEvent({
-      name,
-      properties
-    });
-  }
-}
-
-/**
- * Track a custom metric
- * @param {string} name - Metric name
- * @param {number} value - Metric value
- * @param {Object} properties - Additional properties
- */
-function trackMetric(name, value, properties = {}) {
-  if (client && client.trackMetric) {
-    client.trackMetric({
-      name,
-      value,
-      properties
-    });
-  }
-}
-
-/**
- * Track an exception
- * @param {Error} error - Error object
- * @param {Object} properties - Additional properties
- */
-function trackException(error, properties = {}) {
-  if (client && client.trackException) {
-    client.trackException({
-      exception: error,
-      properties
-    });
-  }
-}
-
-/**
- * Flush telemetry data (useful for short-lived processes)
- * @returns {Promise<void>}
- */
-function flush() {
-  return new Promise((resolve) => {
-    if (client && client.flush) {
-      client.flush({
-        callback: () => resolve()
-      });
-    } else {
-      resolve();
-    }
-  });
-}
-
-// Export the client and helper functions
-module.exports = {
-  client,
-  trackEvent,
-  trackMetric,
-  trackException,
-  flush,
-  isEnabled: !isDisabled
-};

package/src/utils/fileUtils.js

@@ -1,305 +0,0 @@
-const fs = require('fs').promises;
-const fsSync = require('fs');
-const readline = require('readline');
-
-/**
- * File utility functions
- */
-
-/**
- * Check if a file exists
- * @param {string} filePath - File path
- * @returns {Promise<boolean>}
- */
-async function fileExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Count lines in a file (non-empty lines only)
- * @param {string} filePath - File path
- * @returns {Promise<number>}
- */
-async function countLines(filePath) {
-  try {
-    const stream = fsSync.createReadStream(filePath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    let count = 0;
-    for await (const line of rl) {
-      if (line.trim()) count++;
-    }
-    return count;
-  } catch (err) {
-    console.error(`Error counting lines in ${filePath}:`, err.message);
-    return 0;
-  }
-}
-
-/**
- * Read and parse YAML file (simple key: value format)
- * @param {string} filePath - YAML file path
- * @returns {Promise<object>}
- */
-async function parseYAML(filePath) {
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    const lines = content.split('\n');
-    const result = {};
-
-    for (const line of lines) {
-      const match = line.match(/^(\w+):\s*(.+)$/);
-      if (match) {
-        result[match[1]] = match[2].trim();
-      }
-    }
-
-    return result;
-  } catch (err) {
-    console.error(`Error parsing YAML ${filePath}:`, err.message);
-    return {};
-  }
-}
-
-/**
- * Efficiently read session metadata in a single pass
- * Combines getFirstUserMessage, getSessionDuration, getSessionMetadata
- * @param {string} filePath - Path to .jsonl file
- * @param {number} maxMessageLength - Max characters for first message (default 200)
- * @returns {Promise<Object>} Combined metadata object
- */
-async function getSessionMetadataOptimized(filePath, maxMessageLength = 200) {
-  try {
-    const stream = fsSync.createReadStream(filePath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-    let firstUserMessage = '';
-    let firstTimestamp = null;
-    let lastTimestamp = null;
-    let copilotVersion = null;
-    let selectedModel = null;
-    let hasSessionEnd = false;
-
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-
-      try {
-        const event = JSON.parse(line);
-
-        // Extract timestamp for duration calculation
-        if (event.timestamp) {
-          const ts = new Date(event.timestamp).getTime();
-          if (!isNaN(ts)) {
-            if (!firstTimestamp) firstTimestamp = ts;
-            lastTimestamp = ts;
-          }
-        }
-
-        // Get first user message
-        if (!firstUserMessage && event.type === 'user.message') {
-          const msg = event.data?.message || event.data?.content || event.data?.text || '';
-          if (msg) {
-            firstUserMessage = msg.length > maxMessageLength ? msg.substring(0, maxMessageLength) + '...' : msg;
-          }
-        }
-
-        // Check for session.end event
-        if (event.type === 'session.end') {
-          hasSessionEnd = true;
-        }
-
-        // Get copilot version from session start
-        if (event.type === 'session.start' && event.data?.copilotVersion && !copilotVersion) {
-          copilotVersion = event.data.copilotVersion;
-        }
-
-        // Get selected model
-        if ((event.type === 'session.start' || event.type === 'session.model_change') && !selectedModel) {
-          if (event.data?.selectedModel) {
-            selectedModel = event.data.selectedModel;
-          } else if (event.data?.newModel) {
-            selectedModel = event.data.newModel;
-          } else if (event.data?.model) {
-            selectedModel = event.data.model;
-          }
-        }
-      } catch {
-        // Skip malformed JSON lines
-      }
-    }
-
-    rl.close();
-    stream.destroy();
-
-    // Calculate duration
-    const duration = firstTimestamp && lastTimestamp && lastTimestamp > firstTimestamp
-      ? lastTimestamp - firstTimestamp
-      : null;
-
-    return {
-      firstUserMessage: firstUserMessage || '',
-      duration,
-      copilotVersion: copilotVersion || null,
-      selectedModel: selectedModel || null,
-      hasSessionEnd,
-      lastEventTime: lastTimestamp,
-      firstEventTime: firstTimestamp
-    };
-  } catch (err) {
-    console.error(`Error reading session metadata from ${filePath}:`, err.message);
-    return {
-      firstUserMessage: '',
-      duration: null,
-      copilotVersion: null,
-      selectedModel: null,
-      hasSessionEnd: false,
-      lastEventTime: null
-    };
-  }
-}
-
-/**
- * Get the first user message from a .jsonl events file
- * Reads line by line and stops at the first user.message event
- * @param {string} filePath - Path to .jsonl file
- * @param {number} maxLength - Max characters to return (default 200)
- * @returns {Promise<string>} First user message or empty string
- */
-async function getFirstUserMessage(filePath, maxLength = 200) {
-  try {
-    const stream = fsSync.createReadStream(filePath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      try {
-        const event = JSON.parse(line);
-        if (event.type === 'user.message') {
-          const msg = event.data?.message || event.data?.content || event.data?.text || '';
-          if (msg) {
-            rl.close();
-            stream.destroy();
-            return msg.length > maxLength ? msg.substring(0, maxLength) + '...' : msg;
-          }
-        }
-      } catch {
-        // Skip malformed JSON lines
-      }
-    }
-    return '';
-  } catch (_err) {
-    return '';
-  }
-}
-
-/**
- * Get session duration by reading first and last event timestamps
- * @param {string} filePath - Path to .jsonl events file
- * @returns {Promise<number|null>} Duration in milliseconds, or null if unable to calculate
- */
-async function getSessionDuration(filePath) {
-  try {
-    const stream = fsSync.createReadStream(filePath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-    let firstTimestamp = null;
-    let lastTimestamp = null;
-
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      try {
-        const event = JSON.parse(line);
-        if (event.timestamp) {
-          const ts = new Date(event.timestamp).getTime();
-          if (!firstTimestamp) {
-            firstTimestamp = ts;
-          }
-          lastTimestamp = ts;
-        }
-      } catch {
-        // Skip malformed JSON lines
-      }
-    }
-
-    if (firstTimestamp && lastTimestamp && lastTimestamp >= firstTimestamp) {
-      return lastTimestamp - firstTimestamp;
-    }
-    return null;
-  } catch (err) {
-    console.error(`Error calculating session duration for ${filePath}:`, err.message);
-    return null;
-  }
-}
-
-/**
- * Get session metadata from session.start event
- * @param {string} filePath - Path to .jsonl events file
- * @returns {Promise<{copilotVersion: string|null, selectedModel: string|null}>}
- */
-async function getSessionMetadata(filePath) {
-  try {
-    const stream = fsSync.createReadStream(filePath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-    let copilotVersion = null;
-    let selectedModel = null;
-
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      try {
-        const event = JSON.parse(line);
-        
-        // Extract copilotVersion and selectedModel from session.start
-        if (event.type === 'session.start' && event.data) {
-          copilotVersion = event.data.copilotVersion || null;
-          selectedModel = event.data.selectedModel || null;
-          
-          // If we have selectedModel, we're done
-          if (selectedModel) {
-            rl.close();
-            stream.destroy();
-            return { copilotVersion, selectedModel };
-          }
-        }
-        
-        // If no selectedModel in session.start, check for model_change
-        if (!selectedModel && event.type === 'session.model_change' && event.data) {
-          selectedModel = event.data.newModel || null;
-          rl.close();
-          stream.destroy();
-          return { copilotVersion, selectedModel };
-        }
-      } catch {
-        // Skip malformed JSON lines
-      }
-    }
-    return { copilotVersion, selectedModel };
-  } catch (err) {
-    console.error(`Error reading session metadata from ${filePath}:`, err.message);
-    return { copilotVersion: null, selectedModel: null };
-  }
-}
-
-/**
- * Check if entry should be skipped
- * @param {string} entry - Directory/file name
- * @returns {boolean}
- */
-function shouldSkipEntry(entry) {
-  return entry === '.DS_Store' || entry.startsWith('.');
-}
-
-module.exports = {
-  fileExists,
-  countLines,
-  parseYAML,
-  getFirstUserMessage,
-  getSessionDuration,
-  getSessionMetadata,
-  getSessionMetadataOptimized, // New optimized function
-  shouldSkipEntry
-};

package/src/utils/helpers.js

@@ -1,45 +0,0 @@
-/**
- * Helper utilities for server routes
- */
-
-/**
- * Build metadata object from session
- * @param {Session} session - Session model instance
- * @returns {Object} Metadata object
- */
-function buildMetadata(session) {
-  const json = session.toJSON ? session.toJSON() : {};
-  return {
-    type: session.type,
-    source: session.source, // 'copilot' or 'claude'
-    sourceName: json.sourceName || session.source,
-    sourceBadgeClass: json.sourceBadgeClass || 'source-unknown',
-    summary: session.summary,
-    model: session.selectedModel || session.model,
-    repo: session.workspace?.repository,
-    branch: session.workspace?.branch,
-    cwd: session.workspace?.cwd,
-    created: session.createdAt,
-    updated: session.updatedAt,
-    copilotVersion: session.copilotVersion,
-    sessionStatus: session.sessionStatus
-  };
-}
-
-/**
- * Validate session ID to prevent path traversal
- * @param {string} sessionId - Session identifier
- * @returns {boolean} True if valid
- */
-function isValidSessionId(sessionId) {
-  // Allow alphanumeric, underscore, and hyphen (common in UUIDs and session IDs)
-  // Length limit prevents abuse
-  return typeof sessionId === 'string' && 
-         /^[a-zA-Z0-9_-]+$/.test(sessionId) && 
-         sessionId.length < 256;
-}
-
-module.exports = {
-  buildMetadata,
-  isValidSessionId
-};