claude-code-workflow 6.2.2 → 6.2.4

package/ccw/dist/tools/native-session-discovery.js

@@ -0,0 +1,700 @@
+/**
+ * Native Session Discovery - Discovers and tracks native CLI tool sessions
+ * Supports Gemini, Qwen, and Codex session formats
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { join, basename, resolve } from 'path';
+// basename is used for extracting session ID from filename
+import { createHash } from 'crypto';
+import { homedir } from 'os';
+/**
+ * Calculate project hash (same algorithm as Gemini/Qwen)
+ * Note: Gemini/Qwen use the absolute path AS-IS without normalization
+ * On Windows, this means using backslashes and original case
+ */
+export function calculateProjectHash(projectDir) {
+    // resolve() returns absolute path with native separators (backslash on Windows)
+    const absolutePath = resolve(projectDir);
+    return createHash('sha256').update(absolutePath).digest('hex');
+}
+/**
+ * Get home directory path
+ */
+function getHomePath() {
+    return homedir().replace(/\\/g, '/');
+}
+/**
+ * Base session discoverer interface
+ */
+class SessionDiscoverer {
+    /**
+     * Get the latest session
+     */
+    getLatestSession(options) {
+        const sessions = this.getSessions({ ...options, limit: 1 });
+        return sessions.length > 0 ? sessions[0] : null;
+    }
+    /**
+     * Track new session created during execution
+     * @param beforeTimestamp - Filter sessions created after this time
+     * @param workingDir - Project working directory
+     * @param prompt - Optional prompt content for precise matching (fallback)
+     */
+    async trackNewSession(beforeTimestamp, workingDir, prompt) {
+        const sessions = this.getSessions({
+            workingDir,
+            afterTimestamp: beforeTimestamp,
+            limit: 10 // Get more candidates for prompt matching
+        });
+        if (sessions.length === 0)
+            return null;
+        // If only one session or no prompt provided, return the latest
+        if (sessions.length === 1 || !prompt) {
+            return sessions[0];
+        }
+        // Try to match by prompt content (fallback for parallel execution)
+        const matched = this.matchSessionByPrompt(sessions, prompt);
+        return matched || sessions[0]; // Fallback to latest if no match
+    }
+    /**
+     * Match session by prompt content
+     * Searches for the prompt in session's user messages
+     */
+    matchSessionByPrompt(sessions, prompt) {
+        // Normalize prompt for comparison (first 200 chars)
+        const promptPrefix = prompt.substring(0, 200).trim();
+        if (!promptPrefix)
+            return null;
+        for (const session of sessions) {
+            try {
+                const userMessage = this.extractFirstUserMessage(session.filePath);
+                if (userMessage && userMessage.includes(promptPrefix)) {
+                    return session;
+                }
+            }
+            catch {
+                // Skip sessions that can't be read
+            }
+        }
+        return null;
+    }
+}
+/**
+ * Gemini Session Discoverer
+ * Path: ~/.gemini/tmp/<projectHash>/chats/session-*.json
+ */
+class GeminiSessionDiscoverer extends SessionDiscoverer {
+    tool = 'gemini';
+    basePath = join(getHomePath(), '.gemini', 'tmp');
+    getSessions(options = {}) {
+        const { workingDir, limit, afterTimestamp } = options;
+        const sessions = [];
+        try {
+            if (!existsSync(this.basePath))
+                return [];
+            // If workingDir provided, only look in that project's folder
+            let projectDirs;
+            if (workingDir) {
+                const projectHash = calculateProjectHash(workingDir);
+                const projectPath = join(this.basePath, projectHash);
+                projectDirs = existsSync(projectPath) ? [projectHash] : [];
+            }
+            else {
+                projectDirs = readdirSync(this.basePath).filter(d => {
+                    const fullPath = join(this.basePath, d);
+                    return statSync(fullPath).isDirectory();
+                });
+            }
+            for (const projectHash of projectDirs) {
+                const chatsDir = join(this.basePath, projectHash, 'chats');
+                if (!existsSync(chatsDir))
+                    continue;
+                const sessionFiles = readdirSync(chatsDir)
+                    .filter(f => f.startsWith('session-') && f.endsWith('.json'))
+                    .map(f => ({
+                    name: f,
+                    path: join(chatsDir, f),
+                    stat: statSync(join(chatsDir, f))
+                }))
+                    .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                for (const file of sessionFiles) {
+                    if (afterTimestamp && file.stat.mtime <= afterTimestamp)
+                        continue;
+                    try {
+                        const content = JSON.parse(readFileSync(file.path, 'utf8'));
+                        sessions.push({
+                            sessionId: content.sessionId,
+                            tool: this.tool,
+                            filePath: file.path,
+                            projectHash,
+                            createdAt: new Date(content.startTime || file.stat.birthtime),
+                            updatedAt: new Date(content.lastUpdated || file.stat.mtime)
+                        });
+                    }
+                    catch {
+                        // Skip invalid files
+                    }
+                }
+            }
+            // Sort by updatedAt descending
+            sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+            return limit ? sessions.slice(0, limit) : sessions;
+        }
+        catch {
+            return [];
+        }
+    }
+    findSessionById(sessionId) {
+        const sessions = this.getSessions();
+        return sessions.find(s => s.sessionId === sessionId) || null;
+    }
+    /**
+     * Extract first user message from Gemini session file
+     * Format: { "messages": [{ "type": "user", "content": "..." }] }
+     */
+    extractFirstUserMessage(filePath) {
+        try {
+            const content = JSON.parse(readFileSync(filePath, 'utf8'));
+            if (content.messages && Array.isArray(content.messages)) {
+                const userMsg = content.messages.find((m) => m.type === 'user');
+                return userMsg?.content || null;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Encode a path to Qwen's project folder name format
+ * D:\Claude_dms3 -> D--Claude-dms3
+ * Rules: : -> -, \ -> -, _ -> -
+ */
+function encodeQwenProjectPath(projectDir) {
+    const absolutePath = resolve(projectDir);
+    // Replace : -> -, \ -> -, _ -> -
+    return absolutePath
+        .replace(/:/g, '-')
+        .replace(/\\/g, '-')
+        .replace(/_/g, '-');
+}
+/**
+ * Qwen Session Discoverer
+ * New path: ~/.qwen/projects/<path-encoded>/chats/<uuid>.jsonl
+ * Old path: ~/.qwen/tmp/<projectHash>/chats/session-*.json (deprecated, fallback)
+ */
+class QwenSessionDiscoverer extends SessionDiscoverer {
+    tool = 'qwen';
+    basePath = join(getHomePath(), '.qwen', 'projects');
+    legacyBasePath = join(getHomePath(), '.qwen', 'tmp');
+    getSessions(options = {}) {
+        const { workingDir, limit, afterTimestamp } = options;
+        const sessions = [];
+        // Try new format first (projects folder)
+        try {
+            if (existsSync(this.basePath)) {
+                let projectDirs;
+                if (workingDir) {
+                    const encodedPath = encodeQwenProjectPath(workingDir);
+                    const projectPath = join(this.basePath, encodedPath);
+                    projectDirs = existsSync(projectPath) ? [encodedPath] : [];
+                }
+                else {
+                    projectDirs = readdirSync(this.basePath).filter(d => {
+                        const fullPath = join(this.basePath, d);
+                        return statSync(fullPath).isDirectory();
+                    });
+                }
+                for (const projectFolder of projectDirs) {
+                    const chatsDir = join(this.basePath, projectFolder, 'chats');
+                    if (!existsSync(chatsDir))
+                        continue;
+                    // New format: <uuid>.jsonl files
+                    const sessionFiles = readdirSync(chatsDir)
+                        .filter(f => f.endsWith('.jsonl'))
+                        .map(f => ({
+                        name: f,
+                        path: join(chatsDir, f),
+                        stat: statSync(join(chatsDir, f))
+                    }))
+                        .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                    for (const file of sessionFiles) {
+                        if (afterTimestamp && file.stat.mtime <= afterTimestamp)
+                            continue;
+                        try {
+                            // Parse JSONL - read first line for session info
+                            const content = readFileSync(file.path, 'utf8');
+                            const firstLine = content.split('\n')[0];
+                            const firstEntry = JSON.parse(firstLine);
+                            // Session ID is in the filename or first entry
+                            const sessionId = firstEntry.sessionId || basename(file.name, '.jsonl');
+                            // Find timestamp from entries
+                            let createdAt = file.stat.birthtime;
+                            let updatedAt = file.stat.mtime;
+                            if (firstEntry.timestamp) {
+                                createdAt = new Date(firstEntry.timestamp);
+                            }
+                            // Get last entry for updatedAt
+                            const lines = content.trim().split('\n').filter(l => l.trim());
+                            if (lines.length > 0) {
+                                try {
+                                    const lastEntry = JSON.parse(lines[lines.length - 1]);
+                                    if (lastEntry.timestamp) {
+                                        updatedAt = new Date(lastEntry.timestamp);
+                                    }
+                                }
+                                catch { /* ignore */ }
+                            }
+                            sessions.push({
+                                sessionId,
+                                tool: this.tool,
+                                filePath: file.path,
+                                projectHash: projectFolder, // Using encoded path as project identifier
+                                createdAt,
+                                updatedAt
+                            });
+                        }
+                        catch {
+                            // Skip invalid files
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* ignore errors */ }
+        // Fallback to legacy format (tmp folder with hash)
+        try {
+            if (existsSync(this.legacyBasePath)) {
+                let projectDirs;
+                if (workingDir) {
+                    const projectHash = calculateProjectHash(workingDir);
+                    const projectPath = join(this.legacyBasePath, projectHash);
+                    projectDirs = existsSync(projectPath) ? [projectHash] : [];
+                }
+                else {
+                    projectDirs = readdirSync(this.legacyBasePath).filter(d => {
+                        const fullPath = join(this.legacyBasePath, d);
+                        return statSync(fullPath).isDirectory();
+                    });
+                }
+                for (const projectHash of projectDirs) {
+                    const chatsDir = join(this.legacyBasePath, projectHash, 'chats');
+                    if (!existsSync(chatsDir))
+                        continue;
+                    const sessionFiles = readdirSync(chatsDir)
+                        .filter(f => f.startsWith('session-') && f.endsWith('.json'))
+                        .map(f => ({
+                        name: f,
+                        path: join(chatsDir, f),
+                        stat: statSync(join(chatsDir, f))
+                    }))
+                        .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                    for (const file of sessionFiles) {
+                        if (afterTimestamp && file.stat.mtime <= afterTimestamp)
+                            continue;
+                        try {
+                            const content = JSON.parse(readFileSync(file.path, 'utf8'));
+                            sessions.push({
+                                sessionId: content.sessionId,
+                                tool: this.tool,
+                                filePath: file.path,
+                                projectHash,
+                                createdAt: new Date(content.startTime || file.stat.birthtime),
+                                updatedAt: new Date(content.lastUpdated || file.stat.mtime)
+                            });
+                        }
+                        catch {
+                            // Skip invalid files
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* ignore errors */ }
+        // Sort by updatedAt descending and dedupe by sessionId
+        sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+        // Dedupe (new format takes precedence as it's checked first)
+        const seen = new Set();
+        const uniqueSessions = sessions.filter(s => {
+            if (seen.has(s.sessionId))
+                return false;
+            seen.add(s.sessionId);
+            return true;
+        });
+        return limit ? uniqueSessions.slice(0, limit) : uniqueSessions;
+    }
+    findSessionById(sessionId) {
+        const sessions = this.getSessions();
+        return sessions.find(s => s.sessionId === sessionId) || null;
+    }
+    /**
+     * Extract first user message from Qwen session file
+     * New format (.jsonl): { type: "user", message: { role: "user", parts: [{ text: "..." }] } }
+     * Legacy format (.json): { "messages": [{ "type": "user", "content": "..." }] }
+     */
+    extractFirstUserMessage(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            // Check if JSONL (new format) or JSON (legacy)
+            if (filePath.endsWith('.jsonl')) {
+                // JSONL format - find first user message
+                const lines = content.split('\n').filter(l => l.trim());
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        // New Qwen format: { type: "user", message: { parts: [{ text: "..." }] } }
+                        if (entry.type === 'user' && entry.message?.parts?.[0]?.text) {
+                            return entry.message.parts[0].text;
+                        }
+                        // Alternative format
+                        if (entry.role === 'user' && entry.content) {
+                            return entry.content;
+                        }
+                    }
+                    catch { /* skip invalid lines */ }
+                }
+            }
+            else {
+                // Legacy JSON format
+                const data = JSON.parse(content);
+                if (data.messages && Array.isArray(data.messages)) {
+                    const userMsg = data.messages.find((m) => m.type === 'user');
+                    return userMsg?.content || null;
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Codex Session Discoverer
+ * Path: ~/.codex/sessions/YYYY/MM/DD/rollout-*-<uuid>.jsonl
+ */
+class CodexSessionDiscoverer extends SessionDiscoverer {
+    tool = 'codex';
+    basePath = join(getHomePath(), '.codex', 'sessions');
+    getSessions(options = {}) {
+        const { limit, afterTimestamp } = options;
+        const sessions = [];
+        try {
+            if (!existsSync(this.basePath))
+                return [];
+            // Get year directories (e.g., 2025)
+            const yearDirs = readdirSync(this.basePath)
+                .filter(d => /^\d{4}$/.test(d))
+                .sort((a, b) => b.localeCompare(a)); // Descending
+            for (const year of yearDirs) {
+                const yearPath = join(this.basePath, year);
+                if (!statSync(yearPath).isDirectory())
+                    continue;
+                // Get month directories
+                const monthDirs = readdirSync(yearPath)
+                    .filter(d => /^\d{2}$/.test(d))
+                    .sort((a, b) => b.localeCompare(a));
+                for (const month of monthDirs) {
+                    const monthPath = join(yearPath, month);
+                    if (!statSync(monthPath).isDirectory())
+                        continue;
+                    // Get day directories
+                    const dayDirs = readdirSync(monthPath)
+                        .filter(d => /^\d{2}$/.test(d))
+                        .sort((a, b) => b.localeCompare(a));
+                    for (const day of dayDirs) {
+                        const dayPath = join(monthPath, day);
+                        if (!statSync(dayPath).isDirectory())
+                            continue;
+                        // Get session files
+                        const sessionFiles = readdirSync(dayPath)
+                            .filter(f => f.startsWith('rollout-') && f.endsWith('.jsonl'))
+                            .map(f => ({
+                            name: f,
+                            path: join(dayPath, f),
+                            stat: statSync(join(dayPath, f))
+                        }))
+                            .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                        for (const file of sessionFiles) {
+                            if (afterTimestamp && file.stat.mtime <= afterTimestamp)
+                                continue;
+                            try {
+                                // Parse first line for session_meta
+                                const firstLine = readFileSync(file.path, 'utf8').split('\n')[0];
+                                const meta = JSON.parse(firstLine);
+                                if (meta.type === 'session_meta' && meta.payload?.id) {
+                                    sessions.push({
+                                        sessionId: meta.payload.id,
+                                        tool: this.tool,
+                                        filePath: file.path,
+                                        createdAt: new Date(meta.payload.timestamp || file.stat.birthtime),
+                                        updatedAt: file.stat.mtime
+                                    });
+                                }
+                            }
+                            catch {
+                                // Try extracting UUID from filename
+                                const uuidMatch = file.name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+                                if (uuidMatch) {
+                                    sessions.push({
+                                        sessionId: uuidMatch[1],
+                                        tool: this.tool,
+                                        filePath: file.path,
+                                        createdAt: file.stat.birthtime,
+                                        updatedAt: file.stat.mtime
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+            return limit ? sessions.slice(0, limit) : sessions;
+        }
+        catch {
+            return [];
+        }
+    }
+    findSessionById(sessionId) {
+        const sessions = this.getSessions();
+        return sessions.find(s => s.sessionId === sessionId) || null;
+    }
+    /**
+     * Extract first user message from Codex session file (.jsonl)
+     * Format: {"type":"event_msg","payload":{"type":"user_message","message":"..."}}
+     */
+    extractFirstUserMessage(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            const lines = content.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    // Look for user_message event
+                    if (entry.type === 'event_msg' &&
+                        entry.payload?.type === 'user_message' &&
+                        entry.payload?.message) {
+                        return entry.payload.message;
+                    }
+                }
+                catch { /* skip invalid lines */ }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Claude Code Session Discoverer
+ * Path: ~/.claude/projects/<projectHash>/sessions/*.jsonl
+ * Claude Code stores sessions with UUID-based session IDs
+ */
+class ClaudeSessionDiscoverer extends SessionDiscoverer {
+    tool = 'claude';
+    basePath = join(getHomePath(), '.claude', 'projects');
+    getSessions(options = {}) {
+        const { workingDir, limit, afterTimestamp } = options;
+        const sessions = [];
+        try {
+            if (!existsSync(this.basePath))
+                return [];
+            // If workingDir provided, only look in that project's folder
+            let projectDirs;
+            if (workingDir) {
+                const projectHash = calculateProjectHash(workingDir);
+                const projectPath = join(this.basePath, projectHash);
+                projectDirs = existsSync(projectPath) ? [projectHash] : [];
+            }
+            else {
+                projectDirs = readdirSync(this.basePath).filter(d => {
+                    const fullPath = join(this.basePath, d);
+                    return statSync(fullPath).isDirectory();
+                });
+            }
+            for (const projectHash of projectDirs) {
+                // Claude Code stores session files directly in project folder (not in 'sessions' subdirectory)
+                // e.g., ~/.claude/projects/D--Claude-dms3/<uuid>.jsonl
+                const projectDir = join(this.basePath, projectHash);
+                if (!existsSync(projectDir))
+                    continue;
+                const sessionFiles = readdirSync(projectDir)
+                    .filter(f => f.endsWith('.jsonl') || f.endsWith('.json'))
+                    .map(f => ({
+                    name: f,
+                    path: join(projectDir, f),
+                    stat: statSync(join(projectDir, f))
+                }))
+                    .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                for (const file of sessionFiles) {
+                    if (afterTimestamp && file.stat.mtime <= afterTimestamp)
+                        continue;
+                    try {
+                        // Extract session ID from filename or content
+                        const uuidMatch = file.name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+                        if (uuidMatch) {
+                            sessions.push({
+                                sessionId: uuidMatch[1],
+                                tool: this.tool,
+                                filePath: file.path,
+                                projectHash,
+                                createdAt: file.stat.birthtime,
+                                updatedAt: file.stat.mtime
+                            });
+                        }
+                        else {
+                            // Try reading first line for session metadata
+                            const firstLine = readFileSync(file.path, 'utf8').split('\n')[0];
+                            const meta = JSON.parse(firstLine);
+                            if (meta.session_id) {
+                                sessions.push({
+                                    sessionId: meta.session_id,
+                                    tool: this.tool,
+                                    filePath: file.path,
+                                    projectHash,
+                                    createdAt: new Date(meta.timestamp || file.stat.birthtime),
+                                    updatedAt: file.stat.mtime
+                                });
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip invalid files
+                    }
+                }
+            }
+            sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+            return limit ? sessions.slice(0, limit) : sessions;
+        }
+        catch {
+            return [];
+        }
+    }
+    findSessionById(sessionId) {
+        const sessions = this.getSessions();
+        return sessions.find(s => s.sessionId === sessionId) || null;
+    }
+    /**
+     * Extract first user message from Claude Code session file (.jsonl)
+     * Format: {"type":"user","message":{"role":"user","content":"..."},"isMeta":false,...}
+     */
+    extractFirstUserMessage(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            const lines = content.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    // Claude Code format: type="user", message.role="user", message.content="..."
+                    // Skip meta messages and command messages
+                    if (entry.type === 'user' &&
+                        entry.message?.role === 'user' &&
+                        entry.message?.content &&
+                        !entry.isMeta &&
+                        !entry.message.content.startsWith('<command-')) {
+                        return entry.message.content;
+                    }
+                }
+                catch { /* skip invalid lines */ }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+// Singleton discoverers
+const discoverers = {
+    gemini: new GeminiSessionDiscoverer(),
+    qwen: new QwenSessionDiscoverer(),
+    codex: new CodexSessionDiscoverer(),
+    claude: new ClaudeSessionDiscoverer()
+};
+/**
+ * Get session discoverer for a tool
+ */
+export function getDiscoverer(tool) {
+    return discoverers[tool] || null;
+}
+/**
+ * Get latest native session for a tool
+ */
+export function getLatestNativeSession(tool, workingDir) {
+    const discoverer = discoverers[tool];
+    if (!discoverer)
+        return null;
+    return discoverer.getLatestSession({ workingDir });
+}
+/**
+ * Find native session by ID
+ */
+export function findNativeSessionById(tool, sessionId) {
+    const discoverer = discoverers[tool];
+    if (!discoverer)
+        return null;
+    return discoverer.findSessionById(sessionId);
+}
+/**
+ * Track new session created during execution
+ * @param tool - CLI tool name (gemini, qwen, codex, claude)
+ * @param beforeTimestamp - Filter sessions created after this time
+ * @param workingDir - Project working directory
+ * @param prompt - Optional prompt for precise matching in parallel execution
+ */
+export async function trackNewSession(tool, beforeTimestamp, workingDir, prompt) {
+    const discoverer = discoverers[tool];
+    if (!discoverer)
+        return null;
+    return discoverer.trackNewSession(beforeTimestamp, workingDir, prompt);
+}
+/**
+ * Get all sessions for a tool
+ */
+export function getNativeSessions(tool, options) {
+    const discoverer = discoverers[tool];
+    if (!discoverer)
+        return [];
+    return discoverer.getSessions(options);
+}
+/**
+ * Check if a tool supports native resume
+ */
+export function supportsNativeResume(tool) {
+    return tool in discoverers;
+}
+/**
+ * Get native resume command arguments for a tool
+ */
+export function getNativeResumeArgs(tool, sessionId) {
+    switch (tool) {
+        case 'gemini':
+            // gemini -r <uuid> or -r latest
+            return ['-r', sessionId];
+        case 'qwen':
+            // qwen --continue (latest) or --resume <uuid>
+            if (sessionId === 'latest') {
+                return ['--continue'];
+            }
+            return ['--resume', sessionId];
+        case 'codex':
+            // codex resume <uuid> or codex resume --last
+            if (sessionId === 'latest') {
+                return ['resume', '--last'];
+            }
+            return ['resume', sessionId];
+        default:
+            return [];
+    }
+}
+/**
+ * Get base path for a tool's sessions
+ */
+export function getToolSessionPath(tool) {
+    const discoverer = discoverers[tool];
+    return discoverer?.basePath || null;
+}
+//# sourceMappingURL=native-session-discovery.js.map