@qiaolei81/copilot-session-viewer 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.2] - 2026-03-08
+
+### Fixed
+- **VSCode Session Duration** - Duration now uses the last `terminalCommandState.timestamp` (when the agent actually executed a command) instead of a `toolCount × 3500ms` heuristic. Long-running agentic sessions that span multiple hours are now measured correctly
+- **VSCode Multi-Workspace Dedup** - `_findVsCodeSession` now collects candidates from all matching workspace hashes and returns the one with the latest effective end time (most complete data), instead of returning the first match found
+- **Session `createdAt` in CI** - `Session.fromDirectory` now reads `startTime`/`endTime` from `workspace.yaml` (in addition to `created_at`/`updated_at`), fixing `createdAt` being undefined in environments where `stats.birthtime` is unavailable
+
+### Refactored
+- **`_buildVsCodeSession()`** - Extracted shared VSCode session construction logic into a single method used by both the main scan loop and `_findVsCodeSession`, eliminating duplicate `effectiveEnd2`/`toolCount2` variables
+
 ## [0.3.1] - 2026-03-07
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qiaolei81/copilot-session-viewer",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Web UI for viewing GitHub Copilot CLI session logs",
   "author": "Lei Qiao <qiaolei81@gmail.com>",
   "license": "MIT",

package/src/models/Session.js

@@ -40,11 +40,21 @@ class Session {
    * @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: workspace?.created_at || stats.birthtime,
-      updatedAt: workspace?.updated_at || stats.mtime,
+      createdAt,
+      updatedAt,
       summary: workspace?.summary || 'No summary',
       hasEvents: eventCount > 0,
       eventCount: eventCount,

package/src/services/sessionRepository.js

@@ -512,6 +512,8 @@ class SessionRepository {
   async _findVsCodeSession(sessionId, workspaceStorageDir) {
     try {
       const hashes = await fs.readdir(workspaceStorageDir);
+      const candidates = [];
+
       for (const hash of hashes) {
         const chatSessionsDir = path.join(workspaceStorageDir, hash, 'chatSessions');
         try {
@@ -529,58 +531,24 @@ class SessionRepository {
               sessionJson = JSON.parse(raw);
             }
             const requests = sessionJson.requests || [];
-            if (requests.length === 0) return null;
-
-            const firstReq = requests[0];
-            const createdAt = sessionJson.creationDate
-              ? new Date(sessionJson.creationDate)
-              : (firstReq.timestamp ? new Date(firstReq.timestamp) : stats.birthtime);
-            const lastReqTime2 = requests[requests.length - 1].timestamp ? new Date(requests[requests.length - 1].timestamp) : null;
-            const updatedAt = sessionJson.lastMessageDate
-              ? new Date(sessionJson.lastMessageDate)
-              : (lastReqTime2 || stats.mtime);
-            const userText = this._extractVsCodeUserText(firstReq.message);
-
-            const copilotChatVersion = firstReq.agent?.extensionVersion || null;
-            const realWorkspacePath = await this._resolveVsCodeWorkspacePath(path.join(workspaceStorageDir, hash));
+            if (requests.length === 0) continue;
 
-            // Same estimation logic as scan path
-            const _fileMtime2 = stats.mtime;
-            // Count tools for estimation
-            let toolCount2 = 0;
-            for (const req of requests) {
-              toolCount2 += (req.response || []).filter(r => r.kind === 'toolInvocationSerialized').length;
-            }
-            let effectiveEnd2;
-            if (toolCount2 > 10 && lastReqTime2) {
-              const estimatedDurationMs2 = Math.max(toolCount2 * 3500, 60000);
-              effectiveEnd2 = new Date(createdAt.getTime() + estimatedDurationMs2);
-            } else if (lastReqTime2) {
-              effectiveEnd2 = lastReqTime2;
-            } else {
-              effectiveEnd2 = updatedAt;
-            }
-
-            return new Session(sessionId, 'file', {
-              source: 'vscode',
-              filePath: fullPath,
-              workspaceHash: hash,
-              createdAt,
-              updatedAt: effectiveEnd2,
-              summary: userText ? userText.slice(0, 120) : `VSCode chat (${requests.length} requests)`,
-              hasEvents: true,
-              eventCount: requests.reduce((s, r) => s + (r.response || []).length, 0) + requests.length * 2 + 1,
-              duration: effectiveEnd2.getTime() - createdAt.getTime(),
-              sessionStatus: ((Date.now() - effectiveEnd2.getTime()) < 15 * 60 * 1000 || (Date.now() - stats.mtime.getTime()) < 15 * 60 * 1000) ? 'wip' : 'completed',
-              selectedModel: firstReq.modelId || null,
-              copilotVersion: copilotChatVersion,
-              workspace: { cwd: realWorkspacePath || path.join(workspaceStorageDir, hash) },
-            });
+            const realWorkspacePath = await this._resolveVsCodeWorkspacePath(path.join(workspaceStorageDir, hash));
+            const statsWithPath = { ...stats, filePath: fullPath };
+            candidates.push(this._buildVsCodeSession(
+              sessionId, requests, sessionJson, statsWithPath, hash,
+              realWorkspacePath || path.join(workspaceStorageDir, hash)
+            ));
           }
         } catch {
           // No chatSessions dir or can't read — skip
         }
       }
+      // Return the candidate with the latest effectiveEndTime (most complete data)
+      if (candidates.length > 0) {
+        candidates.sort((a, b) => (b.updatedAt?.getTime?.() ?? 0) - (a.updatedAt?.getTime?.() ?? 0));
+        return candidates[0];
+      }
     } catch (err) {
       console.error(`[VSCode findById] Error searching VSCode sessions: ${err.message}`, err.stack);
     }
@@ -685,6 +653,15 @@ class SessionRepository {
       if (!workspace.summary && optimizedMetadata.firstUserMessage) {
         workspace.summary = optimizedMetadata.firstUserMessage;
       }
+
+      // Use max of filesystem mtime and last event timestamp for updatedAt
+      if (optimizedMetadata.lastEventTime) {
+        const lastEventMs = new Date(optimizedMetadata.lastEventTime).getTime();
+        const mtimeMs = new Date(stats.mtime).getTime();
+        if (lastEventMs > mtimeMs) {
+          stats = { ...stats, mtime: new Date(lastEventMs) };
+        }
+      }
     }
 
     const session = Session.fromDirectory(fullPath, entry, stats, workspace, eventCount, duration, isImported, hasInsight, copilotVersion, selectedModel, sessionStatus);
@@ -727,7 +704,7 @@ class SessionRepository {
       return 'completed';
     }
     if (metadata.lastEventTime !== null && metadata.lastEventTime !== undefined) {
-      const WIP_THRESHOLD_MS = 15 * 60 * 1000;
+      const WIP_THRESHOLD_MS = 5 * 60 * 1000;
       if ((Date.now() - metadata.lastEventTime) < WIP_THRESHOLD_MS) {
         return 'wip';
       }
@@ -962,68 +939,11 @@ class SessionRepository {
         const requests = sessionJson.requests || [];
         if (requests.length === 0) continue;
 
-        const firstReq = requests[0];
-        const lastReq = requests[requests.length - 1];
-        const createdAt = sessionJson.creationDate
-          ? new Date(sessionJson.creationDate)
-          : (firstReq.timestamp ? new Date(firstReq.timestamp) : stats.birthtime);
-        const lastReqTime = lastReq.timestamp ? new Date(lastReq.timestamp) : null;
-        const updatedAt = sessionJson.lastMessageDate
-          ? new Date(sessionJson.lastMessageDate)
-          : (lastReqTime || stats.mtime);
-
-        // Count tool invocations across all requests (must be before effectiveEndTime calc)
-        let toolCount = 0;
-        for (const req of requests) {
-          toolCount += (req.response || []).filter(r => r.kind === 'toolInvocationSerialized').length;
-        }
-
-        // For VSCode agentic sessions, file mtime may be more accurate than last request timestamp
-        // because sub-agents write incremental updates over time without new request timestamps.
-        // BUT: VSCode may touch/sync all files at once, creating misleading mtimes.
-        // Strategy: 
-        //   - If session has many tool invocations (agentic), estimate duration from tool count
-        //   - Otherwise fall back to request timestamps
-        const _fileMtime = stats.mtime;
-        let effectiveEndTime;
-        if (toolCount > 10 && lastReqTime) {
-          // Agentic session: estimate ~3.5s per tool invocation as a rough heuristic
-          const estimatedDurationMs = Math.max(toolCount * 3500, 60000); // at least 1 min
-          const estimatedEnd = new Date(createdAt.getTime() + estimatedDurationMs);
-          effectiveEndTime = estimatedEnd;
-        } else if (lastReqTime) {
-          effectiveEndTime = lastReqTime;
-        } else {
-          effectiveEndTime = updatedAt;
-        }
-
-        const model = firstReq.modelId || null;
-        const agentId = firstReq.agent?.id || 'vscode-copilot';
-        const copilotChatVersion = firstReq.agent?.extensionVersion || null;
-        const userText = this._extractVsCodeUserText(firstReq.message);
-
-        const session = new Session(
-          sessionId,
-          'file',
-          {
-            source: 'vscode',
-            filePath: fullPath,
-            workspaceHash,
-            createdAt,
-            updatedAt: effectiveEndTime,
-            summary: userText ? userText.slice(0, 120) : `VSCode chat (${requests.length} requests)`,
-            hasEvents: true,
-            eventCount: requests.reduce((s, r) => s + (r.response || []).length, 0) + requests.length * 2 + 1,
-            duration: effectiveEndTime.getTime() - createdAt.getTime(),
-            sessionStatus: ((Date.now() - effectiveEndTime.getTime()) < 15 * 60 * 1000 || (Date.now() - stats.mtime.getTime()) < 15 * 60 * 1000) ? 'wip' : 'completed',
-            selectedModel: model,
-            agentId,
-            toolCount,
-            copilotVersion: copilotChatVersion,
-            workspace: { cwd: realWorkspacePath || workspaceHashDir },
-          }
+        const statsWithPath = { ...stats, filePath: fullPath };
+        const session = this._buildVsCodeSession(
+          sessionId, requests, sessionJson, statsWithPath, workspaceHash,
+          realWorkspacePath || workspaceHashDir
         );
-
         sessions.push(session);
       } catch (err) {
         // Skip malformed files silently
@@ -1033,6 +953,76 @@ class SessionRepository {
   }
 
   /** Extract plain text from a VSCode message object */
+  /**
+   * Build a VSCode Session object from parsed JSONL data.
+   * Single source of truth for VSCode session construction — used by both
+   * the main scan loop and _findVsCodeSession to avoid duplicate logic.
+   * @private
+   */
+  _buildVsCodeSession(sessionId, requests, sessionJson, stats, workspaceHash, workspaceCwd) {
+    const firstReq = requests[0];
+    const lastReq = requests[requests.length - 1];
+
+    const createdAt = sessionJson.creationDate
+      ? new Date(sessionJson.creationDate)
+      : (firstReq.timestamp ? new Date(firstReq.timestamp) : stats.birthtime);
+
+    const lastReqTime = lastReq.timestamp ? new Date(lastReq.timestamp) : null;
+    const fallbackUpdatedAt = sessionJson.lastMessageDate
+      ? new Date(sessionJson.lastMessageDate)
+      : (lastReqTime || stats.mtime);
+
+    // Use last terminal command timestamp (truest end time for agentic sessions).
+    // terminalCommandState.timestamp = when the agent actually executed a command.
+    // request.timestamp = when the user sent the message (start of turn, not end).
+    // mtime is unreliable — VSCode syncs/touches all files when the workspace opens.
+    const lastTerminalTime = this._extractLastTerminalTimestamp(requests);
+    const effectiveEndTime = lastTerminalTime || lastReqTime || fallbackUpdatedAt;
+
+    const isWip = (Date.now() - effectiveEndTime.getTime()) < 15 * 60 * 1000;
+    const userText = this._extractVsCodeUserText(firstReq.message);
+    const toolCount = requests.reduce(
+      (sum, req) => sum + (req.response || []).filter(r => r.kind === 'toolInvocationSerialized').length,
+      0
+    );
+
+    return new Session(sessionId, 'file', {
+      source: 'vscode',
+      filePath: stats.filePath,
+      workspaceHash,
+      createdAt,
+      updatedAt: effectiveEndTime,
+      summary: userText ? userText.slice(0, 120) : `VSCode chat (${requests.length} requests)`,
+      hasEvents: true,
+      eventCount: requests.reduce((s, r) => s + (r.response || []).length, 0) + requests.length * 2 + 1,
+      duration: effectiveEndTime.getTime() - createdAt.getTime(),
+      sessionStatus: isWip ? 'wip' : 'completed',
+      selectedModel: firstReq.modelId || null,
+      agentId: firstReq.agent?.id || 'vscode-copilot',
+      toolCount,
+      copilotVersion: firstReq.agent?.extensionVersion || null,
+      workspace: { cwd: workspaceCwd },
+    });
+  }
+
+  _extractLastTerminalTimestamp(requests) {
+    let maxTs = 0;
+
+    function walk(obj) {
+      if (!obj || typeof obj !== 'object') return;
+      if (Array.isArray(obj)) { obj.forEach(walk); return; }
+      if (obj.terminalCommandState && typeof obj.terminalCommandState.timestamp === 'number') {
+        const ts = obj.terminalCommandState.timestamp;
+        if (ts > 1_000_000_000_000 && ts < 9_999_999_999_999 && ts > maxTs) maxTs = ts;
+      }
+      for (const val of Object.values(obj)) walk(val);
+    }
+
+    for (const req of requests) walk(req.response);
+
+    return maxTs > 0 ? new Date(maxTs) : null;
+  }
+
   _extractVsCodeUserText(message) {
     if (!message) return '';
     if (typeof message.text === 'string') return message.text;

package/src/utils/fileUtils.js

@@ -146,7 +146,8 @@ async function getSessionMetadataOptimized(filePath, maxMessageLength = 200) {
       copilotVersion: copilotVersion || null,
       selectedModel: selectedModel || null,
       hasSessionEnd,
-      lastEventTime: lastTimestamp
+      lastEventTime: lastTimestamp,
+      firstEventTime: firstTimestamp
     };
   } catch (err) {
     console.error(`Error reading session metadata from ${filePath}:`, err.message);