@sumicom/quicksave 0.6.0 → 0.6.2

package/dist/handlers/messageHandler.js

@@ -1,26 +1,36 @@
 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 { ClaudeCodeService } from '../ai/claudeCodeService.js';
-import { readdir, stat } from 'fs/promises';
+import { SessionManager } from '../ai/sessionManager.js';
+import { ClaudeCodeProvider } from '../ai/claudeCodeProvider.js';
+import { CodexSdkProvider } from '../ai/codexSdkProvider.js';
+import { getSessionRegistry } from '../ai/sessionRegistry.js';
+import { readdir, stat, readFile } from 'fs/promises';
 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.0';
+    agentVersion = '0.6.2';
     defaultRepoPath;
     clientRepos = new Map(); // peerAddress -> repoPath
     repoLocks = new Map(); // repoPath -> peerAddress holding lock
     availableRepos;
     codingPaths = new Map(); // path -> CodingPath
     aiService = null;
-    claudeService = new ClaudeCodeService();
+    claudeService = new SessionManager([
+        new ClaudeCodeProvider(),
+        new CodexSdkProvider(),
+    ]);
     latestVersionCache = null;
     versionCheckInFlight = null;
+    codexModelsCache = null;
+    codexModelsCheckInFlight = null;
     onPeerSubscribed;
     onPeerUnsubscribed;
+    onHistoryUpdated;
     productionBuild;
     constructor(repos, _license, codingPaths, productionBuild = false) {
         this.repos = new Map();
@@ -73,6 +83,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;
@@ -177,6 +240,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':
@@ -197,14 +266,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);
@@ -237,6 +316,12 @@ export class MessageHandler {
                     return this.handleGetSessionConfig(message);
                 case 'session:set-config':
                     return this.handleSetSessionConfig(message);
+                case 'session:list-history':
+                    return this.handleListHistory(message, peerAddress);
+                case 'session:update-history':
+                    return this.handleUpdateHistory(message);
+                case 'session:delete-history':
+                    return this.handleDeleteHistory(message);
                 default:
                     return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
             }
@@ -247,8 +332,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,
@@ -258,6 +344,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;
@@ -398,8 +485,8 @@ export class MessageHandler {
             return response;
         }
         try {
-            const { message: commitMessage, description } = message.payload;
-            const hash = await this.getGit(peerAddress).commit(commitMessage, description);
+            const { message: commitMessage, description, attribution } = message.payload;
+            const hash = await this.getGit(peerAddress).commit(commitMessage, description, attribution ?? true);
             const response = createMessage('git:commit:response', {
                 success: true,
                 hash,
@@ -518,6 +605,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)) {
@@ -603,13 +729,24 @@ export class MessageHandler {
                 response.id = message.id;
                 return response;
             }
-            // Collect diffs for all staged files
-            const diffs = await Promise.all(status.staged.map((file) => git.getDiff(file.path, true)));
+            // Collect diffs and context in parallel
+            const [diffs, recentLog, branchInfo, conventions] = await Promise.all([
+                Promise.all(status.staged.map((file) => git.getDiff(file.path, true))),
+                git.getLog(10).catch(() => []),
+                git.getBranches().catch(() => ({ current: '' })),
+                git.readCommitConventions().catch(() => undefined),
+            ]);
+            const recentCommits = recentLog.map((c) => c.message);
+            const branchName = branchInfo.current;
             // Generate summary (uses internal queue and cache)
             const result = await aiService.generateSummary({
                 diffs,
                 context: message.payload.context,
                 model: message.payload.model,
+                recentCommits: recentCommits.length > 0 ? recentCommits : undefined,
+                branchName: branchName || undefined,
+                conventions,
+                attribution: message.payload.attribution,
             });
             const response = createMessage('ai:generate-commit-summary:response', {
                 success: true,
@@ -808,6 +945,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
     // ============================================================================
@@ -844,6 +1056,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
     // ============================================================================
@@ -923,6 +1148,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
     // ============================================================================
@@ -941,59 +1210,105 @@ export class MessageHandler {
         }
     }
     async handleClaudeStart(message, peerAddress) {
-        const { prompt, cwd: payloadCwd, allowedTools, systemPrompt, model, permissionMode } = 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)}`);
+        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,
+                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 });
             response.id = message.id;
             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);
             }
+            // Update session history
+            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,
+            });
+            this.onHistoryUpdated?.(cwd, registry.getEntry(cwd, actualSessionId), 'upsert');
             const response = createMessage('claude:resume:response', { success: true, sessionId: actualSessionId, streamId });
             response.id = message.id;
             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;
         }
     }
-    handleClaudeCancel(message) {
+    async handleClaudeCancel(message) {
         const { sessionId } = message.payload;
-        const success = this.claudeService.cancelSession(sessionId);
+        const success = await this.claudeService.cancelSession(sessionId);
         const response = createMessage('claude:cancel:response', { success, error: success ? undefined : 'Session not found or already ended' });
         response.id = message.id;
         return response;
@@ -1001,14 +1316,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;
@@ -1074,6 +1389,45 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
+    // ── Session Registry (History) ──────────────────────────────────────
+    handleListHistory(message, peerAddress) {
+        const cwd = message.payload.cwd || this.getClientRepoPath(peerAddress);
+        const entries = getSessionRegistry().getEntriesForProject(cwd);
+        const response = createMessage('session:list-history:response', { entries });
+        response.id = message.id;
+        return response;
+    }
+    handleUpdateHistory(message) {
+        const { sessionId, cwd, updates } = message.payload;
+        const entry = getSessionRegistry().updateEntry(cwd, sessionId, updates);
+        const response = createMessage('session:update-history:response', entry ? { success: true, entry } : { success: false, error: 'Entry not found' });
+        response.id = message.id;
+        if (entry) {
+            this.onHistoryUpdated?.(cwd, entry, 'upsert');
+        }
+        return response;
+    }
+    handleDeleteHistory(message) {
+        const { sessionId, cwd } = message.payload;
+        const entry = getSessionRegistry().getEntry(cwd, sessionId);
+        const success = getSessionRegistry().deleteEntry(cwd, sessionId);
+        const response = createMessage('session:delete-history:response', { success, error: success ? undefined : 'Entry not found' });
+        response.id = message.id;
+        if (success && entry) {
+            this.onHistoryUpdated?.(cwd, entry, 'delete');
+        }
+        return response;
+    }
+    async getGitBranchQuiet(cwd) {
+        try {
+            const git = new GitOperations(cwd);
+            const { current } = await git.getBranches();
+            return current || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     createErrorResponse(id, code, message) {
         const response = createMessage('error', { code, message });
         response.id = id;