mstro-app 0.1.57 → 0.2.0

package/dist/server/services/websocket/handler.js

@@ -13,27 +13,34 @@ import { dirname, join } from 'node:path';
 import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import { AnalyticsEvents, trackEvent } from '../analytics.js';
 import { createDirectory, createFile, deleteFile, listDirectory, renameFile, writeFile } from '../files.js';
+import { validatePathWithinWorkingDir } from '../pathUtils.js';
 import { captureException } from '../sentry.js';
-import { getModel, getSettings, setModel } from '../settings.js';
+import { getModel, getPrBaseBranch, getSettings, setModel, setPrBaseBranch } from '../settings.js';
 import { getPTYManager } from '../terminal/pty-manager.js';
 import { AutocompleteService } from './autocomplete.js';
 import { readFileContent } from './file-utils.js';
 import { SessionRegistry } from './session-registry.js';
+/** Convert tool history entries into OutputLine-compatible lines */
+function convertToolHistoryToLines(tools, ts) {
+    const lines = [];
+    for (const tool of tools) {
+        lines.push({ type: 'tool-call', text: '', toolName: tool.toolName, toolInput: tool.toolInput || {}, timestamp: ts });
+        if (tool.result !== undefined) {
+            lines.push({ type: 'tool-result', text: '', toolResult: tool.result || 'No output', toolStatus: tool.isError ? 'error' : 'success', timestamp: ts });
+        }
+    }
+    return lines;
+}
 /** Convert a single movement record into OutputLine-compatible entries */
 function convertMovementToLines(movement) {
     const lines = [];
     const ts = new Date(movement.timestamp).getTime();
-    lines.push({ type: 'user', text: `> ${movement.userPrompt}`, timestamp: ts });
+    lines.push({ type: 'user', text: movement.userPrompt, timestamp: ts });
     if (movement.thinkingOutput) {
         lines.push({ type: 'thinking', text: '', thinking: movement.thinkingOutput, timestamp: ts });
     }
     if (movement.toolUseHistory) {
-        for (const tool of movement.toolUseHistory) {
-            lines.push({ type: 'tool-call', text: '', toolName: tool.toolName, toolInput: tool.toolInput || {}, timestamp: ts });
-            if (tool.result !== undefined) {
-                lines.push({ type: 'tool-result', text: '', toolResult: tool.result || 'No output', toolStatus: tool.isError ? 'error' : 'success', timestamp: ts });
-            }
-        }
+        lines.push(...convertToolHistoryToLines(movement.toolUseHistory, ts));
     }
     if (movement.assistantResponse) {
         lines.push({ type: 'assistant', text: movement.assistantResponse, timestamp: ts });
@@ -41,9 +48,20 @@ function convertMovementToLines(movement) {
     if (movement.errorOutput) {
         lines.push({ type: 'error', text: `Error: ${movement.errorOutput}`, timestamp: ts });
     }
-    lines.push({ type: 'system', text: `Command completed (tokens: ${movement.tokensUsed.toLocaleString()})`, timestamp: ts });
+    const durationText = movement.durationMs
+        ? `Completed in ${(movement.durationMs / 1000).toFixed(2)}s`
+        : 'Completed';
+    lines.push({ type: 'system', text: durationText, timestamp: ts });
     return lines;
 }
+/** Detect git provider from remote URL */
+function detectGitProvider(remoteUrl) {
+    if (remoteUrl.includes('github.com'))
+        return 'github';
+    if (remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab'))
+        return 'gitlab';
+    return 'unknown';
+}
 export class WebSocketImproviseHandler {
     sessions = new Map();
     connections = new Map();
@@ -127,7 +145,10 @@ export class WebSocketImproviseHandler {
         try {
             const msg = JSON.parse(message);
             const tabId = msg.tabId || 'default';
-            await this.dispatchMessage(ws, msg, tabId, workingDir);
+            // Extract sandbox permission injected by server relay (for sandboxed shared users)
+            const permission = msg._permission;
+            delete msg._permission;
+            await this.dispatchMessage(ws, msg, tabId, workingDir, permission);
         }
         catch (error) {
             console.error('[WebSocketImproviseHandler] Error handling message:', error);
@@ -141,7 +162,7 @@ export class WebSocketImproviseHandler {
     /**
      * Dispatch a parsed message to the appropriate handler
      */
-    async dispatchMessage(ws, msg, tabId, workingDir) {
+    async dispatchMessage(ws, msg, tabId, workingDir, permission) {
         switch (msg.type) {
             case 'ping':
                 this.send(ws, { type: 'pong', tabId });
@@ -158,7 +179,7 @@ export class WebSocketImproviseHandler {
             case 'new':
             case 'approve':
             case 'reject':
-                return this.handleSessionMessage(ws, msg, tabId);
+                return this.handleSessionMessage(ws, msg, tabId, permission);
             case 'getSessions':
             case 'getSessionsCount':
             case 'getSessionById':
@@ -170,16 +191,14 @@ export class WebSocketImproviseHandler {
             case 'readFile':
             case 'recordSelection':
             case 'requestNotificationSummary':
-                return this.handleFileMessage(ws, msg, tabId, workingDir);
+                return this.handleFileMessage(ws, msg, tabId, workingDir, permission);
             case 'terminalInit':
             case 'terminalReconnect':
             case 'terminalList':
-            case 'terminalInitPersistent':
-            case 'terminalListPersistent':
             case 'terminalInput':
             case 'terminalResize':
             case 'terminalClose':
-                return this.handleTerminalMessage(ws, msg, tabId, workingDir);
+                return this.handleTerminalMessage(ws, msg, tabId, workingDir, permission);
             case 'listDirectory':
             case 'writeFile':
             case 'createFile':
@@ -187,7 +206,7 @@ export class WebSocketImproviseHandler {
             case 'deleteFile':
             case 'renameFile':
             case 'notifyFileOpened':
-                return this.handleFileExplorerMessage(ws, msg, tabId, workingDir);
+                return this.handleFileExplorerMessage(ws, msg, tabId, workingDir, permission);
             case 'gitStatus':
             case 'gitStage':
             case 'gitUnstage':
@@ -197,6 +216,9 @@ export class WebSocketImproviseHandler {
             case 'gitLog':
             case 'gitDiscoverRepos':
             case 'gitSetDirectory':
+            case 'gitGetRemoteInfo':
+            case 'gitCreatePR':
+            case 'gitGeneratePRDescription':
                 return this.handleGitMessage(ws, msg, tabId, workingDir);
             // Session sync messages
             case 'getActiveTabs':
@@ -225,19 +247,19 @@ export class WebSocketImproviseHandler {
     /**
      * Handle session-related messages (execute, cancel, history, new, approve, reject)
      */
-    handleSessionMessage(ws, msg, tabId) {
+    handleSessionMessage(ws, msg, tabId, permission) {
         switch (msg.type) {
             case 'execute': {
                 if (!msg.data?.prompt)
                     throw new Error('Prompt is required');
                 const session = this.requireSession(ws, tabId);
-                session.executePrompt(msg.data.prompt, msg.data.attachments);
+                const sandboxed = permission === 'control' || permission === 'view';
+                session.executePrompt(msg.data.prompt, msg.data.attachments, { sandboxed });
                 break;
             }
             case 'cancel': {
                 const session = this.requireSession(ws, tabId);
                 session.cancel();
-                this.send(ws, { type: 'output', tabId, data: { text: '\n⚠️  Operation cancelled\n' } });
                 break;
             }
             case 'getHistory': {
@@ -313,7 +335,7 @@ export class WebSocketImproviseHandler {
     /**
      * Handle file-related messages (autocomplete, readFile, recordSelection, notifications)
      */
-    handleFileMessage(ws, msg, tabId, workingDir) {
+    handleFileMessage(ws, msg, tabId, workingDir, permission) {
         switch (msg.type) {
             case 'autocomplete':
                 if (!msg.data?.partialPath)
@@ -321,9 +343,7 @@ export class WebSocketImproviseHandler {
                 this.send(ws, { type: 'autocomplete', tabId, data: { completions: this.autocompleteService.getFileCompletions(msg.data.partialPath, workingDir) } });
                 break;
             case 'readFile':
-                if (!msg.data?.filePath)
-                    throw new Error('File path is required');
-                this.send(ws, { type: 'fileContent', tabId, data: readFileContent(msg.data.filePath, workingDir) });
+                this.handleReadFile(ws, msg, tabId, workingDir, permission);
                 break;
             case 'recordSelection':
                 if (msg.data?.filePath)
@@ -336,14 +356,27 @@ export class WebSocketImproviseHandler {
                 break;
         }
     }
+    handleReadFile(ws, msg, tabId, workingDir, permission) {
+        if (!msg.data?.filePath)
+            throw new Error('File path is required');
+        const isSandboxed = permission === 'control' || permission === 'view';
+        if (isSandboxed) {
+            const validation = validatePathWithinWorkingDir(msg.data.filePath, workingDir);
+            if (!validation.valid) {
+                this.send(ws, { type: 'fileContent', tabId, data: { path: msg.data.filePath, fileName: msg.data.filePath.split('/').pop() || '', content: '', error: 'Sandboxed: path outside project directory' } });
+                return;
+            }
+        }
+        this.send(ws, { type: 'fileContent', tabId, data: readFileContent(msg.data.filePath, workingDir) });
+    }
     /**
      * Handle terminal messages
      */
-    handleTerminalMessage(ws, msg, tabId, workingDir) {
+    handleTerminalMessage(ws, msg, tabId, workingDir, permission) {
         const termId = msg.terminalId || tabId;
         switch (msg.type) {
             case 'terminalInit':
-                this.handleTerminalInit(ws, termId, workingDir, msg.data?.shell, msg.data?.cols, msg.data?.rows);
+                this.handleTerminalInit(ws, termId, workingDir, msg.data?.shell, msg.data?.cols, msg.data?.rows, permission);
                 break;
             case 'terminalReconnect':
                 this.handleTerminalReconnect(ws, termId);
@@ -351,12 +384,6 @@ export class WebSocketImproviseHandler {
             case 'terminalList':
                 this.handleTerminalList(ws);
                 break;
-            case 'terminalInitPersistent':
-                this.handleTerminalInitPersistent(ws, termId, workingDir, msg.data?.shell, msg.data?.cols, msg.data?.rows);
-                break;
-            case 'terminalListPersistent':
-                this.handleTerminalListPersistent(ws);
-                break;
             case 'terminalInput':
                 this.handleTerminalInput(ws, termId, msg.data?.input);
                 break;
@@ -465,9 +492,20 @@ export class WebSocketImproviseHandler {
             });
         }
     }
-    handleFileExplorerMessage(ws, msg, tabId, workingDir) {
+    handleFileExplorerMessage(ws, msg, tabId, workingDir, permission) {
+        const isSandboxed = permission === 'control' || permission === 'view';
         const handlers = {
-            listDirectory: () => this.handleListDirectory(ws, msg, tabId, workingDir),
+            listDirectory: () => {
+                // Sandboxed users can only list directories within the project
+                if (isSandboxed && msg.data?.dirPath) {
+                    const validation = validatePathWithinWorkingDir(msg.data.dirPath, workingDir);
+                    if (!validation.valid) {
+                        this.send(ws, { type: 'directoryListing', tabId, data: { success: false, path: msg.data.dirPath, error: 'Sandboxed: path outside project directory' } });
+                        return;
+                    }
+                }
+                this.handleListDirectory(ws, msg, tabId, workingDir);
+            },
             writeFile: () => this.handleWriteFile(ws, msg, tabId, workingDir),
             createFile: () => this.handleCreateFile(ws, msg, tabId, workingDir),
             createDirectory: () => this.handleCreateDirectory(ws, msg, tabId, workingDir),
@@ -499,10 +537,10 @@ export class WebSocketImproviseHandler {
             this.send(ws, { type: 'thinking', tabId, data: { text } });
         });
         session.on('onMovementStart', (sequenceNumber, prompt) => {
-            this.send(ws, { type: 'movementStart', tabId, data: { sequenceNumber, prompt, timestamp: Date.now() } });
+            this.send(ws, { type: 'movementStart', tabId, data: { sequenceNumber, prompt, timestamp: Date.now(), executionStartTimestamp: session.executionStartTimestamp } });
             // Broadcast execution state to ALL clients so tab indicators update
             // even if per-tab event subscriptions aren't ready yet (e.g., newly discovered tabs)
-            this.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: true } });
+            this.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: true, executionStartTimestamp: session.executionStartTimestamp } });
         });
         session.on('onMovementComplete', (movement) => {
             this.send(ws, { type: 'movementComplete', tabId, data: movement });
@@ -681,6 +719,7 @@ export class WebSocketImproviseHandler {
                 outputHistory,
                 isExecuting: session.isExecuting,
                 executionEvents,
+                ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
             }
         });
     }
@@ -767,12 +806,12 @@ export class WebSocketImproviseHandler {
      * Get count of all historical sessions without reading file contents
      */
     getSessionsCount(workingDir) {
-        const sessionsDir = join(workingDir, '.mstro', 'improvise');
+        const sessionsDir = join(workingDir, '.mstro', 'history');
         if (!existsSync(sessionsDir)) {
             return 0;
         }
         return readdirSync(sessionsDir)
-            .filter((name) => name.startsWith('history-') && name.endsWith('.json'))
+            .filter((name) => name.endsWith('.json'))
             .length;
     }
     /**
@@ -780,16 +819,16 @@ export class WebSocketImproviseHandler {
      * Returns minimal metadata - movements are stripped to just userPrompt preview
      */
     getSessionsList(workingDir, limit = 20, offset = 0) {
-        const sessionsDir = join(workingDir, '.mstro', 'improvise');
+        const sessionsDir = join(workingDir, '.mstro', 'history');
         if (!existsSync(sessionsDir)) {
             return { sessions: [], total: 0, hasMore: false };
         }
         // Get sorted file list (newest first) without reading contents
         const historyFiles = readdirSync(sessionsDir)
-            .filter((name) => name.startsWith('history-') && name.endsWith('.json'))
+            .filter((name) => name.endsWith('.json'))
             .sort((a, b) => {
-            const timestampA = parseInt(a.replace('history-', '').replace('.json', ''), 10);
-            const timestampB = parseInt(b.replace('history-', '').replace('.json', ''), 10);
+            const timestampA = parseInt(a.replace('.json', ''), 10);
+            const timestampB = parseInt(b.replace('.json', ''), 10);
             return timestampB - timestampA;
         });
         const total = historyFiles.length;
@@ -828,12 +867,12 @@ export class WebSocketImproviseHandler {
      * Get a full session by ID (includes all movement data)
      */
     getSessionById(workingDir, sessionId) {
-        const sessionsDir = join(workingDir, '.mstro', 'improvise');
+        const sessionsDir = join(workingDir, '.mstro', 'history');
         if (!existsSync(sessionsDir)) {
             return null;
         }
         const historyFiles = readdirSync(sessionsDir)
-            .filter((name) => name.startsWith('history-') && name.endsWith('.json'));
+            .filter((name) => name.endsWith('.json'));
         for (const filename of historyFiles) {
             const historyPath = join(sessionsDir, filename);
             try {
@@ -861,13 +900,13 @@ export class WebSocketImproviseHandler {
      * Delete a single session from disk
      */
     deleteSession(workingDir, sessionId) {
-        const sessionsDir = join(workingDir, '.mstro', 'improvise');
+        const sessionsDir = join(workingDir, '.mstro', 'history');
         if (!existsSync(sessionsDir)) {
             return { sessionId, success: false };
         }
         try {
             const historyFiles = readdirSync(sessionsDir)
-                .filter((name) => name.startsWith('history-') && name.endsWith('.json'));
+                .filter((name) => name.endsWith('.json'));
             for (const filename of historyFiles) {
                 const historyPath = join(sessionsDir, filename);
                 try {
@@ -892,13 +931,13 @@ export class WebSocketImproviseHandler {
      * Clear all sessions from disk
      */
     clearAllSessions(workingDir) {
-        const sessionsDir = join(workingDir, '.mstro', 'improvise');
+        const sessionsDir = join(workingDir, '.mstro', 'history');
         if (!existsSync(sessionsDir)) {
             return { success: true, deletedCount: 0 };
         }
         try {
             const historyFiles = readdirSync(sessionsDir)
-                .filter((name) => name.startsWith('history-') && name.endsWith('.json'));
+                .filter((name) => name.endsWith('.json'));
             let deletedCount = 0;
             for (const filename of historyFiles) {
                 const historyPath = join(sessionsDir, filename);
@@ -945,17 +984,17 @@ export class WebSocketImproviseHandler {
         };
     }
     searchSessions(workingDir, query, limit = 20, offset = 0) {
-        const sessionsDir = join(workingDir, '.mstro', 'improvise');
+        const sessionsDir = join(workingDir, '.mstro', 'history');
         if (!existsSync(sessionsDir)) {
             return { sessions: [], total: 0, hasMore: false };
         }
         const lowerQuery = query.toLowerCase();
         try {
             const historyFiles = readdirSync(sessionsDir)
-                .filter((name) => name.startsWith('history-') && name.endsWith('.json'))
+                .filter((name) => name.endsWith('.json'))
                 .sort((a, b) => {
-                const timestampA = parseInt(a.replace('history-', '').replace('.json', ''), 10);
-                const timestampB = parseInt(b.replace('history-', '').replace('.json', ''), 10);
+                const timestampA = parseInt(a.replace('.json', ''), 10);
+                const timestampB = parseInt(b.replace('.json', ''), 10);
                 return timestampB - timestampA;
             });
             const allMatches = [];
@@ -1017,6 +1056,7 @@ export class WebSocketImproviseHandler {
                     isExecuting: session.isExecuting,
                     outputHistory: this.buildOutputHistory(session),
                     executionEvents: session.isExecuting ? session.getExecutionEventLog() : undefined,
+                    ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
                 };
             }
             else {
@@ -1312,6 +1352,9 @@ Respond with ONLY the summary text, nothing else.`;
             gitLog: () => this.handleGitLog(ws, msg, tabId, gitDir),
             gitDiscoverRepos: () => this.handleGitDiscoverRepos(ws, tabId, workingDir),
             gitSetDirectory: () => this.handleGitSetDirectory(ws, msg, tabId, workingDir),
+            gitGetRemoteInfo: () => this.handleGitGetRemoteInfo(ws, tabId, gitDir),
+            gitCreatePR: () => this.handleGitCreatePR(ws, msg, tabId, gitDir),
+            gitGeneratePRDescription: () => this.handleGitGeneratePRDescription(ws, msg, tabId, gitDir),
         };
         handlers[msg.type]?.();
     }
@@ -1457,15 +1500,24 @@ Respond with ONLY the summary text, nothing else.`;
             // Get current branch
             const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
             const branch = branchResult.stdout.trim() || 'HEAD';
-            // Get ahead/behind counts
+            // Get ahead/behind counts and upstream tracking info
             let ahead = 0;
             let behind = 0;
+            let hasUpstream = false;
             const trackingResult = await this.executeGitCommand(['rev-list', '--left-right', '--count', `${branch}...@{u}`], workingDir);
             if (trackingResult.exitCode === 0) {
+                hasUpstream = true;
                 const parts = trackingResult.stdout.trim().split(/\s+/);
                 ahead = parseInt(parts[0], 10) || 0;
                 behind = parseInt(parts[1], 10) || 0;
             }
+            else {
+                // No upstream - count local commits as ahead
+                const localResult = await this.executeGitCommand(['rev-list', '--count', 'HEAD'], workingDir);
+                if (localResult.exitCode === 0) {
+                    ahead = parseInt(localResult.stdout.trim(), 10) || 0;
+                }
+            }
             const { staged, unstaged, untracked } = this.parseGitStatus(statusResult.stdout);
             const response = {
                 branch,
@@ -1475,6 +1527,7 @@ Respond with ONLY the summary text, nothing else.`;
                 untracked,
                 ahead,
                 behind,
+                hasUpstream,
             };
             this.send(ws, { type: 'gitStatus', tabId, data: response });
         }
@@ -1554,6 +1607,8 @@ Respond with ONLY the summary text, nothing else.`;
             const hashResult = await this.executeGitCommand(['rev-parse', '--short', 'HEAD'], workingDir);
             const hash = hashResult.stdout.trim();
             this.send(ws, { type: 'gitCommitted', tabId, data: { hash, message } });
+            // Proactively send updated status so the UI reflects new ahead/behind counts
+            this.handleGitStatus(ws, tabId, workingDir);
         }
         catch (error) {
             this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
@@ -1660,6 +1715,8 @@ Respond with ONLY the commit message, nothing else.`;
                     const hashResult = await this.executeGitCommand(['rev-parse', '--short', 'HEAD'], workingDir);
                     const hash = hashResult.stdout.trim();
                     this.send(ws, { type: 'gitCommitted', tabId, data: { hash, message: commitMessage } });
+                    // Proactively send updated status so the UI reflects new ahead/behind counts
+                    this.handleGitStatus(ws, tabId, workingDir);
                 }
             });
             claude.on('error', (err) => {
@@ -1689,14 +1746,14 @@ Respond with ONLY the commit message, nothing else.`;
         for (const pattern of patterns) {
             const match = output.match(pattern);
             if (match?.[1]) {
-                return match[1].trim();
+                return this.stripCoauthorLines(match[1].trim());
             }
         }
         // Split into paragraphs for analysis
         const paragraphs = output.split(/\n\n+/).filter(p => p.trim());
         // If only one paragraph, return it as-is
         if (paragraphs.length <= 1) {
-            return output.trim();
+            return this.stripCoauthorLines(output.trim());
         }
         const firstParagraph = paragraphs[0].trim();
         const firstLine = firstParagraph.split('\n')[0].trim();
@@ -1717,7 +1774,7 @@ Respond with ONLY the commit message, nothing else.`;
             // Validate the extracted message has a reasonable first line
             const extractedFirstLine = commitMessage.split('\n')[0].trim();
             if (extractedFirstLine.length > 0 && extractedFirstLine.length <= 100) {
-                return commitMessage;
+                return this.stripCoauthorLines(commitMessage);
             }
         }
         // Check if the second paragraph looks like a proper commit title
@@ -1730,18 +1787,49 @@ Respond with ONLY the commit message, nothing else.`;
                 /^[A-Z][a-z]/.test(secondFirstLine) &&
                 !secondFirstLine.endsWith('.')) {
                 // Return from second paragraph onwards
-                return paragraphs.slice(1).join('\n\n').trim();
+                return this.stripCoauthorLines(paragraphs.slice(1).join('\n\n').trim());
             }
         }
         // Fall back to original output if we can't identify a better message
-        return output.trim();
+        return this.stripCoauthorLines(output.trim());
+    }
+    /**
+     * Strip injected coauthor/attribution lines from a commit message.
+     * The Claude Code CLI appends "Co-Authored-By" lines to LLM output.
+     * We detect and remove them by matching known marker strings.
+     */
+    stripCoauthorLines(message) {
+        const lines = message.split('\n');
+        const markers = ['co-authored', 'authored-by', 'haiku', 'noreply@anthropic.com'];
+        const result = [];
+        for (let i = 0; i < lines.length; i++) {
+            const lower = lines[i].toLowerCase();
+            if (markers.some(m => lower.includes(m))) {
+                // Also remove a blank line immediately before this one
+                if (result.length > 0 && result[result.length - 1].trim() === '') {
+                    result.pop();
+                }
+                continue;
+            }
+            result.push(lines[i]);
+        }
+        // Don't return empty - keep at least the first line of the original
+        if (result.length === 0)
+            return lines[0]?.trim() || message;
+        return result.join('\n').trimEnd();
     }
     /**
      * Handle git push request
      */
     async handleGitPush(ws, tabId, workingDir) {
         try {
-            const result = await this.executeGitCommand(['push'], workingDir);
+            // Check if branch has an upstream, if not use --set-upstream
+            const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+            const branch = branchResult.stdout.trim();
+            const upstreamCheck = await this.executeGitCommand(['rev-parse', '--abbrev-ref', `${branch}@{u}`], workingDir);
+            const hasUpstream = upstreamCheck.exitCode === 0;
+            const pushArgs = hasUpstream ? ['push'] : ['push', '-u', 'origin', branch];
+            const result = await this.executeGitCommand(pushArgs, workingDir);
             if (result.exitCode !== 0) {
                 this.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || result.stdout || 'Failed to push' } });
                 return;
@@ -1874,13 +1962,305 @@ Respond with ONLY the commit message, nothing else.`;
             this.handleGitLog(ws, { type: 'gitLog', data: { limit: 5 } }, tabId, directory);
         }
     }
+    /**
+     * Get remote info for PR creation (remote URL, provider, default branch)
+     */
+    async handleGitGetRemoteInfo(ws, tabId, workingDir) {
+        try {
+            const remoteResult = await this.executeGitCommand(['remote', 'get-url', 'origin'], workingDir);
+            if (remoteResult.exitCode !== 0) {
+                this.send(ws, { type: 'gitRemoteInfo', tabId, data: { hasRemote: false } });
+                return;
+            }
+            const remoteUrl = remoteResult.stdout.trim();
+            const provider = detectGitProvider(remoteUrl);
+            const defaultBranch = await this.getDefaultBranch(workingDir);
+            const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+            const currentBranch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : '';
+            const cliStatus = await this.checkGitCliStatus(provider);
+            const remoteBranches = await this.listRemoteBranches(workingDir);
+            const preferredBaseBranch = getPrBaseBranch(remoteUrl) ?? undefined;
+            this.send(ws, {
+                type: 'gitRemoteInfo',
+                tabId,
+                data: {
+                    hasRemote: true,
+                    remoteUrl,
+                    provider,
+                    defaultBranch,
+                    currentBranch,
+                    ...cliStatus,
+                    remoteBranches,
+                    preferredBaseBranch,
+                },
+            });
+        }
+        catch (error) {
+            this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
+        }
+    }
+    async getDefaultBranch(workingDir) {
+        const result = await this.executeGitCommand(['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'], workingDir);
+        return result.exitCode === 0 ? result.stdout.trim().replace('origin/', '') : 'main';
+    }
+    async checkGitCliStatus(provider) {
+        const cliBin = provider === 'github' ? 'gh' : provider === 'gitlab' ? 'glab' : null;
+        if (!cliBin)
+            return { hasGhCli: false, ghCliAuthenticated: false };
+        const installed = await this.spawnCheck(cliBin, ['--version']);
+        if (!installed)
+            return { hasGhCli: false, ghCliAuthenticated: false };
+        const authenticated = await this.spawnCheck(cliBin, ['auth', 'status']);
+        return { hasGhCli: true, ghCliAuthenticated: authenticated, ghCliBinary: cliBin };
+    }
+    async listRemoteBranches(workingDir) {
+        const result = await this.executeGitCommand(['branch', '-r', '--list', 'origin/*'], workingDir);
+        if (result.exitCode !== 0)
+            return [];
+        return result.stdout.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.includes('->'))
+            .map(line => line.replace('origin/', ''))
+            .filter(Boolean)
+            .sort();
+    }
+    /** Check if a binary runs successfully (exit code 0) */
+    spawnCheck(bin, args) {
+        return new Promise((resolve) => {
+            const proc = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    }
+    /** Detect which CLI binary to use for PR creation based on remote URL */
+    detectPRCliBin(remoteUrl) {
+        const isGitHub = remoteUrl.includes('github.com');
+        const isGitLab = remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab');
+        const cliBin = isGitHub ? 'gh' : isGitLab ? 'glab' : null;
+        return { cliBin, isGitHub, isGitLab };
+    }
+    /** Send PR success and optionally persist base branch */
+    sendPRCreated(ws, tabId, url, method, remoteUrl, baseBranch) {
+        if (baseBranch)
+            setPrBaseBranch(remoteUrl, baseBranch);
+        this.send(ws, { type: 'gitPRCreated', tabId, data: { url, method } });
+    }
+    /**
+     * Create a pull/merge request using gh CLI (GitHub) or open browser URL (fallback)
+     */
+    async handleGitCreatePR(ws, msg, tabId, workingDir) {
+        const { title, body, baseBranch, draft } = msg.data ?? {};
+        if (!title) {
+            this.send(ws, { type: 'gitError', tabId, data: { error: 'PR title is required' } });
+            return;
+        }
+        try {
+            const branchResult = await this.executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+            if (branchResult.exitCode !== 0) {
+                this.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to detect current branch' } });
+                return;
+            }
+            const remoteResult = await this.executeGitCommand(['remote', 'get-url', 'origin'], workingDir);
+            if (remoteResult.exitCode !== 0) {
+                this.send(ws, { type: 'gitError', tabId, data: { error: 'No remote origin configured' } });
+                return;
+            }
+            const headBranch = branchResult.stdout.trim();
+            const remoteUrl = remoteResult.stdout.trim();
+            const { cliBin, isGitHub, isGitLab } = this.detectPRCliBin(remoteUrl);
+            const cliResult = await this.tryCliPRCreate(cliBin, { title, body, baseBranch, draft, headBranch }, workingDir);
+            if (cliResult.created) {
+                this.sendPRCreated(ws, tabId, cliResult.url, isGitHub ? 'gh' : 'glab', remoteUrl, baseBranch);
+                return;
+            }
+            if (cliResult.error) {
+                this.send(ws, { type: 'gitError', tabId, data: { error: cliResult.error } });
+                return;
+            }
+            const prUrl = this.buildBrowserPRUrl(remoteUrl, headBranch, baseBranch, title, body, isGitHub, isGitLab);
+            if (prUrl) {
+                this.sendPRCreated(ws, tabId, prUrl, 'browser', remoteUrl, baseBranch);
+            }
+            else {
+                this.send(ws, { type: 'gitError', tabId, data: { error: 'Could not determine remote URL format for PR creation' } });
+            }
+        }
+        catch (error) {
+            this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
+        }
+    }
+    /** Attempt to create a PR/MR via CLI. Returns { created, url, error } */
+    async tryCliPRCreate(cliBin, opts, workingDir) {
+        if (!cliBin)
+            return { created: false }; // No CLI for this provider
+        // Check if CLI is installed
+        const installed = await this.spawnCheck(cliBin, ['--version']);
+        if (!installed)
+            return { created: false }; // Not installed, fall through to browser
+        // Build CLI args
+        const args = cliBin === 'gh'
+            ? ['pr', 'create', '--title', opts.title]
+            : ['mr', 'create', '--title', opts.title, '--yes']; // glab mr create
+        if (opts.body)
+            args.push('--body', opts.body);
+        if (opts.baseBranch) {
+            args.push(cliBin === 'gh' ? '--base' : '--target-branch', opts.baseBranch);
+        }
+        if (opts.draft)
+            args.push('--draft');
+        const result = await this.spawnWithOutput(cliBin, args, workingDir);
+        if (result.exitCode === 0) {
+            const urlMatch = result.stdout.match(/https?:\/\/\S+/);
+            return { created: true, url: urlMatch ? urlMatch[0] : result.stdout.trim() };
+        }
+        return { created: false, error: this.classifyCliPRError(cliBin, result, opts.headBranch) };
+    }
+    /** Classify a CLI PR creation error into a user-facing message */
+    classifyCliPRError(cliBin, result, headBranch) {
+        const combined = result.stderr + result.stdout;
+        const lower = combined.toLowerCase();
+        if (lower.includes('already exists')) {
+            const existingUrl = combined.match(/https?:\/\/\S+/);
+            return existingUrl
+                ? `A pull request already exists for ${headBranch}: ${existingUrl[0]}`
+                : `A pull request already exists for ${headBranch}`;
+        }
+        if (lower.includes('auth') || lower.includes('401') || lower.includes('token') || lower.includes('log in')) {
+            return `${cliBin} is not authenticated. Run: ${cliBin} auth login`;
+        }
+        if (lower.includes('must first push') || lower.includes('failed to push') || lower.includes('no upstream')) {
+            return `Branch "${headBranch}" has not been pushed to remote. Push first, then create the PR.`;
+        }
+        return `${cliBin} failed: ${(result.stderr || result.stdout).trim()}`;
+    }
+    /** Spawn a process and capture stdout/stderr */
+    spawnWithOutput(bin, args, cwd) {
+        return new Promise((resolve) => {
+            const proc = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (d) => { stdout += d.toString(); });
+            proc.stderr?.on('data', (d) => { stderr += d.toString(); });
+            proc.on('close', (code) => resolve({ stdout, stderr, exitCode: code ?? 1 }));
+            proc.on('error', (err) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
+        });
+    }
+    /** Build a browser URL for PR creation (fallback when no CLI) */
+    buildBrowserPRUrl(remoteUrl, headBranch, baseBranch, title, body, isGitHub, isGitLab) {
+        const sshMatch = remoteUrl.match(/[:/]([^/]+)\/([^/.]+)(?:\.git)?$/);
+        if (!sshMatch)
+            return '';
+        const [, owner, repo] = sshMatch;
+        const base = baseBranch || 'main';
+        if (isGitHub) {
+            return `https://github.com/${owner}/${repo}/compare/${base}...${headBranch}?expand=1&title=${encodeURIComponent(title)}${body ? `&body=${encodeURIComponent(body)}` : ''}`;
+        }
+        if (isGitLab) {
+            return `https://gitlab.com/${owner}/${repo}/-/merge_requests/new?merge_request[source_branch]=${headBranch}&merge_request[target_branch]=${base}&merge_request[title]=${encodeURIComponent(title)}`;
+        }
+        return '';
+    }
+    /**
+     * Generate a PR title and description using Haiku, based on the diff against the base branch.
+     */
+    async handleGitGeneratePRDescription(ws, msg, tabId, workingDir) {
+        const baseBranch = msg.data?.baseBranch || 'main';
+        try {
+            // Get commit list for context
+            const logResult = await this.executeGitCommand(['log', `${baseBranch}..HEAD`, '--oneline'], workingDir);
+            const commits = logResult.exitCode === 0 ? logResult.stdout.trim() : '';
+            if (!commits) {
+                this.send(ws, { type: 'gitError', tabId, data: { error: `No commits found between ${baseBranch} and HEAD` } });
+                return;
+            }
+            // Get diff against base
+            const diffResult = await this.executeGitCommand(['diff', `${baseBranch}...HEAD`], workingDir);
+            const diff = diffResult.exitCode === 0 ? diffResult.stdout : '';
+            // Get changed files summary
+            const statResult = await this.executeGitCommand(['diff', `${baseBranch}...HEAD`, '--stat'], workingDir);
+            const stat = statResult.exitCode === 0 ? statResult.stdout.trim() : '';
+            // Truncate diff if too long (same pattern as commit message generation)
+            let truncatedDiff = diff;
+            if (diff.length > 8000) {
+                truncatedDiff = `${diff.slice(0, 4000)}\n\n... [diff truncated] ...\n\n${diff.slice(-3500)}`;
+            }
+            // Build prompt
+            const tempDir = join(workingDir, '.mstro', 'tmp');
+            if (!existsSync(tempDir)) {
+                mkdirSync(tempDir, { recursive: true });
+            }
+            const prompt = `You are generating a pull request title and description for the following changes.
+
+COMMITS (${baseBranch}..HEAD):
+${commits}
+
+FILES CHANGED:
+${stat}
+
+DIFF:
+${truncatedDiff}
+
+Generate a pull request title and description following these rules:
+1. TITLE: First line must be the PR title — imperative mood, under 70 characters
+2. Leave a blank line after the title
+3. BODY: Write a concise description in markdown with:
+   - A "## Summary" section with 1-3 bullet points explaining what changed and why
+   - Optionally a "## Details" section if the changes are complex
+4. Focus on the "why" not just the "what"
+5. No emojis
+
+Respond with ONLY the title and description, nothing else.`;
+            const promptFile = join(tempDir, `pr-desc-${Date.now()}.txt`);
+            writeFileSync(promptFile, prompt);
+            const systemPrompt = 'You are a pull request description assistant. Respond with only the PR title and description, no preamble or explanation.';
+            const args = [
+                '--print',
+                '--model', 'haiku',
+                '--system-prompt', systemPrompt,
+                promptFile
+            ];
+            const claude = spawn('claude', args, {
+                cwd: workingDir,
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            claude.stdout?.on('data', (data) => { stdout += data.toString(); });
+            claude.stderr?.on('data', (data) => { stderr += data.toString(); });
+            claude.on('close', (code) => {
+                try {
+                    unlinkSync(promptFile);
+                }
+                catch { /* ignore */ }
+                if (code !== 0 || !stdout.trim()) {
+                    console.error('[WebSocketImproviseHandler] Claude PR description error:', stderr || 'No output');
+                    this.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to generate PR description' } });
+                    return;
+                }
+                // Parse: first line = title, rest = body
+                const output = this.stripCoauthorLines(stdout.trim());
+                const lines = output.split('\n');
+                const title = lines[0].trim();
+                const body = lines.slice(1).join('\n').trim();
+                this.send(ws, { type: 'gitPRDescription', tabId, data: { title, body } });
+            });
+            claude.on('error', (err) => {
+                console.error('[WebSocketImproviseHandler] Failed to spawn Claude for PR description:', err);
+                this.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to generate PR description' } });
+            });
+            setTimeout(() => { claude.kill(); }, 30000);
+        }
+        catch (error) {
+            this.send(ws, { type: 'gitError', tabId, data: { error: error.message } });
+        }
+    }
     // ============================================
     // Terminal handling methods
     // ============================================
     /**
      * Initialize a new terminal session or reconnect to existing one
      */
-    handleTerminalInit(ws, terminalId, workingDir, requestedShell, cols, rows) {
+    handleTerminalInit(ws, terminalId, workingDir, requestedShell, cols, rows, permission) {
         const ptyManager = getPTYManager();
         // Check if PTY is available (node-pty requires native compilation)
         if (!ptyManager.isPtyAvailable()) {
@@ -1900,23 +2280,13 @@ Respond with ONLY the commit message, nothing else.`;
         this.setupTerminalBroadcastListeners(terminalId);
         try {
             // Create or reconnect to the PTY process
-            const { shell, cwd, isReconnect } = ptyManager.create(terminalId, workingDir, cols || 80, rows || 24, requestedShell);
-            // If reconnecting, send scrollback buffer to THIS client only
-            if (isReconnect) {
-                const scrollback = ptyManager.getScrollback(terminalId);
-                if (scrollback.length > 0) {
-                    this.send(ws, {
-                        type: 'terminalScrollback',
-                        terminalId,
-                        data: { lines: scrollback }
-                    });
-                }
-            }
-            else {
+            // Both 'control' and 'view' users get sandboxed terminals
+            const { shell, cwd, isReconnect } = ptyManager.create(terminalId, workingDir, cols || 80, rows || 24, requestedShell, { sandboxed: permission === 'control' || permission === 'view' });
+            if (!isReconnect) {
                 // New terminal — broadcast to other clients so they can create matching tabs
                 this.broadcastToOthers(ws, {
                     type: 'terminalCreated',
-                    data: { terminalId, shell, cwd, persistent: false }
+                    data: { terminalId, shell, cwd }
                 });
             }
             // Send ready message to THIS client
@@ -1959,15 +2329,6 @@ Respond with ONLY the commit message, nothing else.`;
         this.addTerminalSubscriber(terminalId, ws);
         // Set up broadcast listeners (idempotent — only creates once per terminal)
         this.setupTerminalBroadcastListeners(terminalId);
-        // Send scrollback buffer to THIS client only
-        const scrollback = ptyManager.getScrollback(terminalId);
-        if (scrollback.length > 0) {
-            this.send(ws, {
-                type: 'terminalScrollback',
-                terminalId,
-                data: { lines: scrollback }
-            });
-        }
         // Send ready message indicating reconnection
         this.send(ws, {
             type: 'terminalReady',
@@ -2003,13 +2364,6 @@ Respond with ONLY the commit message, nothing else.`;
         if (!input) {
             return;
         }
-        // Check if this is a persistent terminal first
-        const persistentHandler = this.persistentHandlers.get(terminalId);
-        if (persistentHandler) {
-            persistentHandler.write(input);
-            return;
-        }
-        // Otherwise use regular PTY
         const ptyManager = getPTYManager();
         const success = ptyManager.write(terminalId, input);
         if (!success) {
@@ -2027,13 +2381,6 @@ Respond with ONLY the commit message, nothing else.`;
         if (!cols || !rows) {
             return;
         }
-        // Check if this is a persistent terminal first
-        const persistentHandler = this.persistentHandlers.get(terminalId);
-        if (persistentHandler) {
-            persistentHandler.resize(cols, rows);
-            return;
-        }
-        // Otherwise use regular PTY
         const ptyManager = getPTYManager();
         ptyManager.resize(terminalId, cols, rows);
     }
@@ -2042,26 +2389,15 @@ Respond with ONLY the commit message, nothing else.`;
      */
     handleTerminalClose(ws, terminalId) {
         trackEvent(AnalyticsEvents.TERMINAL_SESSION_CLOSED);
-        // Check if this is a persistent terminal first
-        const persistentHandler = this.persistentHandlers.get(terminalId);
-        if (persistentHandler) {
-            persistentHandler.detach();
-            this.persistentHandlers.delete(terminalId);
-            // For persistent terminals, close actually kills the tmux session
-            const ptyManager = getPTYManager();
-            ptyManager.closePersistent(terminalId);
-        }
-        else {
-            // Clean up event listeners
-            const listenerCleanup = this.terminalListenerCleanups.get(terminalId);
-            if (listenerCleanup) {
-                listenerCleanup();
-                this.terminalListenerCleanups.delete(terminalId);
-            }
-            // Close regular PTY
-            const ptyManager = getPTYManager();
-            ptyManager.close(terminalId);
+        // Clean up event listeners
+        const listenerCleanup = this.terminalListenerCleanups.get(terminalId);
+        if (listenerCleanup) {
+            listenerCleanup();
+            this.terminalListenerCleanups.delete(terminalId);
         }
+        // Close PTY
+        const ptyManager = getPTYManager();
+        ptyManager.close(terminalId);
         // Clean up subscribers
         this.terminalSubscribers.delete(terminalId);
         // Broadcast to other clients
@@ -2070,8 +2406,6 @@ Respond with ONLY the commit message, nothing else.`;
             data: { terminalId }
         });
     }
-    // Persistent terminal handlers for tmux-backed sessions
-    persistentHandlers = new Map();
     // Track PTY event listener cleanup functions per terminal to prevent duplicate listeners
     terminalListenerCleanups = new Map();
     // Track which WS connections are subscribed to each terminal's output
@@ -2104,31 +2438,6 @@ Respond with ONLY the commit message, nothing else.`;
             this.terminalListenerCleanups.delete(terminalId);
         }
     }
-    /**
-     * Attach persistent (tmux) terminal handlers for output/exit broadcasting.
-     */
-    attachPersistentHandlers(terminalId, ptyManager) {
-        const handlers = ptyManager.attachPersistent(terminalId, (output) => {
-            const subs = this.terminalSubscribers.get(terminalId);
-            if (subs) {
-                for (const sub of subs) {
-                    this.send(sub, { type: 'terminalOutput', terminalId, data: { output } });
-                }
-            }
-        }, (exitCode) => {
-            const subs = this.terminalSubscribers.get(terminalId);
-            if (subs) {
-                for (const sub of subs) {
-                    this.send(sub, { type: 'terminalExit', terminalId, data: { exitCode } });
-                }
-            }
-            this.persistentHandlers.delete(terminalId);
-            this.terminalSubscribers.delete(terminalId);
-        });
-        if (handlers) {
-            this.persistentHandlers.set(terminalId, handlers);
-        }
-    }
     /**
      * Set up PTY event listeners that broadcast to all subscribers.
      * Only creates listeners once per terminal (idempotent).
@@ -2183,85 +2492,5 @@ Respond with ONLY the commit message, nothing else.`;
             ptyManager.off('error', onError);
         });
     }
-    /**
-     * Initialize a persistent (tmux-backed) terminal session
-     * These sessions survive server restarts.
-     * Uses subscriber pattern for multi-client output broadcasting.
-     */
-    handleTerminalInitPersistent(ws, terminalId, workingDir, requestedShell, cols, rows) {
-        const ptyManager = getPTYManager();
-        // Check if tmux is available
-        if (!ptyManager.isTmuxAvailable()) {
-            this.send(ws, {
-                type: 'terminalError',
-                terminalId,
-                data: { error: 'Persistent terminals require tmux, which is not installed' }
-            });
-            return;
-        }
-        // Add this WS as a subscriber for this terminal's output
-        this.addTerminalSubscriber(terminalId, ws);
-        try {
-            // Create or reconnect to the persistent session
-            const { shell, cwd, isReconnect } = ptyManager.createPersistent(terminalId, workingDir, cols || 80, rows || 24, requestedShell);
-            // Only attach if we don't already have handlers (first subscriber)
-            if (!this.persistentHandlers.has(terminalId)) {
-                this.attachPersistentHandlers(terminalId, ptyManager);
-            }
-            // If reconnecting, send scrollback buffer to THIS client only
-            if (isReconnect) {
-                const scrollback = ptyManager.getPersistentScrollback(terminalId);
-                if (scrollback.length > 0) {
-                    this.send(ws, {
-                        type: 'terminalScrollback',
-                        terminalId,
-                        data: { lines: scrollback }
-                    });
-                }
-            }
-            else {
-                // New terminal — broadcast to other clients so they can create matching tabs
-                this.broadcastToOthers(ws, {
-                    type: 'terminalCreated',
-                    data: { terminalId, shell, cwd, persistent: true }
-                });
-            }
-            // Send ready message to THIS client
-            this.send(ws, {
-                type: 'terminalReady',
-                terminalId,
-                data: { shell, cwd, isReconnect, persistent: true }
-            });
-        }
-        catch (error) {
-            console.error(`[WebSocketImproviseHandler] Failed to create persistent terminal:`, error);
-            this.send(ws, {
-                type: 'terminalError',
-                terminalId,
-                data: { error: error.message || 'Failed to create persistent terminal' }
-            });
-            this.removeTerminalSubscriber(terminalId, ws);
-        }
-    }
-    /**
-     * List all persistent terminal sessions (including those from previous server runs)
-     */
-    handleTerminalListPersistent(ws) {
-        const ptyManager = getPTYManager();
-        const sessions = ptyManager.getPersistentSessions();
-        this.send(ws, {
-            type: 'terminalListPersistent',
-            data: {
-                available: ptyManager.isTmuxAvailable(),
-                terminals: sessions.map(s => ({
-                    id: s.terminalId,
-                    shell: s.shell,
-                    cwd: s.cwd,
-                    createdAt: s.createdAt,
-                    lastAttachedAt: s.lastAttachedAt,
-                }))
-            }
-        });
-    }
 }
 //# sourceMappingURL=handler.js.map