@qiaolei81/copilot-session-viewer 0.2.7 → 0.3.0

package/src/services/sessionRepository.js

@@ -20,31 +20,30 @@ class SessionRepository {
     } else if (Array.isArray(sessionDirs)) {
       this.sources = sessionDirs;
     } else {
-      // Default: Copilot + Claude + Pi-Mono
+      // Default: Copilot + Claude + Pi-Mono + VSCode
       // Support environment variables for each source (useful for testing/CI)
       this.sources = [
         {
           type: 'copilot',
-          dir: process.env.COPILOT_SESSION_DIR || 
+          dir: process.env.COPILOT_SESSION_DIR ||
                process.env.SESSION_DIR || // Legacy fallback
                path.join(os.homedir(), '.copilot', 'session-state')
         },
         {
           type: 'claude',
-          dir: process.env.CLAUDE_SESSION_DIR || 
+          dir: process.env.CLAUDE_SESSION_DIR ||
                path.join(os.homedir(), '.claude', 'projects')
         },
         {
           type: 'pi-mono',
-          dir: process.env.PI_MONO_SESSION_DIR || 
+          dir: process.env.PI_MONO_SESSION_DIR ||
                path.join(os.homedir(), '.pi', 'agent', 'sessions')
         },
-        // TODO: VSCode parser disabled
-        // {
-        //   type: 'vscode',
-        //   dir: process.env.VSCODE_WORKSPACE_STORAGE_DIR ||
-        //        path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'workspaceStorage')
-        // }
+        {
+          type: 'vscode',
+          dir: process.env.VSCODE_WORKSPACE_STORAGE_DIR ||
+               path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'workspaceStorage')
+        }
       ];
     }
     
@@ -111,10 +110,11 @@ class SessionRepository {
           if (stats.isDirectory()) {
             return this._scanPiMonoDir(fullPath, entry);
           }
-        // } else if (source.type === 'vscode') { // TODO: VSCode disabled
-        //   if (stats.isDirectory()) {
-        //     return this._scanVsCodeWorkspaceDir(fullPath);
-        //   }
+        } else if (source.type === 'vscode') {
+          // VSCode: workspace hash directories containing chatSessions/*.jsonl
+          if (stats.isDirectory()) {
+            return this._scanVsCodeWorkspaceDir(fullPath);
+          }
         }
         return null;
       });
@@ -274,8 +274,8 @@ class SessionRepository {
         session = await this._findClaudeSession(sessionId, source.dir);
       } else if (source.type === 'pi-mono') {
         session = await this._findPiMonoSession(sessionId, source.dir);
-      // } else if (source.type === 'vscode') { // TODO: VSCode disabled
-      //   session = await this._findVsCodeSession(sessionId, source.dir);
+      } else if (source.type === 'vscode') {
+        session = await this._findVsCodeSession(sessionId, source.dir);
       }
 
       if (session) return session;
@@ -470,23 +470,46 @@ class SessionRepository {
             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)
-              : stats.mtime;
+              : (lastReqTime2 || stats.mtime);
             const userText = this._extractVsCodeUserText(firstReq.message);
 
+            const copilotChatVersion = firstReq.agent?.extensionVersion || null;
+            const realWorkspacePath = await this._resolveVsCodeWorkspacePath(path.join(workspaceStorageDir, hash));
+
+            // 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,
+              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: updatedAt - createdAt,
-              sessionStatus: 'completed',
-              model: firstReq.modelId || null,
-              workspace: { cwd: path.join(workspaceStorageDir, hash) },
+              duration: effectiveEnd2.getTime() - createdAt.getTime(),
+              sessionStatus: (Date.now() - effectiveEnd2.getTime()) < 5 * 60 * 1000 ? 'wip' : 'completed',
+              selectedModel: firstReq.modelId || null,
+              copilotVersion: copilotChatVersion,
+              workspace: { cwd: realWorkspacePath || path.join(workspaceStorageDir, hash) },
             });
           }
         } catch {
@@ -845,6 +868,9 @@ class SessionRepository {
       return []; // No chatSessions subfolder — skip silently
     }
 
+    // Extract workspace hash from directory name
+    const workspaceHash = path.basename(workspaceHashDir);
+
     // Resolve the real project path from workspace.json
     const realWorkspacePath = await this._resolveVsCodeWorkspacePath(workspaceHashDir);
 
@@ -876,18 +902,39 @@ class SessionRepository {
         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)
-          : (lastReq.timestamp ? new Date(lastReq.timestamp) : stats.mtime);
+          : (lastReqTime || stats.mtime);
 
-        // Count tool invocations across all requests
+        // 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(
@@ -896,16 +943,18 @@ class SessionRepository {
           {
             source: 'vscode',
             filePath: fullPath,
+            workspaceHash,
             createdAt,
-            updatedAt,
+            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: updatedAt - createdAt,
-            sessionStatus: 'completed',
-            model,
+            duration: effectiveEndTime.getTime() - createdAt.getTime(),
+            sessionStatus: (Date.now() - effectiveEndTime.getTime()) < 5 * 60 * 1000 ? 'wip' : 'completed',
+            selectedModel: model,
             agentId,
             toolCount,
+            copilotVersion: copilotChatVersion,
             workspace: { cwd: realWorkspacePath || workspaceHashDir },
           }
         );

package/src/services/sessionService.js

@@ -151,24 +151,72 @@ class SessionService {
         console.error('Error searching Pi-Mono sessions:', err);
         return [];
       }
-    // } else if (session.source === 'vscode') { // TODO: VSCode disabled
-    //   const { VsCodeParser } = require('../../lib/parsers');
-    //   const vscodeParser = new VsCodeParser();
-    //   try {
-    //     const raw = await fs.promises.readFile(session.filePath, 'utf-8');
-    //     let sessionJson;
-    //     if (session.filePath.endsWith('.jsonl')) {
-    //       sessionJson = this.sessionRepository._parseVsCodeJsonl(raw);
-    //     } else {
-    //       sessionJson = JSON.parse(raw);
-    //     }
-    //     if (!sessionJson) return [];
-    //     const parsed = vscodeParser.parseVsCode(sessionJson);
-    //     return this._expandVsCodeEvents(parsed.allEvents);
-    //   } catch (err) {
-    //     console.error('Error reading VSCode session:', err);
-    //     return [];
-    //   }
+    } else if (session.source === 'vscode') {
+      // VSCode format: Read JSONL file and parse with VsCodeParser
+      const { VsCodeParser } = require('../../lib/parsers');
+      const vscodeParser = new VsCodeParser();
+      try {
+        const raw = await fs.promises.readFile(session.filePath, 'utf-8');
+        const lines = raw.trim().split('\n').filter(line => line.trim());
+        const parsedLines = lines.map(line => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return null;
+          }
+        }).filter(l => l !== null);
+
+        if (parsedLines.length === 0) return [];
+
+        // Use parseJsonl for new JSONL format, or parseVsCode for old JSON format
+        let parsed;
+        if (vscodeParser.canParse(parsedLines)) {
+          // New JSONL format
+          parsed = vscodeParser.parseJsonl(parsedLines);
+        } else {
+          // Old JSON format (single object)
+          const sessionJson = JSON.parse(raw);
+          parsed = vscodeParser.parseVsCode(sessionJson);
+        }
+
+        let events = this._expandVsCodeEvents(parsed.allEvents);
+
+        // Bug fix #2: Use file modification time as session end time
+        // VSCode sessions only record request.timestamp, not completion time
+        // For agentic sessions with sub-agents, actual work takes much longer
+        if (events.length > 0) {
+          try {
+            const stats = await fs.promises.stat(session.filePath);
+            const fileMtime = new Date(stats.mtime).toISOString();
+
+            // Check if the last event timestamp is much earlier than file mtime
+            const lastEvent = events[events.length - 1];
+            if (lastEvent && lastEvent.timestamp) {
+              const lastEventTime = new Date(lastEvent.timestamp).getTime();
+              const fileTime = new Date(fileMtime).getTime();
+              const diffSeconds = (fileTime - lastEventTime) / 1000;
+
+              // If difference is more than 10 seconds, use file mtime as end time
+              if (diffSeconds > 10) {
+                // Update the last event's timestamp to file modification time
+                lastEvent.timestamp = fileMtime;
+                console.log(`[VSCode] Updated session ${session.id} end time to file mtime (${diffSeconds.toFixed(0)}s difference)`);
+              }
+            }
+          } catch (err) {
+            console.error('[VSCode] Error getting file mtime:', err);
+          }
+        }
+
+        // Bug fix #1: Generate tool.execution_start/complete events from data.tools array
+        // This expansion must happen here before returning, since VSCode bypasses the normal pipeline
+        events = this._expandVsCodeToTimelineFormat(events);
+
+        return events;
+      } catch (err) {
+        console.error('Error reading VSCode session:', err);
+        return [];
+      }
     }
 
 
@@ -247,6 +295,7 @@ class SessionService {
       // But we need to merge toolResult events into their parent assistant messages
       this._mergePiMonoToolResults(events);
     }
+    // Note: VSCode expansion is handled in the VSCode block above (before early return)
     
     // Clean up events for timeline rendering
     events = events.filter(e => {
@@ -500,6 +549,17 @@ class SessionService {
       }
     });
     
+    // Mark user events that are entirely tool_result responses (will be filtered out in normalizer)
+    events.forEach(event => {
+      if (event.type === 'user' && Array.isArray(event.message?.content)) {
+        const allToolResults = event.message.content.length > 0 &&
+          event.message.content.every(block => block?.type === 'tool_result');
+        if (allToolResults) {
+          event._isToolResultWrapper = true;
+        }
+      }
+    });
+
     // Match tool_use with tool_result
     events.forEach(event => {
       if (event.data?.tools) {
@@ -523,9 +583,15 @@ class SessionService {
         });
         
         // Bug fix: Only remove tool_result from assistant messages
-        // User messages naturally contain tool_result (responses to tool_use), keep them
+        // Mark user messages that consist entirely of tool_results as wrappers (will be filtered out)
         if (event.type === 'assistant' || event.type === 'assistant.message') {
           event.data.tools = event.data.tools.filter(tool => tool.type !== 'tool_result');
+        } else if (event.type === 'user' || event.type === 'user.message') {
+          const allToolResults = event.data.tools.length > 0 &&
+            event.data.tools.every(tool => tool.type === 'tool_result');
+          if (allToolResults) {
+            event._isToolResultWrapper = true;
+          }
         }
       }
     });
@@ -782,6 +848,11 @@ class SessionService {
       normalized.data.badgeClass = 'badge-session';
       return;
     }
+    if (type === 'system.notification') {
+      normalized.data.badgeLabel = 'SYSTEM';
+      normalized.data.badgeClass = 'badge-system';
+      return;
+    }
     
     // Extract category from type (e.g., 'user.message' → 'user')
     const parts = (type || '').split('.');
@@ -815,8 +886,17 @@ class SessionService {
 
     if (source === 'copilot') {
       // Copilot format normalization
-      
-      // Old format: request/response → user/assistant
+
+      // system-sourced user.message → system.notification (separate type for display)
+      if (event.type === 'user.message' && event.data?.source === 'system') {
+        normalized.type = 'system.notification';
+        // Extract text from <system_notification>...</system_notification> tag if present
+        const raw = event.data.content || event.data.message || '';
+        const match = raw.match(/<system_notification>([\s\S]*?)<\/system_notification>/);
+        normalized.data.message = match ? match[1].trim() : raw.trim();
+        this._generateBadgeInfo(normalized);
+        return normalized;
+      }
       if (event.type === 'request') {
         normalized.type = 'user';
         // Extract message from payload.messages (Anthropic API format)
@@ -1463,6 +1543,8 @@ class SessionService {
     let pendingParentId = null;
     let pendingTs = null;
     let pendingIdx = 0;
+    let pendingSubAgentId = null;
+    let pendingSubAgentName = null;
 
     const flushTools = () => {
       if (pendingTools.length === 0) return;
@@ -1475,19 +1557,30 @@ class SessionService {
           message: '',
           content: '',
           tools: pendingTools,
+          subAgentId: pendingSubAgentId,
+          subAgentName: pendingSubAgentName,
         },
         _synthetic: true,
       });
       pendingTools = [];
+      pendingSubAgentId = null;
+      pendingSubAgentName = null;
     };
 
     for (let i = 0; i < events.length; i++) {
       const ev = events[i];
       if (ev.type === 'tool.invocation') {
+        const evSubAgentId = ev.data?.subAgentId || null;
+        // Flush if switching to a different subagent's tool group
+        if (pendingTools.length > 0 && evSubAgentId !== pendingSubAgentId) {
+          flushTools();
+        }
         if (pendingTools.length === 0) {
           pendingParentId = ev.parentId;
           pendingTs = ev.timestamp;
           pendingIdx = i;
+          pendingSubAgentId = evSubAgentId;
+          pendingSubAgentName = ev.data?.subAgentName || null;
         }
         if (ev.data?.tool) pendingTools.push(ev.data.tool);
       } else {
@@ -1755,6 +1848,72 @@ class SessionService {
 
     return expanded;
   }
+
+  /**
+   * Expand VSCode format to timeline format with tool.execution_start/complete events
+   * VSCode events already have assistant.message events with data.tools arrays (from _expandVsCodeEvents)
+   * This method generates tool.execution_start/complete events for the time-analyze page
+   * @private
+   * @param {Array} events - VSCode events with assistant.message events containing data.tools
+   * @returns {Array} Expanded events with tool execution events
+   */
+  _expandVsCodeToTimelineFormat(events) {
+    const expanded = [];
+
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+
+      // Keep the original event
+      expanded.push(event);
+
+      // Generate tool.execution_start and tool.execution_complete for assistant.message events with tools
+      if (event.type === 'assistant.message' && event.data?.tools && event.data.tools.length > 0) {
+        event.data.tools.forEach((tool, idx) => {
+          // Skip if tool doesn't have required fields
+          if (!tool.id || !tool.name) return;
+
+          const toolStartTime = tool.startTime || event.timestamp;
+          const toolEndTime = tool.endTime || event.timestamp;
+
+          // Generate tool.execution_start event
+          expanded.push({
+            type: 'tool.execution_start',
+            id: `${tool.id}-start`,
+            timestamp: toolStartTime,
+            parentId: event.id,
+            data: {
+              toolCallId: tool.id,
+              toolName: tool.name,
+              tool: tool.name, // Alias for compatibility
+              arguments: tool.input || {}
+            },
+            _synthetic: true,
+            _fileIndex: event._fileIndex ? event._fileIndex + 0.1 + (idx * 0.02) : undefined
+          });
+
+          // Generate tool.execution_complete event
+          expanded.push({
+            type: 'tool.execution_complete',
+            id: `${tool.id}-complete`,
+            timestamp: toolEndTime,
+            parentId: tool.id,
+            data: {
+              toolCallId: tool.id,
+              toolName: tool.name,
+              tool: tool.name, // Alias
+              result: tool.result || null,
+              error: tool.error || (tool.status === 'error' ? 'Tool execution failed' : null),
+              isError: tool.status === 'error'
+            },
+            _synthetic: true,
+            _fileIndex: event._fileIndex ? event._fileIndex + 0.15 + (idx * 0.02) : undefined
+          });
+        });
+      }
+    }
+
+    return expanded;
+  }
 }
 
 module.exports = SessionService;

package/src/utils/helpers.js

@@ -8,11 +8,14 @@
  * @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.model,
+    model: session.selectedModel || session.model,
     repo: session.workspace?.repository,
     branch: session.workspace?.branch,
     cwd: session.workspace?.cwd,

package/views/index.ejs

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Copilot Session Viewer</title>
+  <title>Session Viewer</title>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body {
@@ -489,7 +489,7 @@
 <body>
   <div class="container">
     <h1>🤖 Session Viewer</h1>
-    <p class="subtitle">View session logs from Copilot, Claude Code, and Pi-Mono</p>
+    <p class="subtitle">View session logs from Copilot CLI, Copilot Chat, Claude Code, and Pi-Mono</p>
     
     <form id="sessionForm">
       <div class="input-group">
@@ -505,10 +505,6 @@
       </div>
     </form>
     
-    <p class="hint">
-      Session ID can be found in <span class="hint-code">~/.copilot/session-state/</span>
-    </p>
-    
     <% if (sessions && sessions.length > 0) { %>
       <div class="recent-sessions">
         <div class="sessions-header">
@@ -518,11 +514,12 @@
           <a class="import-link" id="importLink">Import session from zip</a>
         </div>
         <div class="filter-pills">
-          <button class="filter-pill active" data-source="copilot">Copilot</button>
+          <button class="filter-pill active" data-source="copilot">Copilot CLI</button>
+          <button class="filter-pill" data-source="vscode">Copilot Chat</button>
           <button class="filter-pill" data-source="claude">Claude</button>
           <button class="filter-pill" data-source="pi-mono">Pi</button>
-          <!-- <button class="filter-pill" data-source="vscode">VSCode</button> -->
         </div>
+        <p class="hint source-hint" id="sourceHint"></p>
         <input
           type="file"
           id="fileInput"
@@ -803,7 +800,7 @@
       // Add source badge (use backend-provided metadata - Violation #3 & #5 fix)
       const sourceClass = session.sourceBadgeClass || 'source-copilot';
       const sourceLabel = session.sourceName || 'Copilot';
-      badges += `<span class="status-badge ${sourceClass}" title="${sourceLabel} CLI">${sourceLabel}</span>`;
+      badges += `<span class="status-badge ${sourceClass}" title="${sourceLabel}">${sourceLabel}</span>`;
 
       if (session.sessionStatus === 'wip') {
         badges += '<span class="status-badge wip" title="Session in progress">🔄 WIP</span>';
@@ -812,7 +809,7 @@
         badges += '<span class="status-badge imported" title="Imported session">📥</span>';
       }
       if (session.hasInsight) {
-        badges += '<span class="status-badge insight" title="Has Copilot Insight">💡</span>';
+        badges += '<span class="status-badge insight" title="Has Agent Review">💡</span>';
       }
       // Add model and version badges
       if (session.selectedModel) {
@@ -828,7 +825,7 @@
         badges += `<span class="status-badge model ${modelClass}" title="Model: ${escapeHtml(session.selectedModel)}">${escapeHtml(modelShort)}</span>`;
       }
       if (session.copilotVersion) {
-        badges += `<span class="status-badge version" title="Copilot CLI version">${escapeHtml(session.copilotVersion)}</span>`;
+        badges += `<span class="status-badge version" title="CLI version">${escapeHtml(session.copilotVersion)}</span>`;
       }
       
       let summaryHtml = '';
@@ -843,7 +840,7 @@
         workspaceHtml = `
           <div class="session-info-item workspace" title="${escapeHtml(session.workspace.cwd)}">
             <svg viewBox="0 0 16 16" fill="currentColor"><path d="M1.75 1A1.75 1.75 0 000 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0016 13.25v-8.5A1.75 1.75 0 0014.25 3H7.5a.25.25 0 01-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75z"></path></svg>
-            <span class="session-info-value">${escapeHtml(session.workspace.cwd)}</span>
+            <span class="session-info-value">${escapeHtml(session.workspace.cwd.replace(/^\/Users\/[^/]+/, '~'))}</span>
           </div>
         `;
       }
@@ -957,14 +954,29 @@
       });
     }
 
+    // Source directory hints (from server, platform-aware)
+    const sourceHints = <%- sourceHints || '{}' %>;
+
+    function updateSourceHint(source) {
+      const hint = document.getElementById('sourceHint');
+      if (hint && sourceHints[source]) {
+        hint.innerHTML = 'Sessions from <span class="hint-code">' + sourceHints[source] + '</span>';
+      } else if (hint) {
+        hint.textContent = '';
+      }
+    }
+
     // Filter pill click handler
     function setupFilterPills() {
       const filterPills = document.querySelectorAll('.filter-pill');
+      // Show hint for initial active pill
+      updateSourceHint(currentSourceFilter);
       filterPills.forEach(pill => {
         pill.addEventListener('click', async () => {
           filterPills.forEach(p => p.classList.remove('active'));
           pill.classList.add('active');
           currentSourceFilter = pill.getAttribute('data-source');
+          updateSourceHint(currentSourceFilter);
 
           // Init per-source state if first visit
           if (!sourceState[currentSourceFilter]) {