@sumicom/quicksave 0.3.1 → 0.5.0

package/dist/handlers/messageHandler.js

@@ -1,27 +1,93 @@
-import { createMessage, } from '@sumicom/quicksave-shared';
+import { createMessage, generateMessageId, } from '@sumicom/quicksave-shared';
 import { GitOperations } from '../git/operations.js';
-import { getAnthropicApiKey, setAnthropicApiKey, hasAnthropicApiKey } from '../config.js';
+import { getAnthropicApiKey, setAnthropicApiKey, hasAnthropicApiKey, addManagedRepo, addManagedCodingPath } from '../config.js';
 import { CommitSummaryService } from '../ai/commitSummary.js';
+import { ClaudeCodeService } from '../ai/claudeCodeService.js';
 import { readdir, stat } from 'fs/promises';
 import { join, dirname, basename } from 'path';
 import { homedir } from 'os';
 export class MessageHandler {
     repos;
-    agentVersion = '0.1.0';
-    currentRepoPath;
+    agentVersion = '0.5.0';
+    defaultRepoPath;
+    clientRepos = new Map(); // peerAddress -> repoPath
+    repoLocks = new Map(); // repoPath -> peerAddress holding lock
     availableRepos;
+    codingPaths = new Map(); // path -> CodingPath
     aiService = null;
-    constructor(repos, _license) {
+    claudeService = new ClaudeCodeService();
+    constructor(repos, _license, codingPaths) {
         this.repos = new Map();
         for (const repo of repos) {
             this.repos.set(repo.path, new GitOperations(repo.path));
         }
         this.availableRepos = repos;
-        this.currentRepoPath = repos[0].path;
-        // License handling will be implemented later
+        this.defaultRepoPath = repos.length > 0 ? repos[0].path : '';
+        // Load explicit coding paths only (repos and coding paths are independent)
+        if (codingPaths) {
+            for (const p of codingPaths) {
+                this.codingPaths.set(p, { path: p, name: basename(p) });
+            }
+        }
     }
-    get git() {
-        return this.repos.get(this.currentRepoPath);
+    addRepo(repo) {
+        if (this.repos.has(repo.path))
+            return;
+        this.repos.set(repo.path, new GitOperations(repo.path));
+        this.availableRepos.push(repo);
+        if (!this.defaultRepoPath) {
+            this.defaultRepoPath = repo.path;
+        }
+    }
+    removeRepo(path) {
+        this.repos.delete(path);
+        this.availableRepos = this.availableRepos.filter((r) => r.path !== path);
+        if (this.defaultRepoPath === path) {
+            this.defaultRepoPath = this.availableRepos.length > 0 ? this.availableRepos[0].path : '';
+        }
+    }
+    getClientRepoPath(peerAddress) {
+        return this.clientRepos.get(peerAddress) || this.defaultRepoPath;
+    }
+    getGit(peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        const git = this.repos.get(repoPath);
+        if (!git) {
+            throw new Error('No repository selected. Please add a repository first.');
+        }
+        return git;
+    }
+    acquireRepoLock(repoPath, peerAddress) {
+        const holder = this.repoLocks.get(repoPath);
+        if (holder && holder !== peerAddress) {
+            return false;
+        }
+        this.repoLocks.set(repoPath, peerAddress);
+        return true;
+    }
+    releaseRepoLock(repoPath, peerAddress) {
+        if (this.repoLocks.get(repoPath) === peerAddress) {
+            this.repoLocks.delete(repoPath);
+        }
+    }
+    removeClient(peerAddress) {
+        this.clientRepos.delete(peerAddress);
+        for (const [repoPath, holder] of this.repoLocks) {
+            if (holder === peerAddress) {
+                this.repoLocks.delete(repoPath);
+            }
+        }
+        // Pending user input requests are NOT auto-approved on disconnect.
+        // They persist until the user reconnects and explicitly responds.
+    }
+    cleanup() {
+        this.claudeService.cleanup();
+    }
+    getActiveSessionCount() {
+        return this.claudeService.getActiveSessionCount();
+    }
+    getClaudeService() {
+        return this.claudeService;
     }
     getAiService() {
         const apiKey = getAnthropicApiKey();
@@ -33,49 +99,80 @@ export class MessageHandler {
         }
         return this.aiService;
     }
-    async handleMessage(message) {
+    async handleMessage(message, peerAddress = 'default') {
+        const isVerbose = message.type.startsWith('claude:') || message.type.startsWith('agent:add');
+        if (isVerbose) {
+            console.log(`[msg] ${message.type} from ${peerAddress.slice(0, 12)}`);
+        }
         try {
             switch (message.type) {
                 case 'handshake':
-                    return this.handleHandshake(message);
+                    return this.handleHandshake(message, peerAddress);
                 case 'ping':
                     return createMessage('pong', { timestamp: Date.now() });
                 case 'git:status':
-                    return this.handleStatus(message);
+                    return this.handleStatus(message, peerAddress);
                 case 'git:diff':
-                    return this.handleDiff(message);
+                    return this.handleDiff(message, peerAddress);
                 case 'git:stage':
-                    return this.handleStage(message);
+                    return this.handleStage(message, peerAddress);
                 case 'git:unstage':
-                    return this.handleUnstage(message);
+                    return this.handleUnstage(message, peerAddress);
                 case 'git:stage-patch':
-                    return this.handleStagePatch(message);
+                    return this.handleStagePatch(message, peerAddress);
                 case 'git:unstage-patch':
-                    return this.handleUnstagePatch(message);
+                    return this.handleUnstagePatch(message, peerAddress);
                 case 'git:commit':
-                    return this.handleCommit(message);
+                    return this.handleCommit(message, peerAddress);
                 case 'git:log':
-                    return this.handleLog(message);
+                    return this.handleLog(message, peerAddress);
                 case 'git:branches':
-                    return this.handleBranches();
+                    return this.handleBranches(peerAddress);
                 case 'git:checkout':
-                    return this.handleCheckout(message);
+                    return this.handleCheckout(message, peerAddress);
                 case 'git:discard':
-                    return this.handleDiscard(message);
+                    return this.handleDiscard(message, peerAddress);
+                case 'git:untrack':
+                    return this.handleUntrack(message, peerAddress);
+                case 'git:gitignore-add':
+                    return this.handleGitignoreAdd(message, peerAddress);
+                case 'git:gitignore-read':
+                    return this.handleGitignoreRead(message, peerAddress);
+                case 'git:gitignore-write':
+                    return this.handleGitignoreWrite(message, peerAddress);
                 case 'ai:generate-commit-summary':
-                    return this.handleGenerateCommitSummary(message);
+                    return this.handleGenerateCommitSummary(message, peerAddress);
                 case 'ai:set-api-key':
                     return this.handleSetApiKey(message);
                 case 'ai:get-api-key-status':
                     return this.handleGetApiKeyStatus(message);
                 case 'agent:list-repos':
-                    return this.handleListRepos(message);
+                    return this.handleListRepos(message, peerAddress);
                 case 'agent:switch-repo':
-                    return this.handleSwitchRepo(message);
+                    return this.handleSwitchRepo(message, peerAddress);
                 case 'agent:browse-directory':
                     return this.handleBrowseDirectory(message);
                 case 'agent:add-repo':
                     return this.handleAddRepo(message);
+                case 'agent:list-coding-paths':
+                    return this.handleListCodingPaths(message);
+                case 'agent:add-coding-path':
+                    return this.handleAddCodingPath(message);
+                // Claude Code SDK
+                case 'claude:list-sessions':
+                    return this.handleClaudeListSessions(message, peerAddress);
+                case 'claude:start':
+                    return this.handleClaudeStart(message, peerAddress);
+                case 'claude:resume':
+                    return this.handleClaudeResume(message, peerAddress);
+                case 'claude:cancel':
+                    return this.handleClaudeCancel(message);
+                case 'claude:close':
+                    return this.handleClaudeClose(message);
+                case 'claude:get-messages':
+                    return this.handleClaudeGetMessages(message, peerAddress);
+                case 'claude:user-input-response':
+                    return this.handleClaudeUserInputResponse(message);
                 default:
                     return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
             }
@@ -85,32 +182,48 @@ export class MessageHandler {
             return this.createErrorResponse(message.id, 'HANDLER_ERROR', errorMessage);
         }
     }
-    handleHandshake(message) {
+    handleHandshake(message, peerAddress) {
         const response = createMessage('handshake:ack', {
             success: true,
             agentVersion: this.agentVersion,
-            repoPath: this.currentRepoPath,
+            repoPath: this.getClientRepoPath(peerAddress),
             availableRepos: this.availableRepos,
+            availableCodingPaths: [...this.codingPaths.values()],
         });
         response.id = message.id;
+        // Re-emit pending user input requests so they get broadcast to the new peer
+        const pending = this.claudeService.getPendingInputRequests();
+        for (const request of pending) {
+            console.log(`[handshake] re-emitting pending user input: requestId=${request.requestId}`);
+            this.claudeService.emit('user-input-request', request);
+        }
         return response;
     }
-    async handleStatus(message) {
-        const status = await this.git.getStatus();
+    async handleStatus(message, peerAddress) {
+        const status = await this.getGit(peerAddress).getStatus();
         const response = createMessage('git:status:response', status);
         response.id = message.id;
         return response;
     }
-    async handleDiff(message) {
+    async handleDiff(message, peerAddress) {
         const { path, staged } = message.payload;
-        const diff = await this.git.getDiff(path, staged);
+        const diff = await this.getGit(peerAddress).getDiff(path, staged);
         const response = createMessage('git:diff:response', diff);
         response.id = message.id;
         return response;
     }
-    async handleStage(message) {
+    async handleStage(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:stage:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
         try {
-            await this.git.stage(message.payload.paths);
+            await this.getGit(peerAddress).stage(message.payload.paths);
             const response = createMessage('git:stage:response', { success: true });
             response.id = message.id;
             return response;
@@ -123,10 +236,22 @@ export class MessageHandler {
             response.id = message.id;
             return response;
         }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
     }
-    async handleUnstage(message) {
+    async handleUnstage(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:unstage:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
         try {
-            await this.git.unstage(message.payload.paths);
+            await this.getGit(peerAddress).unstage(message.payload.paths);
             const response = createMessage('git:unstage:response', { success: true });
             response.id = message.id;
             return response;
@@ -139,10 +264,22 @@ export class MessageHandler {
             response.id = message.id;
             return response;
         }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
     }
-    async handleStagePatch(message) {
+    async handleStagePatch(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:stage-patch:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
         try {
-            await this.git.stagePatch(message.payload.patch);
+            await this.getGit(peerAddress).stagePatch(message.payload.patch);
             const response = createMessage('git:stage-patch:response', { success: true });
             response.id = message.id;
             return response;
@@ -155,10 +292,22 @@ export class MessageHandler {
             response.id = message.id;
             return response;
         }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
     }
-    async handleUnstagePatch(message) {
+    async handleUnstagePatch(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:unstage-patch:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
         try {
-            await this.git.unstagePatch(message.payload.patch);
+            await this.getGit(peerAddress).unstagePatch(message.payload.patch);
             const response = createMessage('git:unstage-patch:response', { success: true });
             response.id = message.id;
             return response;
@@ -171,11 +320,23 @@ export class MessageHandler {
             response.id = message.id;
             return response;
         }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
     }
-    async handleCommit(message) {
+    async handleCommit(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:commit:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
         try {
             const { message: commitMessage, description } = message.payload;
-            const hash = await this.git.commit(commitMessage, description);
+            const hash = await this.getGit(peerAddress).commit(commitMessage, description);
             const response = createMessage('git:commit:response', {
                 success: true,
                 hash,
@@ -191,25 +352,37 @@ export class MessageHandler {
             response.id = message.id;
             return response;
         }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
     }
-    async handleLog(message) {
+    async handleLog(message, peerAddress) {
         const limit = message.payload.limit || 50;
-        const commits = await this.git.getLog(limit);
+        const commits = await this.getGit(peerAddress).getLog(limit);
         const response = createMessage('git:log:response', { commits });
         response.id = message.id;
         return response;
     }
-    async handleBranches() {
-        const { branches, current } = await this.git.getBranches();
+    async handleBranches(peerAddress) {
+        const { branches, current } = await this.getGit(peerAddress).getBranches();
         return createMessage('git:branches:response', {
             branches,
             current,
         });
     }
-    async handleCheckout(message) {
+    async handleCheckout(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:checkout:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
         try {
             const { branch, create } = message.payload;
-            await this.git.checkout(branch, create);
+            await this.getGit(peerAddress).checkout(branch, create);
             const response = createMessage('git:checkout:response', { success: true });
             response.id = message.id;
             return response;
@@ -222,10 +395,22 @@ export class MessageHandler {
             response.id = message.id;
             return response;
         }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
     }
-    async handleDiscard(message) {
+    async handleDiscard(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:discard:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
         try {
-            await this.git.discard(message.payload.paths);
+            await this.getGit(peerAddress).discard(message.payload.paths);
             const response = createMessage('git:discard:response', { success: true });
             response.id = message.id;
             return response;
@@ -238,8 +423,101 @@ export class MessageHandler {
             response.id = message.id;
             return response;
         }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
+    }
+    async handleUntrack(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:untrack:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
+        try {
+            await this.getGit(peerAddress).untrack(message.payload.paths);
+            const response = createMessage('git:untrack:response', { success: true });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('git:untrack:response', {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to untrack files',
+            });
+            response.id = message.id;
+            return response;
+        }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
+    }
+    async handleGitignoreAdd(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:gitignore-add:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
+        try {
+            await this.getGit(peerAddress).addToGitignore(message.payload.pattern);
+            const response = createMessage('git:gitignore-add:response', { success: true });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('git:gitignore-add:response', {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to add to .gitignore',
+            });
+            response.id = message.id;
+            return response;
+        }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
     }
-    async handleGenerateCommitSummary(message) {
+    async handleGitignoreRead(message, peerAddress) {
+        const { content, exists } = await this.getGit(peerAddress).readGitignore();
+        const response = createMessage('git:gitignore-read:response', { content, exists });
+        response.id = message.id;
+        return response;
+    }
+    async handleGitignoreWrite(message, peerAddress) {
+        const repoPath = this.getClientRepoPath(peerAddress);
+        if (!this.acquireRepoLock(repoPath, peerAddress)) {
+            const response = createMessage('git:gitignore-write:response', {
+                success: false,
+                error: 'Repository is busy — another device is performing an operation',
+            });
+            response.id = message.id;
+            return response;
+        }
+        try {
+            await this.getGit(peerAddress).writeGitignore(message.payload.content);
+            const response = createMessage('git:gitignore-write:response', { success: true });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('git:gitignore-write:response', {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to write .gitignore',
+            });
+            response.id = message.id;
+            return response;
+        }
+        finally {
+            this.releaseRepoLock(repoPath, peerAddress);
+        }
+    }
+    async handleGenerateCommitSummary(message, peerAddress) {
         const aiService = this.getAiService();
         if (!aiService) {
             const response = createMessage('ai:generate-commit-summary:response', {
@@ -251,7 +529,8 @@ export class MessageHandler {
             return response;
         }
         try {
-            const status = await this.git.getStatus();
+            const git = this.getGit(peerAddress);
+            const status = await git.getStatus();
             if (status.staged.length === 0) {
                 const response = createMessage('ai:generate-commit-summary:response', {
                     success: false,
@@ -262,7 +541,7 @@ export class MessageHandler {
                 return response;
             }
             // Collect diffs for all staged files
-            const diffs = await Promise.all(status.staged.map((file) => this.git.getDiff(file.path, true)));
+            const diffs = await Promise.all(status.staged.map((file) => git.getDiff(file.path, true)));
             // Generate summary (uses internal queue and cache)
             const result = await aiService.generateSummary({
                 diffs,
@@ -316,7 +595,7 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
-    async handleListRepos(message) {
+    async handleListRepos(message, peerAddress) {
         // Refresh branch info for all repos
         const repos = [];
         for (const repo of this.availableRepos) {
@@ -331,24 +610,24 @@ export class MessageHandler {
         }
         const response = createMessage('agent:list-repos:response', {
             repos,
-            current: this.currentRepoPath,
+            current: this.getClientRepoPath(peerAddress),
         });
         response.id = message.id;
         return response;
     }
-    handleSwitchRepo(message) {
+    handleSwitchRepo(message, peerAddress) {
         const { path } = message.payload;
         // Check if the requested repo is in our available repos
         if (!this.repos.has(path)) {
             const response = createMessage('agent:switch-repo:response', {
                 success: false,
-                newPath: this.currentRepoPath,
+                newPath: this.getClientRepoPath(peerAddress),
                 error: `Repository not available: ${path}`,
             });
             response.id = message.id;
             return response;
         }
-        this.currentRepoPath = path;
+        this.clientRepos.set(peerAddress, path);
         const response = createMessage('agent:switch-repo:response', {
             success: true,
             newPath: path,
@@ -427,17 +706,29 @@ export class MessageHandler {
             return response;
         }
         try {
-            // Verify it's a git repo by trying to get branches
+            // Verify it's a git repo and resolve to actual root
             const git = new GitOperations(repoPath);
             const { current } = await git.getBranches();
-            // Add to our maps
-            this.repos.set(repoPath, git);
+            const rootPath = await git.getGitRoot();
+            // Check if already added (by resolved root path)
+            if (this.repos.has(rootPath)) {
+                const response = createMessage('agent:add-repo:response', {
+                    success: false,
+                    error: 'Repository already added',
+                });
+                response.id = message.id;
+                return response;
+            }
+            // Add to our maps using the actual git root
+            this.repos.set(rootPath, git);
             const newRepo = {
-                path: repoPath,
-                name: basename(repoPath),
+                path: rootPath,
+                name: basename(rootPath),
                 currentBranch: current,
             };
             this.availableRepos.push(newRepo);
+            // Persist to agent.json
+            addManagedRepo(rootPath);
             const response = createMessage('agent:add-repo:response', {
                 success: true,
                 repo: newRepo,
@@ -454,6 +745,144 @@ export class MessageHandler {
             return response;
         }
     }
+    // ============================================================================
+    // Coding Path Handlers
+    // ============================================================================
+    handleListCodingPaths(message) {
+        const response = createMessage('agent:list-coding-paths:response', { paths: [...this.codingPaths.values()] });
+        response.id = message.id;
+        return response;
+    }
+    async handleAddCodingPath(message) {
+        const { path: codingPath } = message.payload;
+        if (this.codingPaths.has(codingPath)) {
+            const response = createMessage('agent:add-coding-path:response', { success: false, error: 'Coding path already added' });
+            response.id = message.id;
+            return response;
+        }
+        try {
+            // Verify directory exists
+            const dirStat = await stat(codingPath);
+            if (!dirStat.isDirectory()) {
+                const response = createMessage('agent:add-coding-path:response', { success: false, error: 'Path is not a directory' });
+                response.id = message.id;
+                return response;
+            }
+            const newPath = { path: codingPath, name: basename(codingPath) };
+            this.codingPaths.set(codingPath, newPath);
+            addManagedCodingPath(codingPath);
+            const response = createMessage('agent:add-coding-path:response', { success: true, path: newPath });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('agent:add-coding-path:response', { success: false, error: error instanceof Error ? error.message : 'Failed to add coding path' });
+            response.id = message.id;
+            return response;
+        }
+    }
+    // ============================================================================
+    // Claude Code SDK Handlers
+    // ============================================================================
+    async handleClaudeListSessions(message, peerAddress) {
+        try {
+            const cwd = message.payload.cwd || this.getClientRepoPath(peerAddress);
+            const sessions = await this.claudeService.listAvailableSessions(cwd);
+            const response = createMessage('claude:list-sessions:response', { sessions });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('claude:list-sessions:response', { sessions: [], error: error instanceof Error ? error.message : 'Failed to list sessions' });
+            response.id = message.id;
+            return response;
+        }
+    }
+    async handleClaudeStart(message, peerAddress) {
+        const { prompt, cwd: payloadCwd, allowedTools, systemPrompt, model, permissionMode } = message.payload;
+        const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
+        const streamId = generateMessageId();
+        console.log(`[claude:start] cwd=${cwd} prompt=${prompt.slice(0, 80)}`);
+        try {
+            const sessionId = await this.claudeService.startSession({
+                prompt, cwd, streamId, allowedTools, systemPrompt, model, permissionMode,
+            });
+            console.log(`[claude:start] session created: ${sessionId}`);
+            const response = createMessage('claude:start:response', { success: true, sessionId, streamId });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            console.error(`[claude: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 cwd = payloadCwd || this.getClientRepoPath(peerAddress);
+        const streamId = generateMessageId();
+        console.log(`[claude:resume] session=${requestedId} cwd=${cwd} prompt=${prompt.slice(0, 80)}`);
+        try {
+            const actualSessionId = await this.claudeService.resumeSession({
+                sessionId: requestedId, prompt, cwd, streamId,
+            });
+            console.log(`[claude:resume] session resumed: ${actualSessionId}`);
+            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);
+            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) {
+        const { sessionId } = message.payload;
+        const success = 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;
+    }
+    handleClaudeClose(message) {
+        const { sessionId } = message.payload;
+        const success = this.claudeService.closeSession(sessionId);
+        console.log(`[claude: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}`);
+        // No dedicated response type — just acknowledge
+        const response = createMessage('claude:user-input-response', { success: resolved });
+        response.id = message.id;
+        return response;
+    }
+    async handleClaudeGetMessages(message, peerAddress) {
+        const { sessionId, cwd: payloadCwd, offset = 0, limit = 50 } = message.payload;
+        const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
+        try {
+            const result = await this.claudeService.getMessages(sessionId, cwd, offset, limit);
+            const response = createMessage('claude:get-messages:response', result);
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const response = createMessage('claude:get-messages:response', {
+                messages: [],
+                total: 0,
+                hasMore: false,
+                error: error instanceof Error ? error.message : 'Failed to get messages',
+            });
+            response.id = message.id;
+            return response;
+        }
+    }
     createErrorResponse(id, code, message) {
         const response = createMessage('error', { code, message });
         response.id = id;