commandmate 0.1.5 → 0.1.7

package/dist/cli/utils/prompt.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Interactive Prompt Utilities
+ * Issue #119: Interactive init support
+ *
+ * Provides readline-based prompts for CLI commands.
+ * Reference implementation: scripts/setup-env.sh
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeReadline = closeReadline;
+exports.expandTilde = expandTilde;
+exports.resolvePath = resolvePath;
+exports.validatePort = validatePort;
+exports.prompt = prompt;
+exports.confirm = confirm;
+exports.isInteractive = isInteractive;
+const readline = __importStar(require("readline"));
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * Readline interface singleton
+ * Reused across prompts to avoid creating multiple interfaces
+ */
+let rlInstance = null;
+/**
+ * Get or create readline interface
+ */
+function getReadlineInterface() {
+    if (!rlInstance) {
+        rlInstance = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+    }
+    return rlInstance;
+}
+/**
+ * Close readline interface
+ * Should be called when all prompts are done
+ */
+function closeReadline() {
+    if (rlInstance) {
+        rlInstance.close();
+        rlInstance = null;
+    }
+}
+/**
+ * Expand tilde (~) to home directory
+ *
+ * @param path - Path that may contain tilde
+ * @returns Path with tilde expanded to home directory
+ *
+ * @example
+ * expandTilde('~/repos') // '/Users/xxx/repos'
+ * expandTilde('/absolute/path') // '/absolute/path'
+ */
+function expandTilde(path) {
+    if (path.startsWith('~/')) {
+        return path.replace(/^~/, (0, os_1.homedir)());
+    }
+    if (path === '~') {
+        return (0, os_1.homedir)();
+    }
+    return path;
+}
+/**
+ * Resolve path to absolute path
+ * Handles tilde expansion and relative paths
+ *
+ * @param path - Path to resolve
+ * @returns Absolute path
+ */
+function resolvePath(path) {
+    const expanded = expandTilde(path);
+    return (0, path_1.resolve)(expanded);
+}
+/**
+ * Validate port number
+ *
+ * @param input - Port number as string
+ * @returns Error message or true if valid
+ */
+function validatePort(input) {
+    const port = parseInt(input, 10);
+    if (isNaN(port)) {
+        return 'Port must be a number';
+    }
+    if (port < 1 || port > 65535) {
+        return 'Port must be between 1 and 65535';
+    }
+    return true;
+}
+/**
+ * Interactive prompt with default value and validation
+ *
+ * @param question - Question to display
+ * @param options - Prompt options (default, validate)
+ * @returns User input or default value
+ *
+ * @example
+ * const port = await prompt('Server port', { default: '3000', validate: validatePort });
+ */
+async function prompt(question, options = {}) {
+    const rl = getReadlineInterface();
+    const { default: defaultValue, validate } = options;
+    const displayQuestion = defaultValue
+        ? `? ${question} [${defaultValue}]: `
+        : `? ${question}: `;
+    return new Promise((resolvePromise) => {
+        const askQuestion = () => {
+            rl.question(displayQuestion, (answer) => {
+                const trimmedAnswer = answer.trim();
+                const result = trimmedAnswer || defaultValue || '';
+                // Validate if validator provided
+                if (validate && result) {
+                    const validationResult = validate(result);
+                    if (validationResult !== true) {
+                        console.log(`  Error: ${validationResult}`);
+                        askQuestion(); // Re-ask
+                        return;
+                    }
+                }
+                resolvePromise(result);
+            });
+        };
+        askQuestion();
+    });
+}
+/**
+ * Interactive Yes/No confirmation
+ *
+ * @param question - Question to display
+ * @param options - Confirm options (default)
+ * @returns true for Yes, false for No
+ *
+ * @example
+ * const enableExternal = await confirm('Enable external access?', { default: false });
+ */
+async function confirm(question, options = {}) {
+    const rl = getReadlineInterface();
+    const defaultValue = options.default ?? false;
+    const hint = defaultValue ? '(Y/n)' : '(y/N)';
+    const displayQuestion = `? ${question} ${hint}: `;
+    return new Promise((resolvePromise) => {
+        const askQuestion = () => {
+            rl.question(displayQuestion, (answer) => {
+                const trimmedAnswer = answer.trim().toLowerCase();
+                if (trimmedAnswer === '') {
+                    resolvePromise(defaultValue);
+                    return;
+                }
+                if (trimmedAnswer === 'y' || trimmedAnswer === 'yes') {
+                    resolvePromise(true);
+                    return;
+                }
+                if (trimmedAnswer === 'n' || trimmedAnswer === 'no') {
+                    resolvePromise(false);
+                    return;
+                }
+                // Invalid input - re-ask
+                console.log('  Please answer with y/n or yes/no');
+                askQuestion();
+            });
+        };
+        askQuestion();
+    });
+}
+/**
+ * Check if running in interactive mode (TTY)
+ *
+ * @returns true if stdin is a TTY (interactive terminal)
+ */
+function isInteractive() {
+    return process.stdin.isTTY === true;
+}

package/dist/server/server.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Custom Next.js Server with WebSocket Support
+ * Integrates WebSocket server for real-time communication
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// IMPORTANT: Register uncaught exception handler FIRST, before any imports
+// This ensures we catch WebSocket frame errors before other handlers
+process.on('uncaughtException', (error) => {
+    // Check for WebSocket-related errors that are non-fatal
+    const isWebSocketError = error.code === 'WS_ERR_INVALID_UTF8' ||
+        error.code === 'WS_ERR_INVALID_CLOSE_CODE' ||
+        error.code === 'WS_ERR_UNEXPECTED_RSV_1' ||
+        error.code === 'ECONNRESET' ||
+        error.code === 'EPIPE' ||
+        (error instanceof RangeError && error.message?.includes('Invalid WebSocket frame')) ||
+        error.message?.includes('write after end');
+    if (isWebSocketError) {
+        // Silently ignore these non-fatal WebSocket frame errors
+        // They commonly occur when mobile browsers send malformed close frames
+        return;
+    }
+    // For other uncaught exceptions, log and exit
+    console.error('Uncaught exception:', error);
+    process.exit(1);
+});
+const http_1 = require("http");
+const url_1 = require("url");
+const next_1 = __importDefault(require("next"));
+const ws_server_1 = require("./src/lib/ws-server");
+const worktrees_1 = require("./src/lib/worktrees");
+const db_instance_1 = require("./src/lib/db-instance");
+const response_poller_1 = require("./src/lib/response-poller");
+const db_migrations_1 = require("./src/lib/db-migrations");
+const env_1 = require("./src/lib/env");
+const dev = process.env.NODE_ENV !== 'production';
+const hostname = (0, env_1.getEnvByKey)('CM_BIND') || '127.0.0.1';
+const port = parseInt((0, env_1.getEnvByKey)('CM_PORT') || '3000', 10);
+// Create Next.js app
+const app = (0, next_1.default)({ dev, hostname, port });
+const handle = app.getRequestHandler();
+app.prepare().then(() => {
+    // Create HTTP server
+    const server = (0, http_1.createServer)(async (req, res) => {
+        try {
+            const parsedUrl = (0, url_1.parse)(req.url, true);
+            await handle(req, res, parsedUrl);
+        }
+        catch (err) {
+            console.error('Error handling request', err);
+            res.statusCode = 500;
+            res.end('Internal Server Error');
+        }
+    });
+    // Setup WebSocket server
+    (0, ws_server_1.setupWebSocket)(server);
+    // Scan and sync worktrees on startup
+    async function initializeWorktrees() {
+        try {
+            // Run database migrations first
+            console.log('Running database migrations...');
+            const db = (0, db_instance_1.getDbInstance)();
+            (0, db_migrations_1.runMigrations)(db);
+            // Get repository paths from environment variables
+            const repositoryPaths = (0, worktrees_1.getRepositoryPaths)();
+            if (repositoryPaths.length === 0) {
+                console.warn('Warning: No repository paths configured');
+                console.warn('Set WORKTREE_REPOS (comma-separated) or MCBD_ROOT_DIR');
+                return;
+            }
+            console.log(`Configured repositories: ${repositoryPaths.length}`);
+            repositoryPaths.forEach((path, i) => {
+                console.log(`  ${i + 1}. ${path}`);
+            });
+            // Scan all repositories
+            const worktrees = await (0, worktrees_1.scanMultipleRepositories)(repositoryPaths);
+            // Sync to database
+            (0, worktrees_1.syncWorktreesToDB)(db, worktrees);
+            console.log(`✓ Total: ${worktrees.length} worktree(s) synced to database`);
+        }
+        catch (error) {
+            console.error('Error initializing worktrees:', error);
+        }
+    }
+    server.listen(port, async (err) => {
+        if (err)
+            throw err;
+        console.log(`> Ready on http://${hostname}:${port}`);
+        console.log(`> WebSocket server ready`);
+        // Initialize worktrees after server starts
+        await initializeWorktrees();
+    });
+    // Graceful shutdown with timeout
+    let isShuttingDown = false;
+    function gracefulShutdown(signal) {
+        if (isShuttingDown) {
+            console.log('Shutdown already in progress, forcing exit...');
+            process.exit(1);
+        }
+        isShuttingDown = true;
+        console.log(`${signal} received: shutting down...`);
+        // Stop polling first
+        (0, response_poller_1.stopAllPolling)();
+        // Close WebSocket connections immediately (don't wait)
+        (0, ws_server_1.closeWebSocket)();
+        // Force exit after 3 seconds if graceful shutdown fails
+        const forceExitTimeout = setTimeout(() => {
+            console.log('Graceful shutdown timeout, forcing exit...');
+            process.exit(1);
+        }, 3000);
+        // Try graceful HTTP server close
+        server.close(() => {
+            clearTimeout(forceExitTimeout);
+            console.log('Server closed gracefully');
+            process.exit(0);
+        });
+    }
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+});

package/dist/server/src/lib/claude-output.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Claude output parsing utilities
+ * Shared between webhook handlers and polling logic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClaudeOutput = parseClaudeOutput;
+const LOG_FILE_REGEX = /📄 Session log: (.+?\/([^\/\s]+\.jsonl))/;
+const REQUEST_ID_REGEX = /Request ID: ([^\s\n]+)/;
+const SUMMARY_REGEX = /Summary: (.+?)(?:\n─|$)/s;
+/**
+ * Parse Claude CLI output and extract metadata that the UI relies on.
+ *
+ * @param output Raw tmux capture string
+ */
+function parseClaudeOutput(output) {
+    const result = {
+        content: output,
+    };
+    const logFileMatch = LOG_FILE_REGEX.exec(output);
+    if (logFileMatch) {
+        result.logFileName = logFileMatch[2];
+    }
+    const requestIdMatch = REQUEST_ID_REGEX.exec(output);
+    if (requestIdMatch) {
+        result.requestId = requestIdMatch[1];
+    }
+    const summaryMatch = SUMMARY_REGEX.exec(output);
+    if (summaryMatch) {
+        result.summary = summaryMatch[1].trim();
+    }
+    return result;
+}

package/dist/server/src/lib/claude-session.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * Claude CLI session management
+ * Manages Claude CLI sessions within tmux for each worktree
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionName = getSessionName;
+exports.isClaudeInstalled = isClaudeInstalled;
+exports.isClaudeRunning = isClaudeRunning;
+exports.getClaudeSessionState = getClaudeSessionState;
+exports.startClaudeSession = startClaudeSession;
+exports.sendMessageToClaude = sendMessageToClaude;
+exports.captureClaudeOutput = captureClaudeOutput;
+exports.stopClaudeSession = stopClaudeSession;
+exports.restartClaudeSession = restartClaudeSession;
+const tmux_1 = require("./tmux");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Cached Claude CLI path
+ */
+let cachedClaudePath = null;
+/**
+ * Get Claude CLI path dynamically
+ * Uses CLAUDE_PATH environment variable if set, otherwise finds via 'which'
+ */
+async function getClaudePath() {
+    // Return cached path if available
+    if (cachedClaudePath) {
+        return cachedClaudePath;
+    }
+    // Check environment variable first
+    if (process.env.CLAUDE_PATH) {
+        cachedClaudePath = process.env.CLAUDE_PATH;
+        return cachedClaudePath;
+    }
+    // Find claude via 'which' command
+    try {
+        const { stdout } = await execAsync('which claude', { timeout: 5000 });
+        cachedClaudePath = stdout.trim();
+        return cachedClaudePath;
+    }
+    catch {
+        // Fallback to common paths
+        const fallbackPaths = [
+            '/opt/homebrew/bin/claude', // macOS Homebrew (Apple Silicon)
+            '/usr/local/bin/claude', // macOS Homebrew (Intel) / Linux
+            '/usr/bin/claude', // Linux system install
+        ];
+        for (const path of fallbackPaths) {
+            try {
+                await execAsync(`test -x "${path}"`, { timeout: 1000 });
+                cachedClaudePath = path;
+                return cachedClaudePath;
+            }
+            catch {
+                // Path not found, try next
+            }
+        }
+        throw new Error('Claude CLI not found. Set CLAUDE_PATH environment variable or install Claude CLI.');
+    }
+}
+/**
+ * Get tmux session name for a worktree
+ *
+ * @param worktreeId - Worktree ID
+ * @returns tmux session name
+ *
+ * @example
+ * ```typescript
+ * getSessionName('feature-foo') // => 'mcbd-claude-feature-foo'
+ * ```
+ */
+function getSessionName(worktreeId) {
+    return `mcbd-claude-${worktreeId}`;
+}
+/**
+ * Check if Claude is installed and available
+ *
+ * @returns True if Claude CLI is available
+ */
+async function isClaudeInstalled() {
+    try {
+        await execAsync('which claude', { timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if Claude session is running
+ *
+ * @param worktreeId - Worktree ID
+ * @returns True if Claude session exists and is running
+ *
+ * @example
+ * ```typescript
+ * const running = await isClaudeRunning('feature-foo');
+ * if (running) {
+ *   console.log('Claude is ready');
+ * }
+ * ```
+ */
+async function isClaudeRunning(worktreeId) {
+    const sessionName = getSessionName(worktreeId);
+    return await (0, tmux_1.hasSession)(sessionName);
+}
+/**
+ * Get Claude session state
+ *
+ * @param worktreeId - Worktree ID
+ * @returns Session state information
+ */
+async function getClaudeSessionState(worktreeId) {
+    const sessionName = getSessionName(worktreeId);
+    const isRunning = await (0, tmux_1.hasSession)(sessionName);
+    return {
+        sessionName,
+        isRunning,
+        lastActivity: new Date(),
+    };
+}
+/**
+ * Start a Claude CLI session in tmux
+ *
+ * @param options - Session options
+ * @throws {Error} If Claude CLI is not installed or session creation fails
+ *
+ * @example
+ * ```typescript
+ * await startClaudeSession({
+ *   worktreeId: 'feature-foo',
+ *   worktreePath: '/path/to/worktree',
+ *   baseUrl: 'http://localhost:3000',
+ * });
+ * ```
+ */
+async function startClaudeSession(options) {
+    const { worktreeId, worktreePath } = options;
+    // Check if Claude is installed
+    const claudeAvailable = await isClaudeInstalled();
+    if (!claudeAvailable) {
+        throw new Error('Claude CLI is not installed or not in PATH');
+    }
+    const sessionName = getSessionName(worktreeId);
+    // Check if session already exists
+    const exists = await (0, tmux_1.hasSession)(sessionName);
+    if (exists) {
+        console.log(`Claude session ${sessionName} already exists`);
+        return;
+    }
+    try {
+        // Create tmux session with large history buffer for Claude output
+        await (0, tmux_1.createSession)({
+            sessionName,
+            workingDirectory: worktreePath,
+            historyLimit: 50000,
+        });
+        // Get Claude CLI path dynamically
+        const claudePath = await getClaudePath();
+        // Start Claude CLI in interactive mode using dynamically resolved path
+        await (0, tmux_1.sendKeys)(sessionName, claudePath, true);
+        // Wait for Claude to initialize with dynamic detection
+        // Check for Claude prompt instead of fixed delay
+        const maxWaitTime = 10000; // 10 seconds max
+        const pollInterval = 500; // Check every 500ms
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            try {
+                const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
+                // Claude is ready when we see the prompt (> ) or separator line
+                if (/^>\s*$/m.test(output) || /^─{10,}$/m.test(output)) {
+                    console.log(`✓ Claude initialized in ${Date.now() - startTime}ms`);
+                    break;
+                }
+            }
+            catch {
+                // Ignore capture errors during initialization
+            }
+        }
+        console.log(`✓ Started Claude session: ${sessionName}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to start Claude session: ${errorMessage}`);
+    }
+}
+/**
+ * Send a message to Claude CLI
+ *
+ * @param worktreeId - Worktree ID
+ * @param message - Message content to send
+ * @throws {Error} If session doesn't exist
+ *
+ * @example
+ * ```typescript
+ * await sendMessageToClaude('feature-foo', 'Explain this code');
+ * ```
+ */
+async function sendMessageToClaude(worktreeId, message) {
+    const sessionName = getSessionName(worktreeId);
+    // Check if session exists
+    const exists = await (0, tmux_1.hasSession)(sessionName);
+    if (!exists) {
+        throw new Error(`Claude session ${sessionName} does not exist. Start the session first.`);
+    }
+    try {
+        // Send message to Claude (without Enter)
+        await (0, tmux_1.sendKeys)(sessionName, message, false);
+        // Wait a moment for the text to be typed
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Send Enter key to submit (single Enter submits in Claude Code CLI)
+        await execAsync(`tmux send-keys -t "${sessionName}" C-m`);
+        // Wait a moment for the message to be processed
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        console.log(`✓ Sent message to Claude session: ${sessionName}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to send message to Claude: ${errorMessage}`);
+    }
+}
+/**
+ * Capture Claude session output
+ *
+ * @param worktreeId - Worktree ID
+ * @param lines - Number of lines to capture (default: 1000)
+ * @returns Captured output
+ *
+ * @example
+ * ```typescript
+ * const output = await captureClaudeOutput('feature-foo');
+ * console.log(output);
+ * ```
+ */
+async function captureClaudeOutput(worktreeId, lines = 1000) {
+    const sessionName = getSessionName(worktreeId);
+    // Check if session exists
+    const exists = await (0, tmux_1.hasSession)(sessionName);
+    if (!exists) {
+        throw new Error(`Claude session ${sessionName} does not exist`);
+    }
+    try {
+        return await (0, tmux_1.capturePane)(sessionName, { startLine: -lines });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to capture Claude output: ${errorMessage}`);
+    }
+}
+/**
+ * Stop a Claude session
+ *
+ * @param worktreeId - Worktree ID
+ * @returns True if session was stopped, false if it didn't exist
+ *
+ * @example
+ * ```typescript
+ * await stopClaudeSession('feature-foo');
+ * ```
+ */
+async function stopClaudeSession(worktreeId) {
+    const sessionName = getSessionName(worktreeId);
+    try {
+        // Send Ctrl+D to exit Claude gracefully
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (exists) {
+            await (0, tmux_1.sendKeys)(sessionName, '', false);
+            // Send Ctrl+D (ASCII 4)
+            await execAsync(`tmux send-keys -t "${sessionName}" C-d`);
+            // Wait a moment for Claude to exit
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+        // Kill the tmux session
+        const killed = await (0, tmux_1.killSession)(sessionName);
+        if (killed) {
+            console.log(`✓ Stopped Claude session: ${sessionName}`);
+        }
+        return killed;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error stopping Claude session: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Restart a Claude session
+ *
+ * @param options - Session options
+ *
+ * @example
+ * ```typescript
+ * await restartClaudeSession({
+ *   worktreeId: 'feature-foo',
+ *   worktreePath: '/path/to/worktree',
+ *   baseUrl: 'http://localhost:3000',
+ * });
+ * ```
+ */
+async function restartClaudeSession(options) {
+    const { worktreeId } = options;
+    // Stop existing session
+    await stopClaudeSession(worktreeId);
+    // Wait a moment before restarting
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    // Start new session
+    await startClaudeSession(options);
+}