@sumicom/quicksave 0.6.1 → 0.6.3

package/dist/handlers/messageHandler.js

@@ -1,27 +1,34 @@
 import { createMessage, generateMessageId, } from '@sumicom/quicksave-shared';
 import { GitOperations } from '../git/operations.js';
-import { getAnthropicApiKey, setAnthropicApiKey, hasAnthropicApiKey, addManagedRepo, addManagedCodingPath } from '../config.js';
+import { getAnthropicApiKey, setAnthropicApiKey, hasAnthropicApiKey, addManagedRepo, removeManagedRepo, addManagedCodingPath, removeManagedCodingPath } from '../config.js';
 import { CommitSummaryService } from '../ai/commitSummary.js';
 import { SessionManager } from '../ai/sessionManager.js';
-import { ClaudeCliProvider } from '../ai/claudeCliProvider.js';
-import { ClaudeSdkProvider } from '../ai/claudeSdkProvider.js';
+import { ClaudeCodeProvider } from '../ai/claudeCodeProvider.js';
+import { CodexSdkProvider } from '../ai/codexSdkProvider.js';
 import { getSessionRegistry } from '../ai/sessionRegistry.js';
-import { readdir, stat } from 'fs/promises';
+import { readdir, stat, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { homedir } from 'os';
 const VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
+const CODEX_MODELS_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
 export class MessageHandler {
     repos;
-    agentVersion = '0.6.1';
+    agentVersion = '0.6.3';
     defaultRepoPath;
     clientRepos = new Map(); // peerAddress -> repoPath
     repoLocks = new Map(); // repoPath -> peerAddress holding lock
     availableRepos;
     codingPaths = new Map(); // path -> CodingPath
     aiService = null;
-    claudeService = new SessionManager(new ClaudeCliProvider(), new ClaudeSdkProvider());
+    claudeService = new SessionManager([
+        new ClaudeCodeProvider(),
+        new CodexSdkProvider(),
+    ]);
     latestVersionCache = null;
     versionCheckInFlight = null;
+    codexModelsCache = null;
+    codexModelsCheckInFlight = null;
     onPeerSubscribed;
     onPeerUnsubscribed;
     onHistoryUpdated;
@@ -77,6 +84,59 @@ export class MessageHandler {
         })();
         return this.versionCheckInFlight;
     }
+    /**
+     * Fetch available Codex models from OpenAI /v1/models. Reads API key from
+     * ~/.codex/auth.json (ChatGPT OAuth token or OPENAI_API_KEY). Cached for 12h
+     * with concurrent-request dedup — same pattern as checkLatestVersion.
+     */
+    async fetchCodexModels(force = false) {
+        if (!force && this.codexModelsCache &&
+            Date.now() - this.codexModelsCache.checkedAt < CODEX_MODELS_CHECK_INTERVAL_MS) {
+            return this.codexModelsCache.models;
+        }
+        if (this.codexModelsCheckInFlight)
+            return this.codexModelsCheckInFlight;
+        this.codexModelsCheckInFlight = (async () => {
+            try {
+                // Resolve API key: env var first, then ~/.codex/auth.json
+                let apiKey = process.env.OPENAI_API_KEY;
+                if (!apiKey) {
+                    try {
+                        const authPath = join(homedir(), '.codex', 'auth.json');
+                        const raw = await readFile(authPath, 'utf-8');
+                        const auth = JSON.parse(raw);
+                        apiKey = auth.OPENAI_API_KEY || auth.tokens?.access_token;
+                    }
+                    catch { /* no auth file */ }
+                }
+                if (!apiKey)
+                    return null;
+                const res = await fetch('https://api.openai.com/v1/models', {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                    signal: AbortSignal.timeout(10_000),
+                });
+                if (!res.ok)
+                    return null;
+                const data = await res.json();
+                if (!Array.isArray(data.data))
+                    return null;
+                // Filter to chat-capable models (gpt-*, o*) and sort descending
+                const models = data.data
+                    .filter((m) => /^(gpt-|o\d)/.test(m.id))
+                    .map((m) => ({ id: m.id, name: m.id }))
+                    .sort((a, b) => b.id.localeCompare(a.id));
+                this.codexModelsCache = { models, checkedAt: Date.now() };
+                return models;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                this.codexModelsCheckInFlight = null;
+            }
+        })();
+        return this.codexModelsCheckInFlight;
+    }
     addRepo(repo) {
         if (this.repos.has(repo.path))
             return;
@@ -181,6 +241,12 @@ export class MessageHandler {
                     return this.handleDiscard(message, peerAddress);
                 case 'git:untrack':
                     return this.handleUntrack(message, peerAddress);
+                case 'git:submodules':
+                    return this.handleSubmodules(message, peerAddress);
+                case 'git:config-get':
+                    return this.handleGitConfigGet(message, peerAddress);
+                case 'git:config-set':
+                    return this.handleGitConfigSet(message, peerAddress);
                 case 'git:gitignore-add':
                     return this.handleGitignoreAdd(message, peerAddress);
                 case 'git:gitignore-read':
@@ -201,14 +267,24 @@ export class MessageHandler {
                     return this.handleBrowseDirectory(message);
                 case 'agent:add-repo':
                     return this.handleAddRepo(message);
+                case 'agent:remove-repo':
+                    return this.handleRemoveRepo(message);
+                case 'agent:clone-repo':
+                    return this.handleCloneRepo(message);
                 case 'agent:list-coding-paths':
                     return this.handleListCodingPaths(message);
                 case 'agent:add-coding-path':
                     return this.handleAddCodingPath(message);
+                case 'agent:remove-coding-path':
+                    return this.handleRemoveCodingPath(message);
                 case 'agent:check-update':
                     return this.handleAgentCheckUpdate(message);
                 case 'agent:update':
                     return this.handleAgentUpdate(message);
+                case 'agent:restart':
+                    return this.handleAgentRestart(message);
+                case 'codex:list-models':
+                    return this.handleCodexListModels(message);
                 // Claude Code SDK
                 case 'claude:list-sessions':
                     return this.handleClaudeListSessions(message, peerAddress);
@@ -247,6 +323,10 @@ export class MessageHandler {
                     return this.handleUpdateHistory(message);
                 case 'session:delete-history':
                     return this.handleDeleteHistory(message);
+                case 'project:list-summaries':
+                    return this.handleListProjectSummaries(message);
+                case 'project:list-repos':
+                    return await this.handleListProjectRepos(message);
                 default:
                     return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
             }
@@ -257,8 +337,9 @@ export class MessageHandler {
         }
     }
     handleHandshake(message, peerAddress) {
-        // Fire-and-forget: check npm registry for latest version (12h dedup, production only)
+        // Fire-and-forget: check npm registry + OpenAI models (12h dedup each)
         this.checkLatestVersion().catch(() => { });
+        this.fetchCodexModels().catch(() => { });
         const response = createMessage('handshake:ack', {
             success: true,
             agentVersion: this.agentVersion,
@@ -268,6 +349,7 @@ export class MessageHandler {
             preferences: this.claudeService.getPreferences(),
             latestVersion: this.latestVersionCache?.version,
             devBuild: !this.productionBuild || undefined,
+            codexModels: this.codexModelsCache?.models,
         });
         response.id = message.id;
         return response;
@@ -528,6 +610,45 @@ export class MessageHandler {
             this.releaseRepoLock(repoPath, peerAddress);
         }
     }
+    async handleSubmodules(message, peerAddress) {
+        const git = this.getGit(peerAddress);
+        const subs = await git.getSubmodules();
+        // Auto-register submodule paths so switch-repo works
+        for (const sub of subs) {
+            if (!this.repos.has(sub.path)) {
+                this.repos.set(sub.path, new GitOperations(sub.path));
+                this.availableRepos.push({ path: sub.path, name: sub.name, currentBranch: sub.branch });
+            }
+        }
+        const response = createMessage('git:submodules:response', {
+            submodules: subs.map((s) => ({ name: s.name, path: s.path, branch: s.branch })),
+        });
+        response.id = message.id;
+        return response;
+    }
+    async handleGitConfigGet(message, peerAddress) {
+        const identity = await this.getGit(peerAddress).getIdentity();
+        const response = createMessage('git:config-get:response', identity);
+        response.id = message.id;
+        return response;
+    }
+    async handleGitConfigSet(message, peerAddress) {
+        try {
+            const { name, email } = message.payload;
+            await this.getGit(peerAddress).setIdentity(name, email);
+            const response = createMessage('git:config-set:response', { success: true });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('git:config-set:response', {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to set git identity',
+            });
+            response.id = message.id;
+            return response;
+        }
+    }
     async handleGitignoreAdd(message, peerAddress) {
         const repoPath = this.getClientRepoPath(peerAddress);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
@@ -829,6 +950,81 @@ export class MessageHandler {
             return response;
         }
     }
+    handleRemoveRepo(message) {
+        const { path: repoPath } = message.payload;
+        if (!this.repos.has(repoPath)) {
+            const response = createMessage('agent:remove-repo:response', {
+                success: false,
+                error: 'Repository not found',
+            });
+            response.id = message.id;
+            return response;
+        }
+        this.removeRepo(repoPath);
+        removeManagedRepo(repoPath);
+        const response = createMessage('agent:remove-repo:response', {
+            success: true,
+        });
+        response.id = message.id;
+        return response;
+    }
+    async handleCloneRepo(message) {
+        const { url, targetDir } = message.payload;
+        if (!url || !url.trim()) {
+            const response = createMessage('agent:clone-repo:response', {
+                success: false,
+                error: 'Repository URL is required',
+            });
+            response.id = message.id;
+            return response;
+        }
+        try {
+            const { execFile } = await import('child_process');
+            const { promisify } = await import('util');
+            const execFileAsync = promisify(execFile);
+            // Clone into the target directory
+            await execFileAsync('git', ['clone', url.trim(), targetDir], {
+                timeout: 120_000,
+            });
+            // Verify it's a valid git repo and add it
+            const git = new GitOperations(targetDir);
+            const { current } = await git.getBranches();
+            const rootPath = await git.getGitRoot();
+            // Check if already added (by resolved root path)
+            if (this.repos.has(rootPath)) {
+                const response = createMessage('agent:clone-repo:response', {
+                    success: false,
+                    error: 'Repository already added',
+                });
+                response.id = message.id;
+                return response;
+            }
+            // Add to maps and persist
+            this.repos.set(rootPath, git);
+            const newRepo = {
+                path: rootPath,
+                name: basename(rootPath),
+                currentBranch: current,
+            };
+            this.availableRepos.push(newRepo);
+            addManagedRepo(rootPath);
+            const response = createMessage('agent:clone-repo:response', {
+                success: true,
+                repo: newRepo,
+                clonedPath: rootPath,
+            });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('agent:clone-repo:response', {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to clone repository',
+            });
+            response.id = message.id;
+            return response;
+        }
+    }
     // ============================================================================
     // Coding Path Handlers
     // ============================================================================
@@ -865,6 +1061,19 @@ export class MessageHandler {
             return response;
         }
     }
+    handleRemoveCodingPath(message) {
+        const { path: codingPath } = message.payload;
+        if (!this.codingPaths.has(codingPath)) {
+            const response = createMessage('agent:remove-coding-path:response', { success: false, error: 'Coding path not found' });
+            response.id = message.id;
+            return response;
+        }
+        this.codingPaths.delete(codingPath);
+        removeManagedCodingPath(codingPath);
+        const response = createMessage('agent:remove-coding-path:response', { success: true });
+        response.id = message.id;
+        return response;
+    }
     // ============================================================================
     // Agent Self-Update
     // ============================================================================
@@ -944,6 +1153,50 @@ export class MessageHandler {
             return response;
         }
     }
+    async handleAgentRestart(message) {
+        if (this.productionBuild) {
+            const response = createMessage('agent:restart:response', { success: false, error: 'Restart is only available for dev builds' });
+            response.id = message.id;
+            return response;
+        }
+        try {
+            const { spawn } = await import('child_process');
+            const { fileURLToPath } = await import('url');
+            const { resolve: resolvePath } = await import('path');
+            const thisFile = fileURLToPath(import.meta.url);
+            const isTs = thisFile.endsWith('.ts');
+            const entryPath = resolvePath(dirname(thisFile), isTs ? '../index.ts' : '../../index.js');
+            const agentRoot = resolvePath(dirname(thisFile), isTs ? '..' : '..');
+            const node = process.execPath;
+            const execArgv = isTs ? ['--import', 'tsx'] : [];
+            spawn(node, [...execArgv, entryPath, '--restart'], {
+                detached: true,
+                stdio: 'ignore',
+                cwd: agentRoot,
+            }).unref();
+            const response = createMessage('agent:restart:response', { success: true });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('agent:restart:response', { success: false, error: error instanceof Error ? error.message : 'Failed to restart agent' });
+            response.id = message.id;
+            return response;
+        }
+    }
+    async handleCodexListModels(message) {
+        try {
+            const models = await this.fetchCodexModels(/* force */ true);
+            const response = createMessage('codex:list-models:response', { models: models ?? [] });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('codex:list-models:response', { models: [], error: error instanceof Error ? error.message : 'Failed to fetch models' });
+            response.id = message.id;
+            return response;
+        }
+    }
     // ============================================================================
     // Claude Code SDK Handlers
     // ============================================================================
@@ -962,27 +1215,41 @@ export class MessageHandler {
         }
     }
     async handleClaudeStart(message, peerAddress) {
-        const { prompt, cwd: payloadCwd, allowedTools, systemPrompt, model, permissionMode, sandboxed } = message.payload;
+        const { prompt, cwd: payloadCwd, agent, allowedTools, systemPrompt, model, permissionMode, sandboxed } = message.payload;
+        const legacyProvider = message.payload.provider;
         const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
         const streamId = generateMessageId();
-        console.log(`[claude:start] cwd=${cwd} prompt=${prompt.slice(0, 80)}${sandboxed ? ' [sandboxed]' : ''}`);
+        const resolvedAgent = agent ?? (legacyProvider === 'codex-mcp' ? 'codex' : legacyProvider ? 'claude-code' : undefined);
+        console.log(`[agent:start] agent=${resolvedAgent ?? 'default'} cwd=${cwd} prompt=${prompt.slice(0, 80)}${sandboxed ? ' [sandboxed]' : ''}`);
         try {
             const sessionId = await this.claudeService.startSession({
-                prompt, cwd, streamId, allowedTools, systemPrompt, model, permissionMode, sandboxed,
+                prompt,
+                cwd,
+                streamId,
+                agent: resolvedAgent,
+                allowedTools,
+                systemPrompt,
+                model,
+                permissionMode,
+                sandboxed,
             });
-            console.log(`[claude:start] session created: ${sessionId}`);
+            console.log(`[agent:start] session created: ${sessionId} agent=${resolvedAgent ?? 'default'}`);
             this.onPeerSubscribed?.(peerAddress, sessionId);
             // Register in session history
             const now = Date.now();
             const registry = getSessionRegistry();
             const gitBranch = await this.getGitBranchQuiet(cwd);
+            const actualAgent = this.claudeService.getSessionAgent(sessionId, cwd);
             registry.upsertEntry({
                 sessionId, cwd,
+                agent: actualAgent,
                 repoName: basename(cwd),
                 gitBranch,
                 firstPrompt: prompt.slice(0, 100),
                 createdAt: now,
                 lastAccessedAt: now,
+                permissionMode,
+                sandboxed: sandboxed || undefined,
             });
             this.onHistoryUpdated?.(cwd, registry.getEntry(cwd, sessionId), 'upsert');
             const response = createMessage('claude:start:response', { success: true, sessionId, streamId });
@@ -990,26 +1257,32 @@ export class MessageHandler {
             return response;
         }
         catch (error) {
-            console.error(`[claude:start] error:`, error);
+            console.error(`[agent:start] error:`, error);
             const response = createMessage('claude:start:response', { success: false, error: error instanceof Error ? error.message : 'Failed to start session' });
             response.id = message.id;
             return response;
         }
     }
     async handleClaudeResume(message, peerAddress) {
-        const { sessionId: requestedId, prompt, cwd: payloadCwd } = message.payload;
+        const { sessionId: requestedId, prompt, cwd: payloadCwd, agent } = message.payload;
+        const legacyProvider = message.payload.provider;
         const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
         const streamId = generateMessageId();
-        console.log(`[claude:resume] session=${requestedId} cwd=${cwd} prompt=${prompt.slice(0, 80)}`);
+        const resolvedAgent = agent ?? (legacyProvider === 'codex-mcp' ? 'codex' : legacyProvider ? 'claude-code' : undefined);
+        console.log(`[agent:resume] session=${requestedId} agent=${resolvedAgent ?? 'stored'} cwd=${cwd} prompt=${prompt.slice(0, 80)}`);
         // Subscribe before resumeSession starts streaming — hot resume emits events
         // immediately (user_message, then assistant turns), so we must be subscribed
         // before session.send() fires, not after resumeSession() returns.
         this.onPeerSubscribed?.(peerAddress, requestedId);
         try {
             const actualSessionId = await this.claudeService.resumeSession({
-                sessionId: requestedId, prompt, cwd, streamId,
+                sessionId: requestedId,
+                prompt,
+                cwd,
+                streamId,
+                agent: resolvedAgent,
             });
-            console.log(`[claude:resume] session resumed: ${actualSessionId}`);
+            console.log(`[agent:resume] session resumed: ${actualSessionId}`);
             // Re-subscribe with actual session ID (cold resume may return a different ID)
             if (actualSessionId !== requestedId) {
                 this.onPeerSubscribed?.(peerAddress, actualSessionId);
@@ -1018,9 +1291,11 @@ export class MessageHandler {
             const registry = getSessionRegistry();
             const existing = registry.getEntry(cwd, requestedId) ?? registry.getEntry(cwd, actualSessionId);
             const gitBranch = await this.getGitBranchQuiet(cwd);
+            const actualAgent = this.claudeService.getSessionAgent(actualSessionId, cwd);
             registry.upsertEntry({
                 ...(existing ?? { sessionId: actualSessionId, cwd, repoName: basename(cwd), createdAt: Date.now() }),
                 sessionId: actualSessionId,
+                agent: actualAgent,
                 lastAccessedAt: Date.now(),
                 gitBranch,
             });
@@ -1030,7 +1305,7 @@ export class MessageHandler {
             return response;
         }
         catch (error) {
-            console.error(`[claude:resume] error:`, error);
+            console.error(`[agent:resume] error:`, error);
             const response = createMessage('claude:resume:response', { success: false, error: error instanceof Error ? error.message : 'Failed to resume session' });
             response.id = message.id;
             return response;
@@ -1046,14 +1321,14 @@ export class MessageHandler {
     handleClaudeClose(message) {
         const { sessionId } = message.payload;
         const success = this.claudeService.closeSession(sessionId);
-        console.log(`[claude:close] session=${sessionId} success=${success}`);
+        console.log(`[agent:close] session=${sessionId} success=${success}`);
         const response = createMessage('claude:close:response', { success, error: success ? undefined : 'Session not found or already closed' });
         response.id = message.id;
         return response;
     }
     handleClaudeUserInputResponse(message) {
         const resolved = this.claudeService.resolveUserInput(message.payload);
-        console.log(`[claude:user-input-response] requestId=${message.payload.requestId} action=${message.payload.action} resolved=${resolved}`);
+        console.log(`[agent:user-input-response] requestId=${message.payload.requestId} action=${message.payload.action} resolved=${resolved}`);
         // No dedicated response type — just acknowledge
         const response = createMessage('claude:user-input-response', { success: resolved });
         response.id = message.id;
@@ -1122,7 +1397,8 @@ export class MessageHandler {
     // ── Session Registry (History) ──────────────────────────────────────
     handleListHistory(message, peerAddress) {
         const cwd = message.payload.cwd || this.getClientRepoPath(peerAddress);
-        const entries = getSessionRegistry().getEntriesForProject(cwd);
+        const entries = getSessionRegistry().getEntriesForProject(cwd)
+            .filter(e => !e.archived);
         const response = createMessage('session:list-history:response', { entries });
         response.id = message.id;
         return response;
@@ -1148,6 +1424,130 @@ export class MessageHandler {
         }
         return response;
     }
+    handleListProjectSummaries(message) {
+        const allEntries = getSessionRegistry().getEntriesForProject()
+            .filter(e => !e.archived);
+        // Group by cwd
+        const byCwd = new Map();
+        for (const entry of allEntries) {
+            let group = byCwd.get(entry.cwd);
+            if (!group) {
+                group = [];
+                byCwd.set(entry.cwd, group);
+            }
+            group.push(entry);
+        }
+        // Build active session set from session manager
+        const activeSessions = this.claudeService.getActiveSessions();
+        const activeCwds = new Set();
+        for (const s of activeSessions) {
+            activeCwds.add(s.cwd);
+        }
+        const projects = [];
+        for (const [cwd, entries] of byCwd) {
+            // entries are already sorted by lastAccessedAt desc from getEntriesForProject
+            const latest = entries[0];
+            projects.push({
+                cwd,
+                sessionCount: entries.length,
+                lastActivityAt: latest.lastAccessedAt,
+                lastSessionTitle: latest.title ?? latest.firstPrompt?.slice(0, 100),
+                hasActiveSession: activeCwds.has(cwd),
+                isGitRepo: existsSync(join(cwd, '.git')),
+            });
+        }
+        // Sort by lastActivityAt desc
+        projects.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+        const response = createMessage('project:list-summaries:response', { projects });
+        response.id = message.id;
+        return response;
+    }
+    async handleListProjectRepos(message) {
+        const { cwd } = message.payload;
+        const repos = [];
+        const seen = new Set();
+        try {
+            // 1. Check if cwd itself is a git repo
+            const rootBranch = await this.getGitBranchQuiet(cwd);
+            if (rootBranch !== undefined) {
+                repos.push({
+                    path: cwd,
+                    name: basename(cwd),
+                    currentBranch: rootBranch || undefined,
+                });
+                seen.add(cwd);
+            }
+            // 2. Find submodules via git
+            if (rootBranch !== undefined) {
+                try {
+                    const git = new GitOperations(cwd);
+                    const submodules = await git.getSubmodules();
+                    for (const sub of submodules) {
+                        const subPath = join(cwd, sub.path);
+                        if (seen.has(subPath))
+                            continue;
+                        seen.add(subPath);
+                        const branch = await this.getGitBranchQuiet(subPath);
+                        repos.push({
+                            path: subPath,
+                            name: sub.path,
+                            currentBranch: branch || undefined,
+                            isSubmodule: true,
+                        });
+                    }
+                }
+                catch {
+                    // git submodule may fail — ignore
+                }
+            }
+            // 3. Scan for nested git repos (depth-limited, skips node_modules etc.)
+            const MAX_DEPTH = 3;
+            const SKIP_DIRS = new Set(['node_modules', '.git', 'vendor', 'dist', 'build', '.next', '__pycache__']);
+            const scan = async (dir, depth) => {
+                if (depth > MAX_DEPTH)
+                    return;
+                let names;
+                try {
+                    names = await readdir(dir);
+                }
+                catch {
+                    return;
+                }
+                for (const name of names) {
+                    if (name.startsWith('.') || SKIP_DIRS.has(name))
+                        continue;
+                    const full = join(dir, name);
+                    try {
+                        const s = await stat(full);
+                        if (!s.isDirectory())
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (existsSync(join(full, '.git')) && !seen.has(full)) {
+                        seen.add(full);
+                        const branch = await this.getGitBranchQuiet(full);
+                        repos.push({
+                            path: full,
+                            name: full.slice(cwd.length + 1),
+                            currentBranch: branch || undefined,
+                        });
+                    }
+                    await scan(full, depth + 1);
+                }
+            };
+            await scan(cwd, 0);
+        }
+        catch (error) {
+            const response = createMessage('project:list-repos:response', { repos: [], error: error instanceof Error ? error.message : 'Failed to scan repos' });
+            response.id = message.id;
+            return response;
+        }
+        const response = createMessage('project:list-repos:response', { repos });
+        response.id = message.id;
+        return response;
+    }
     async getGitBranchQuiet(cwd) {
         try {
             const git = new GitOperations(cwd);