dmux 1.3.0 → 1.3.2

package/dist/DmuxApp.js

@@ -1,7 +1,6 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput, useApp } from 'ink';
 import TextInput from 'ink-text-input';
-import SimpleEnhancedInput from './SimpleEnhancedInput.js';
 import { execSync } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
@@ -23,9 +22,8 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
     const [projectSettings, setProjectSettings] = useState({});
     const [showCommandPrompt, setShowCommandPrompt] = useState(null);
     const [commandInput, setCommandInput] = useState('');
-    const [showAIPrompt, setShowAIPrompt] = useState(false);
-    const [aiChangeRequest, setAIChangeRequest] = useState('');
-    const [generatingCommand, setGeneratingCommand] = useState(false);
+    const [showFileCopyPrompt, setShowFileCopyPrompt] = useState(false);
+    const [currentCommandType, setCurrentCommandType] = useState(null);
     const [runningCommand, setRunningCommand] = useState(false);
     const { exit } = useApp();
     // Track terminal dimensions for responsive layout
@@ -41,10 +39,6 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         };
         // Add resize listener
         process.stdout.on('resize', handleResize);
-        // Add Claude status monitoring
-        const claudeInterval = setInterval(() => {
-            monitorClaudeStatus();
-        }, 200);
         // Add cleanup handlers for process termination
         const handleTermination = () => {
             // Clear screen before exit
@@ -61,88 +55,140 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         return () => {
             clearInterval(interval);
             process.stdout.removeListener('resize', handleResize);
-            clearInterval(claudeInterval);
             process.removeListener('SIGINT', handleTermination);
             process.removeListener('SIGTERM', handleTermination);
         };
     }, []);
-    const monitorClaudeStatus = async () => {
-        // Monitor Claude Code status for all panes
-        const updatedPanes = await Promise.all(panes.map(async (pane) => {
-            try {
-                // Skip if recently checked (within 150ms to avoid overlapping checks)
-                if (pane.lastClaudeCheck && Date.now() - pane.lastClaudeCheck < 150) {
-                    return pane;
-                }
-                // Capture the last 20 lines of the pane
-                const captureOutput = execSync(`tmux capture-pane -t '${pane.paneId}' -p -S -20`, { encoding: 'utf-8', stdio: 'pipe' });
-                // Pattern detection for Claude Code states
-                // Working patterns - Claude is processing
-                // Look for the loading symbols and "(esc to interrupt)"
-                const workingPatterns = [
-                    /\(esc to interrupt\)/i, // Most reliable indicator
-                    /✻|✢|✽|·|✳/, // Loading symbols you identified
-                    /⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/, // Braille spinner characters (might also be used)
-                ];
-                // Permission/attention patterns - needs user input
-                const attentionPatterns = [
-                    /Do you want to (allow|approve|grant|trust)/i,
-                    /Permission required/i,
-                    /\[y\/n\]/i,
-                    /\(y\/n\)/i,
-                    /Would you like to/i,
-                    /Continue\?/i,
-                    /Proceed\?/i,
-                    /Accept.*\?/i,
-                    /Allow.*\?/i,
-                    /Approve.*\?/i,
-                    /Grant.*\?/i,
-                    /Trust.*\?/i,
-                    /press.*enter.*continue/i,
-                    /press.*enter.*accept/i,
-                    /waiting for.*input/i,
-                    /requires.*permission/i,
-                    /needs.*approval/i
-                ];
-                // Check if Claude is working
-                const isWorking = workingPatterns.some(pattern => pattern.test(captureOutput));
-                // Check if Claude needs attention
-                const needsAttention = attentionPatterns.some(pattern => pattern.test(captureOutput));
-                // Determine status
-                let newStatus = 'idle';
-                if (isWorking) {
-                    newStatus = 'working';
-                }
-                else if (needsAttention) {
-                    newStatus = 'waiting';
-                }
-                // Return updated pane if status changed
-                if (pane.claudeStatus !== newStatus) {
+    // Monitor Claude status in all panes with proper dependency tracking
+    useEffect(() => {
+        if (panes.length === 0)
+            return;
+        const monitorClaudeStatus = async () => {
+            // Monitor Claude Code status for all panes
+            const updatedPanesWithNulls = await Promise.all(panes.map(async (pane) => {
+                try {
+                    // Skip if recently checked (within 500ms to avoid overlapping checks)
+                    if (pane.lastClaudeCheck && Date.now() - pane.lastClaudeCheck < 500) {
+                        return pane;
+                    }
+                    // First check if pane exists before trying to capture
+                    const paneIds = execSync(`tmux list-panes -F '#{pane_id}'`, {
+                        encoding: 'utf-8',
+                        stdio: 'pipe'
+                    }).trim().split('\n');
+                    if (!paneIds.includes(pane.paneId)) {
+                        // Pane doesn't exist anymore, return unchanged
+                        return pane;
+                    }
+                    // Capture the last 30 lines of the pane for better detection
+                    const captureOutput = execSync(`tmux capture-pane -t '${pane.paneId}' -p -S -30`, { encoding: 'utf-8', stdio: 'pipe' });
+                    // Pattern detection for Claude Code states
+                    // Working patterns - Claude is processing
+                    // The ONLY reliable indicator is "(esc to interrupt)"
+                    const workingPatterns = [
+                        /esc to interrupt/i, // The ONLY reliable indicator that Claude is actively working
+                    ];
+                    // Extract last few lines to check for patterns
+                    const lines = captureOutput.split('\n');
+                    const lastLines = lines.slice(-10).join('\n');
+                    // Check if Claude's input box is present (waiting for input)
+                    const hasInputBox = /╭─+╮/.test(lastLines) && /╰─+╯/.test(lastLines) && /│\s+>\s+.*│/.test(lastLines);
+                    // Permission/attention patterns - needs user input (very forgiving)
+                    const attentionPatterns = [
+                        /\?\s*$/m, // Any line ending with a question mark
+                        /y\/n/i, // Any y/n prompt
+                        /yes.*no/i, // Yes or no prompts
+                        /\ballow\b.*\?/i,
+                        /\bapprove\b.*\?/i,
+                        /\bgrant\b.*\?/i,
+                        /\btrust\b.*\?/i,
+                        /\baccept\b.*\?/i,
+                        /\bcontinue\b.*\?/i,
+                        /\bproceed\b.*\?/i,
+                        /permission/i,
+                        /confirmation/i,
+                        /press.*enter/i,
+                        /waiting for/i,
+                        /are you sure/i,
+                        /would you like/i,
+                        /do you want/i,
+                        /please confirm/i,
+                        /requires.*approval/i,
+                        /needs.*input/i,
+                        /⏵⏵\s*accept edits/i, // Claude's accept edits mode
+                        /shift\+tab to cycle/i, // Claude's interface hints
+                    ];
+                    // Check if Claude is working
+                    const isWorking = workingPatterns.some(pattern => pattern.test(captureOutput));
+                    // Check if Claude needs attention
+                    const needsAttention = attentionPatterns.some(pattern => pattern.test(captureOutput)) || hasInputBox;
+                    // Determine status - working takes precedence
+                    let newStatus = 'idle';
+                    if (isWorking) {
+                        newStatus = 'working';
+                    }
+                    else if (needsAttention && !isWorking) {
+                        // Only show as waiting if NOT working (working takes precedence)
+                        newStatus = 'waiting';
+                    }
+                    // Additional checks for specific Claude states
+                    // If we see "accept edits" without other working indicators, it's waiting
+                    if (/accept edits/i.test(captureOutput) && !/esc to interrupt/i.test(captureOutput)) {
+                        newStatus = 'waiting';
+                    }
+                    // If Claude's input box is visible and no working indicators, it's waiting for input
+                    if (hasInputBox && !isWorking) {
+                        newStatus = 'waiting';
+                    }
+                    // Check for specific Claude question patterns that might not end with ?
+                    const claudeQuestionPatterns = [
+                        /I (can|could|should|would|will|may|might)/i,
+                        /Let me know/i,
+                        /Please (tell|let|inform|advise)/i,
+                        /Would you prefer/i,
+                        /Should I (proceed|continue|go ahead)/i,
+                    ];
+                    if (claudeQuestionPatterns.some(pattern => pattern.test(lastLines)) && !isWorking) {
+                        newStatus = 'waiting';
+                    }
+                    // Return updated pane if status changed
+                    if (pane.claudeStatus !== newStatus) {
+                        return {
+                            ...pane,
+                            claudeStatus: newStatus,
+                            lastClaudeCheck: Date.now()
+                        };
+                    }
+                    // Just update timestamp
                     return {
                         ...pane,
-                        claudeStatus: newStatus,
                         lastClaudeCheck: Date.now()
                     };
                 }
-                // Just update timestamp
-                return {
-                    ...pane,
-                    lastClaudeCheck: Date.now()
-                };
-            }
-            catch (error) {
-                // If we can't capture the pane, it might be dead
-                return pane;
+                catch (error) {
+                    // If we can't capture the pane, it might be dead - mark it for removal
+                    return null; // Will be filtered out below
+                }
+            }));
+            // Filter out null values (dead panes) and keep only valid panes
+            const updatedPanes = updatedPanesWithNulls.filter((pane) => pane !== null);
+            // Check if we have changes (including pane removals)
+            const hasChanges = updatedPanes.length !== panes.length ||
+                updatedPanes.some((pane, index) => pane.claudeStatus !== panes[index]?.claudeStatus);
+            if (hasChanges) {
+                setPanes(updatedPanes);
+                // Save to file
+                await fs.writeFile(panesFile, JSON.stringify(updatedPanes, null, 2));
             }
-        }));
-        // Only update state if something changed
-        const hasChanges = updatedPanes.some((pane, index) => pane.claudeStatus !== panes[index]?.claudeStatus);
-        if (hasChanges) {
-            setPanes(updatedPanes);
-            // Save to file
-            await fs.writeFile(panesFile, JSON.stringify(updatedPanes, null, 2));
-        }
-    };
+        };
+        // Run monitoring immediately
+        monitorClaudeStatus();
+        // Set up interval for continuous monitoring
+        const claudeInterval = setInterval(monitorClaudeStatus, 1000); // Check every second
+        return () => {
+            clearInterval(claudeInterval);
+        };
+    }, [panes, panesFile]); // Re-run when panes change
     const loadSettings = async () => {
         try {
             const content = await fs.readFile(settingsFile, 'utf-8');
@@ -529,11 +575,49 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         // Final fallback
         return `dmux-${Date.now()}`;
     };
+    const openInEditor = async () => {
+        try {
+            const os = require('os');
+            const fs = require('fs');
+            const tmpFile = path.join(os.tmpdir(), `dmux-prompt-${Date.now()}.md`);
+            // Write current prompt to temp file
+            fs.writeFileSync(tmpFile, newPanePrompt || '# Enter your Claude prompt here\n\n');
+            // Get editor from environment or use default
+            const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+            // Clear screen and open editor
+            process.stdout.write('\x1b[2J\x1b[H');
+            // Use spawn to open editor in foreground
+            const { spawn } = require('child_process');
+            const editorProcess = spawn(editor, [tmpFile], {
+                stdio: 'inherit',
+                shell: true
+            });
+            editorProcess.on('close', (code) => {
+                // Read the file back
+                try {
+                    const content = fs.readFileSync(tmpFile, 'utf8')
+                        .replace(/^# Enter your Claude prompt here\s*\n*/m, '')
+                        .trim();
+                    setNewPanePrompt(content);
+                    // Clean up temp file
+                    fs.unlinkSync(tmpFile);
+                    // Clear screen and return to dmux
+                    process.stdout.write('\x1b[2J\x1b[H');
+                }
+                catch (error) {
+                    // If file read fails, just continue
+                }
+            });
+        }
+        catch (error) {
+            // If editor fails, just continue with inline input
+        }
+    };
     const createNewPane = async (prompt) => {
         setIsCreatingPane(true);
         setStatusMessage('Generating slug...');
         const slug = await generateSlug(prompt);
-        setStatusMessage('Creating new pane...');
+        setStatusMessage(`Creating worktree: ${slug}...`);
         // Get git root directory for consistent worktree placement
         let projectRoot;
         try {
@@ -592,17 +676,29 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         const newPaneCount = paneCount + 1;
         applySmartLayout(newPaneCount);
         // Create git worktree and cd into it
+        // This MUST happen before launching Claude to ensure we're in the right directory
         try {
-            // Send the git worktree command
-            execSync(`tmux send-keys -t '${paneInfo}' 'git worktree add "${worktreePath}" -b ${slug} && cd "${worktreePath}"' Enter`, { stdio: 'pipe' });
-            // Wait for worktree creation to complete
-            await new Promise(resolve => setTimeout(resolve, 1500));
+            // First, create the worktree and cd into it as a single command
+            // Use ; instead of && to ensure cd runs even if worktree already exists
+            const worktreeCmd = `git worktree add "${worktreePath}" -b ${slug} 2>/dev/null ; cd "${worktreePath}"`;
+            execSync(`tmux send-keys -t '${paneInfo}' '${worktreeCmd}' Enter`, { stdio: 'pipe' });
+            // Wait longer for worktree creation and cd to complete
+            // This is critical - if we don't wait long enough, Claude will start in the wrong directory
+            await new Promise(resolve => setTimeout(resolve, 2500));
+            // Verify we're in the worktree directory by sending pwd command  
+            execSync(`tmux send-keys -t '${paneInfo}' 'echo "Worktree created at:" && pwd' Enter`, { stdio: 'pipe' });
+            await new Promise(resolve => setTimeout(resolve, 500));
+            setStatusMessage('Worktree created, launching Claude...');
         }
         catch (error) {
-            // Log error but continue
-            setStatusMessage(`Warning: Could not create worktree: ${error}`);
-        }
-        // Prepare the Claude command
+            // Log error but continue - worktree creation is essential
+            setStatusMessage(`Warning: Worktree issue: ${error}`);
+            // Even if worktree creation failed, try to cd to the directory in case it exists
+            execSync(`tmux send-keys -t '${paneInfo}' 'cd "${worktreePath}" 2>/dev/null || (echo "ERROR: Failed to create/enter worktree ${slug}" && pwd)' Enter`, { stdio: 'pipe' });
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        // NOW prepare and send the Claude command
+        // Claude should always be launched AFTER we're in the worktree directory
         let claudeCmd;
         if (prompt && prompt.trim()) {
             const escapedPrompt = prompt
@@ -615,7 +711,7 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         else {
             claudeCmd = `claude --permission-mode=acceptEdits`;
         }
-        // Send command to new pane
+        // Send Claude command to new pane
         const escapedCmd = claudeCmd.replace(/'/g, "'\\''");
         execSync(`tmux send-keys -t '${paneInfo}' '${escapedCmd}'`, { stdio: 'pipe' });
         execSync(`tmux send-keys -t '${paneInfo}' Enter`, { stdio: 'pipe' });
@@ -1000,163 +1096,131 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         // Final fallback
         return 'chore: merge worktree changes';
     };
-    const generateCommand = async (type, changeRequest) => {
-        setGeneratingCommand(true);
-        setStatusMessage(`Generating ${type} command with AI...`);
+    const detectPackageManager = async () => {
         try {
-            // Find claude command
-            const claudeCmd = await findClaudeCommand();
-            if (!claudeCmd) {
-                throw new Error('Claude Code not found. Please ensure Claude Code is installed and accessible');
-            }
             // Get project root
             const projectRoot = execSync('git rev-parse --show-toplevel', {
                 encoding: 'utf-8',
                 stdio: 'pipe'
             }).trim();
-            // Pre-fetch directory listings
-            setStatusMessage('Analyzing project structure...');
-            // Get main directory listing
-            const mainFiles = execSync(`ls -la "${projectRoot}"`, {
-                encoding: 'utf-8',
-                stdio: 'pipe'
-            });
-            // Get worktree listing (simulate what it would look like)
-            // For now we'll use main, but in reality worktrees start with the same files
-            const worktreeFiles = mainFiles;
-            // Check for package.json to understand the project type
-            let packageJsonContent = '';
+            // Check if package.json exists
             try {
-                packageJsonContent = await fs.readFile(path.join(projectRoot, 'package.json'), 'utf-8');
-            }
-            catch { }
-            let requestedFile = '';
-            let maxAttempts = 2; // Allow one file request, then must generate command
-            for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                const isLastAttempt = attempt === maxAttempts - 1;
-                // Build the prompt
-                let prompt = `You are generating a ${type === 'test' ? 'test' : 'development server'} command for a git worktree.
-
-CRITICAL CONTEXT:
-- Main project directory: ${projectRoot}
-- Worktrees are siblings: ${path.dirname(projectRoot)}/{project-name}-{branch}
-- Command runs INSIDE the worktree (not main)
-- Files like .env, .wrangler, node_modules are NOT shared between worktrees
-
-Files in MAIN directory:
-${mainFiles}
-
-Files in WORKTREE (initially same as main):
-${worktreeFiles}
-
-${packageJsonContent ? `package.json contents:\n${packageJsonContent.substring(0, 3000)}\n` : ''}
-
-${requestedFile}
-
-${changeRequest ? `User's requested change: ${changeRequest}\n` : ''}
-
-Your task: Generate a command to ${type === 'test' ? 'run tests' : 'start a dev server'} in the worktree.
-
-Consider:
-1. Copy needed files from main (e.g., cp ../${path.basename(projectRoot)}/.env .)
-2. Install dependencies (npm/pnpm/yarn install)
-3. Build if needed
-4. Run the ${type} command
-
-${isLastAttempt ? 'YOU MUST PROVIDE THE FINAL COMMAND NOW. No more file requests allowed.' : 'You can request ONE file to read, then you must provide the command.'}
-
-Respond with ONLY a JSON object:
-
-${!isLastAttempt ? `To read ONE file (only one chance):
-{
-  "type": "cat",
-  "path": "path/to/file"
-}
-
-OR ` : ''}To provide the final command:
-{
-  "type": "command",
-  "command": "cp ../${path.basename(projectRoot)}/.env . && npm install && npm run ${type}",
-  "description": "Copy env, install deps, run ${type}"
-}`;
-                // Write prompt to a temporary file
-                const tmpFile = `/tmp/dmux-prompt-${Date.now()}.txt`;
-                await fs.writeFile(tmpFile, prompt);
-                // Use Claude to generate the response
-                const result = execSync(`${claudeCmd} -p "$(cat ${tmpFile})" --output-format json`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                    maxBuffer: 1024 * 1024 * 10
-                });
-                // Clean up temp file
-                try {
-                    await fs.unlink(tmpFile);
+                await fs.access(path.join(projectRoot, 'package.json'));
+                // Check for lock files to determine package manager
+                const files = await fs.readdir(projectRoot);
+                if (files.includes('pnpm-lock.yaml')) {
+                    return { manager: 'pnpm', hasPackageJson: true };
                 }
-                catch { }
-                // Parse the response
-                let response;
-                try {
-                    const wrapper = JSON.parse(result);
-                    let actualResult = wrapper.result || wrapper;
-                    if (typeof actualResult === 'string') {
-                        actualResult = actualResult.trim();
-                        // Extract JSON from the response
-                        const jsonMatch = actualResult.match(/\{[\s\S]*\}/);
-                        if (jsonMatch) {
-                            let jsonStr = jsonMatch[0];
-                            // Clean up markdown code blocks if present
-                            if (actualResult.includes('```')) {
-                                const codeBlockMatch = actualResult.match(/```(?:json)?\s*([\s\S]*?)```/);
-                                if (codeBlockMatch) {
-                                    jsonStr = codeBlockMatch[1].trim();
-                                }
-                            }
-                            actualResult = JSON.parse(jsonStr);
-                        }
-                        else {
-                            throw new Error('No JSON object found in response');
-                        }
-                    }
-                    response = actualResult;
+                else if (files.includes('yarn.lock')) {
+                    return { manager: 'yarn', hasPackageJson: true };
                 }
-                catch (parseError) {
-                    // Failed to parse Claude response
-                    throw new Error(`Failed to parse AI response: ${parseError}`);
+                else if (files.includes('package-lock.json')) {
+                    return { manager: 'npm', hasPackageJson: true };
                 }
-                // Handle the response
-                if (response.type === 'cat' && !isLastAttempt) {
-                    // Read the requested file
-                    const targetPath = path.join(projectRoot, response.path);
-                    try {
-                        const content = await fs.readFile(targetPath, 'utf-8');
-                        const truncated = content.length > 4000
-                            ? content.substring(0, 4000) + '\n... [truncated]'
-                            : content;
-                        requestedFile = `\nContents of ${response.path}:\n${truncated}\n`;
-                    }
-                    catch (err) {
-                        requestedFile = `\nError reading ${response.path}: File not found\n`;
-                    }
-                    // Continue to next iteration to get the command
-                }
-                else if (response.type === 'command') {
-                    // Got the command!
-                    setGeneratingCommand(false);
-                    setStatusMessage('');
-                    return response.command;
+                else {
+                    // Default to npm if no lock file found
+                    return { manager: 'npm', hasPackageJson: true };
                 }
-                else if (isLastAttempt) {
-                    // Last attempt must provide a command
-                    throw new Error('AI did not provide a command on final attempt');
+            }
+            catch {
+                // No package.json found
+                return { manager: null, hasPackageJson: false };
+            }
+        }
+        catch {
+            return { manager: null, hasPackageJson: false };
+        }
+    };
+    const suggestCommand = async (type) => {
+        const { manager, hasPackageJson } = await detectPackageManager();
+        if (!hasPackageJson) {
+            return null;
+        }
+        // Suggest standard commands based on package manager
+        if (type === 'test') {
+            return `${manager} run test`;
+        }
+        else {
+            return `${manager} run dev`;
+        }
+    };
+    const copyNonGitFiles = async (worktreePath) => {
+        try {
+            setStatusMessage('Copying non-git files from main...');
+            // Get project root
+            const projectRoot = execSync('git rev-parse --show-toplevel', {
+                encoding: 'utf-8',
+                stdio: 'pipe'
+            }).trim();
+            // Use rsync to copy non-tracked files
+            // This copies everything except git-tracked files, .git, and common build directories
+            const rsyncCmd = `rsync -avz --exclude='.git' --exclude='node_modules' --exclude='dist' --exclude='build' --exclude='.next' --exclude='.turbo' "${projectRoot}/" "${worktreePath}/"`;
+            execSync(rsyncCmd, { stdio: 'pipe' });
+            setStatusMessage('Non-git files copied successfully');
+            setTimeout(() => setStatusMessage(''), 2000);
+        }
+        catch (error) {
+            setStatusMessage('Failed to copy non-git files');
+            setTimeout(() => setStatusMessage(''), 2000);
+        }
+    };
+    const runCommandInternal = async (type, pane) => {
+        if (!pane.worktreePath) {
+            setStatusMessage('No worktree path for this pane');
+            setTimeout(() => setStatusMessage(''), 2000);
+            return;
+        }
+        const command = type === 'test' ? projectSettings.testCommand : projectSettings.devCommand;
+        if (!command) {
+            setStatusMessage('No command configured');
+            setTimeout(() => setStatusMessage(''), 2000);
+            return;
+        }
+        try {
+            setRunningCommand(true);
+            setStatusMessage(`Starting ${type} in background window...`);
+            // Kill existing window if present
+            const existingWindowId = type === 'test' ? pane.testWindowId : pane.devWindowId;
+            if (existingWindowId) {
+                try {
+                    execSync(`tmux kill-window -t '${existingWindowId}'`, { stdio: 'pipe' });
                 }
+                catch { }
+            }
+            // Create a new background window for the command
+            const windowName = `${pane.slug}-${type}`;
+            const windowId = execSync(`tmux new-window -d -n '${windowName}' -P -F '#{window_id}'`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+            // Create a log file to capture output
+            const logFile = `/tmp/dmux-${pane.id}-${type}.log`;
+            // Build the command with output capture
+            const fullCommand = `cd "${pane.worktreePath}" && ${command} 2>&1 | tee ${logFile}`;
+            // Send the command to the new window
+            execSync(`tmux send-keys -t '${windowId}' '${fullCommand.replace(/'/g, "'\\''")}' Enter`, { stdio: 'pipe' });
+            // Update pane with window info
+            const updatedPane = {
+                ...pane,
+                [type === 'test' ? 'testWindowId' : 'devWindowId']: windowId,
+                [type === 'test' ? 'testStatus' : 'devStatus']: 'running'
+            };
+            const updatedPanes = panes.map(p => p.id === pane.id ? updatedPane : p);
+            await savePanes(updatedPanes);
+            // Start monitoring the output
+            if (type === 'test') {
+                // For tests, monitor for completion
+                setTimeout(() => monitorTestOutput(pane.id, logFile), 2000);
             }
-            throw new Error('Failed to generate command after maximum attempts');
+            else {
+                // For dev, monitor for server URL
+                setTimeout(() => monitorDevOutput(pane.id, logFile), 2000);
+            }
+            setRunningCommand(false);
+            setStatusMessage(`${type === 'test' ? 'Test' : 'Dev server'} started in background`);
+            setTimeout(() => setStatusMessage(''), 3000);
         }
         catch (error) {
-            setGeneratingCommand(false);
-            setStatusMessage(`Failed to generate command: ${error}`);
+            setRunningCommand(false);
+            setStatusMessage(`Failed to run ${type} command`);
             setTimeout(() => setStatusMessage(''), 3000);
-            return null;
         }
     };
     const runCommand = async (type, pane) => {
@@ -1166,11 +1230,21 @@ OR ` : ''}To provide the final command:
             return;
         }
         const command = type === 'test' ? projectSettings.testCommand : projectSettings.devCommand;
+        const isFirstRun = type === 'test' ? !projectSettings.firstTestRun : !projectSettings.firstDevRun;
         if (!command) {
             // No command configured, prompt user
             setShowCommandPrompt(type);
             return;
         }
+        // Check if this is the first run and offer to copy non-git files
+        if (isFirstRun) {
+            // Show file copy prompt and wait for response
+            setShowFileCopyPrompt(true);
+            setCurrentCommandType(type);
+            setStatusMessage(`First time running ${type} command...`);
+            // Return here - the actual command will be run after user responds to prompt
+            return;
+        }
         try {
             setRunningCommand(true);
             setStatusMessage(`Starting ${type} in background window...`);
@@ -1421,24 +1495,55 @@ OR ` : ''}To provide the final command:
         exit();
     };
     useInput(async (input, key) => {
-        if (isCreatingPane || generatingCommand || runningCommand) {
+        if (isCreatingPane || runningCommand) {
             // Disable input while performing operations
             return;
         }
+        if (showFileCopyPrompt) {
+            if (input === 'y' || input === 'Y') {
+                setShowFileCopyPrompt(false);
+                const selectedPane = panes[selectedIndex];
+                if (selectedPane && selectedPane.worktreePath && currentCommandType) {
+                    await copyNonGitFiles(selectedPane.worktreePath);
+                    // Mark as not first run and continue with command
+                    const newSettings = {
+                        ...projectSettings,
+                        [currentCommandType === 'test' ? 'firstTestRun' : 'firstDevRun']: true
+                    };
+                    await saveSettings(newSettings);
+                    // Now run the actual command
+                    await runCommandInternal(currentCommandType, selectedPane);
+                }
+                setCurrentCommandType(null);
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                setShowFileCopyPrompt(false);
+                const selectedPane = panes[selectedIndex];
+                if (selectedPane && currentCommandType) {
+                    // Mark as not first run and continue without copying
+                    const newSettings = {
+                        ...projectSettings,
+                        [currentCommandType === 'test' ? 'firstTestRun' : 'firstDevRun']: true
+                    };
+                    await saveSettings(newSettings);
+                    // Now run the actual command
+                    await runCommandInternal(currentCommandType, selectedPane);
+                }
+                setCurrentCommandType(null);
+            }
+            return;
+        }
         if (showCommandPrompt) {
             if (key.escape) {
                 setShowCommandPrompt(null);
                 setCommandInput('');
-                setShowAIPrompt(false);
-                setAIChangeRequest('');
             }
-            else if (key.return && !showAIPrompt) {
+            else if (key.return) {
                 if (commandInput.trim() === '') {
-                    // User wants AI to generate
-                    const generated = await generateCommand(showCommandPrompt);
-                    if (generated) {
-                        setCommandInput(generated);
-                        setShowAIPrompt(true);
+                    // If empty, suggest a default command based on package manager
+                    const suggested = await suggestCommand(showCommandPrompt);
+                    if (suggested) {
+                        setCommandInput(suggested);
                     }
                 }
                 else {
@@ -1450,43 +1555,37 @@ OR ` : ''}To provide the final command:
                     await saveSettings(newSettings);
                     const selectedPane = panes[selectedIndex];
                     if (selectedPane) {
-                        await runCommand(showCommandPrompt, selectedPane);
-                    }
-                    setShowCommandPrompt(null);
-                    setCommandInput('');
-                    setShowAIPrompt(false);
-                }
-            }
-            else if (key.return && showAIPrompt) {
-                if (aiChangeRequest.trim() === '') {
-                    // User accepts AI generated command
-                    const newSettings = {
-                        ...projectSettings,
-                        [showCommandPrompt === 'test' ? 'testCommand' : 'devCommand']: commandInput.trim()
-                    };
-                    await saveSettings(newSettings);
-                    const selectedPane = panes[selectedIndex];
-                    if (selectedPane) {
-                        await runCommand(showCommandPrompt, selectedPane);
+                        // Check if first run
+                        const isFirstRun = showCommandPrompt === 'test' ? !projectSettings.firstTestRun : !projectSettings.firstDevRun;
+                        if (isFirstRun) {
+                            setCurrentCommandType(showCommandPrompt);
+                            setShowCommandPrompt(null);
+                            setShowFileCopyPrompt(true);
+                        }
+                        else {
+                            await runCommandInternal(showCommandPrompt, selectedPane);
+                            setShowCommandPrompt(null);
+                            setCommandInput('');
+                        }
                     }
-                    setShowCommandPrompt(null);
-                    setCommandInput('');
-                    setShowAIPrompt(false);
-                    setAIChangeRequest('');
-                }
-                else {
-                    // User wants changes, regenerate
-                    const generated = await generateCommand(showCommandPrompt, aiChangeRequest);
-                    if (generated) {
-                        setCommandInput(generated);
-                        setAIChangeRequest('');
+                    else {
+                        setShowCommandPrompt(null);
+                        setCommandInput('');
                     }
                 }
             }
             return;
         }
         if (showNewPaneDialog) {
-            // EnhancedTextInput handles its own input events
+            if (key.escape) {
+                setShowNewPaneDialog(false);
+                setNewPanePrompt('');
+            }
+            else if (key.ctrl && input === 'o') {
+                // Open in external editor
+                openInEditor();
+            }
+            // TextInput handles other input events
             return;
         }
         if (showMergeConfirmation) {
@@ -1628,18 +1727,18 @@ OR ` : ''}To provide the final command:
             }),
             React.createElement(Box, { paddingX: 1, borderStyle: "single", borderColor: selectedIndex === panes.length ? 'green' : 'gray', width: 35, flexShrink: 0 },
                 React.createElement(Text, { color: selectedIndex === panes.length ? 'green' : 'white' }, "+ New dmux pane"))),
-        showNewPaneDialog && (React.createElement(Box, { borderStyle: "double", borderColor: "cyan", paddingX: 1 },
+        showNewPaneDialog && (React.createElement(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1 },
             React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, null, "Enter initial Claude prompt (ESC to cancel):"),
                 React.createElement(Box, { marginTop: 1 },
-                    React.createElement(SimpleEnhancedInput, { value: newPanePrompt, onChange: setNewPanePrompt, placeholder: "Optional prompt... (@ to reference files)", onSubmit: () => {
-                            createNewPane(newPanePrompt);
-                            setShowNewPaneDialog(false);
-                            setNewPanePrompt('');
-                        }, onCancel: () => {
-                            setShowNewPaneDialog(false);
-                            setNewPanePrompt('');
-                        }, isActive: showNewPaneDialog, workingDirectory: process.cwd() }))))),
+                    React.createElement(Box, { flexDirection: "column" },
+                        React.createElement(TextInput, { value: newPanePrompt, onChange: setNewPanePrompt, placeholder: "Optional prompt... (@ to reference files)", onSubmit: () => {
+                                createNewPane(newPanePrompt);
+                                setShowNewPaneDialog(false);
+                                setNewPanePrompt('');
+                            } }),
+                        React.createElement(Box, { marginTop: 1 },
+                            React.createElement(Text, { dimColor: true, italic: true }, "Press Ctrl+O to open in $EDITOR for complex multi-line input"))))))),
         isCreatingPane && (React.createElement(Box, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginTop: 1 },
             React.createElement(Text, { color: "yellow" },
                 React.createElement(Text, { bold: true }, "\u23F3 Creating new pane... "),
@@ -1675,7 +1774,7 @@ OR ` : ''}To provide the final command:
                         React.createElement(Text, { color: selectedCloseOption === 3 ? 'cyan' : 'white' },
                             selectedCloseOption === 3 ? '▶ ' : '  ',
                             "Just Close - Close pane only")))))),
-        showCommandPrompt && !showAIPrompt && (React.createElement(Box, { borderStyle: "double", borderColor: "magenta", paddingX: 1, marginTop: 1 },
+        showCommandPrompt && (React.createElement(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1 },
             React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, { color: "magenta", bold: true },
                     "Configure ",
@@ -1685,24 +1784,16 @@ OR ` : ''}To provide the final command:
                     "Enter command to run ",
                     showCommandPrompt === 'test' ? 'tests' : 'dev server',
                     " in worktrees"),
-                React.createElement(Text, { dimColor: true }, "(Press Enter with empty input to generate with AI, ESC to cancel)"),
+                React.createElement(Text, { dimColor: true }, "(Press Enter with empty input for suggested command, ESC to cancel)"),
                 React.createElement(Box, { marginTop: 1 },
                     React.createElement(TextInput, { value: commandInput, onChange: setCommandInput, placeholder: showCommandPrompt === 'test' ? 'e.g., npm test, pnpm test' : 'e.g., npm run dev, pnpm dev' }))))),
-        showCommandPrompt && showAIPrompt && (React.createElement(Box, { borderStyle: "double", borderColor: "magenta", paddingX: 1, marginTop: 1 },
+        showFileCopyPrompt && (React.createElement(Box, { borderStyle: "double", borderColor: "yellow", paddingX: 1, marginTop: 1 },
             React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: "magenta", bold: true },
-                    "AI Generated ",
-                    showCommandPrompt === 'test' ? 'Test' : 'Dev',
-                    " Command"),
-                React.createElement(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1 },
-                    React.createElement(Text, null, commandInput)),
+                React.createElement(Text, { color: "yellow", bold: true }, "First Run Setup"),
+                React.createElement(Text, null, "Copy non-git files (like .env, configs) from main to worktree?"),
+                React.createElement(Text, { dimColor: true }, "This includes files not tracked by git but excludes node_modules, dist, etc."),
                 React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { dimColor: true }, "Press Enter to accept, or describe changes needed:")),
-                React.createElement(Box, { marginTop: 1 },
-                    React.createElement(TextInput, { value: aiChangeRequest, onChange: setAIChangeRequest, placeholder: "e.g., 'also copy .env file' or press Enter to accept" }))))),
-        generatingCommand && (React.createElement(Box, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginTop: 1 },
-            React.createElement(Text, { color: "yellow" },
-                React.createElement(Text, { bold: true }, "\u23F3 Generating command with AI...")))),
+                    React.createElement(Text, null, "(y/n):"))))),
         runningCommand && (React.createElement(Box, { borderStyle: "single", borderColor: "blue", paddingX: 1, marginTop: 1 },
             React.createElement(Text, { color: "blue" },
                 React.createElement(Text, { bold: true }, "\u25B6 Running command...")))),