commandmate 0.1.0 → 0.1.6

package/dist/server/src/lib/tmux.js

@@ -0,0 +1,299 @@
+"use strict";
+/**
+ * tmux session management
+ * Provides functions to manage tmux sessions for Claude CLI integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTmuxAvailable = isTmuxAvailable;
+exports.hasSession = hasSession;
+exports.listSessions = listSessions;
+exports.createSession = createSession;
+exports.sendKeys = sendKeys;
+exports.capturePane = capturePane;
+exports.killSession = killSession;
+exports.ensureSession = ensureSession;
+exports.sendSpecialKey = sendSpecialKey;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Default timeout for tmux commands (5 seconds)
+ */
+const DEFAULT_TIMEOUT = 5000;
+/**
+ * Check if tmux is installed and available
+ */
+async function isTmuxAvailable() {
+    try {
+        await execAsync('tmux -V', { timeout: DEFAULT_TIMEOUT });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a tmux session exists
+ *
+ * @param sessionName - Name of the tmux session
+ * @returns True if session exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const exists = await hasSession('my-session');
+ * if (exists) {
+ *   console.log('Session is running');
+ * }
+ * ```
+ */
+async function hasSession(sessionName) {
+    try {
+        await execAsync(`tmux has-session -t "${sessionName}"`, { timeout: DEFAULT_TIMEOUT });
+        return true;
+    }
+    catch {
+        // tmux has-session returns non-zero exit code if session doesn't exist
+        return false;
+    }
+}
+/**
+ * List all tmux sessions
+ *
+ * @returns Array of tmux session information
+ *
+ * @example
+ * ```typescript
+ * const sessions = await listSessions();
+ * sessions.forEach(s => console.log(`${s.name}: ${s.windows} windows`));
+ * ```
+ */
+async function listSessions() {
+    try {
+        const { stdout } = await execAsync('tmux list-sessions -F "#{session_name}|#{session_windows}|#{session_attached}"', { timeout: DEFAULT_TIMEOUT });
+        if (!stdout || stdout.trim() === '') {
+            return [];
+        }
+        return stdout
+            .trim()
+            .split('\n')
+            .map(line => {
+            const [name, windows, attached] = line.split('|');
+            return {
+                name,
+                windows: parseInt(windows, 10) || 0,
+                attached: attached === '1',
+            };
+        });
+    }
+    catch {
+        // No sessions exist or tmux not running
+        return [];
+    }
+}
+/**
+ * Create a new tmux session
+ *
+ * @param sessionNameOrOptions - Session name or options object
+ * @param cwd - Working directory (when using legacy signature)
+ *
+ * @throws {Error} If session creation fails
+ *
+ * @example
+ * ```typescript
+ * // Legacy usage
+ * await createSession('my-session', '/path/to/project');
+ *
+ * // New usage with options
+ * await createSession({
+ *   sessionName: 'my-session',
+ *   workingDirectory: '/path/to/project',
+ *   historyLimit: 50000,
+ * });
+ * ```
+ */
+async function createSession(sessionNameOrOptions, cwd) {
+    let sessionName;
+    let workingDirectory;
+    let historyLimit;
+    if (typeof sessionNameOrOptions === 'string') {
+        // Legacy signature
+        sessionName = sessionNameOrOptions;
+        workingDirectory = cwd;
+        historyLimit = 50000;
+    }
+    else {
+        // New signature with options
+        sessionName = sessionNameOrOptions.sessionName;
+        workingDirectory = sessionNameOrOptions.workingDirectory;
+        historyLimit = sessionNameOrOptions.historyLimit || 50000;
+    }
+    try {
+        // Create session
+        await execAsync(`tmux new-session -d -s "${sessionName}" -c "${workingDirectory}"`, { timeout: DEFAULT_TIMEOUT });
+        // Set history limit
+        await execAsync(`tmux set-option -t "${sessionName}" history-limit ${historyLimit}`, { timeout: DEFAULT_TIMEOUT });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to create tmux session: ${errorMessage}`);
+    }
+}
+/**
+ * Send keys to a tmux session
+ *
+ * @param sessionName - Target session name
+ * @param keys - Keys to send (command text)
+ * @param sendEnter - Whether to send Enter key after the command (default: true)
+ *
+ * @throws {Error} If session doesn't exist or command fails
+ *
+ * @example
+ * ```typescript
+ * await sendKeys('my-session', 'echo hello');
+ * await sendKeys('my-session', 'ls -la', true);
+ * await sendKeys('my-session', 'incomplete command', false);
+ * ```
+ */
+async function sendKeys(sessionName, keys, sendEnter = true) {
+    // Escape single quotes in the keys
+    const escapedKeys = keys.replace(/'/g, "'\\''");
+    const command = sendEnter
+        ? `tmux send-keys -t "${sessionName}" '${escapedKeys}' C-m`
+        : `tmux send-keys -t "${sessionName}" '${escapedKeys}'`;
+    try {
+        await execAsync(command, { timeout: DEFAULT_TIMEOUT });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to send keys to tmux session: ${errorMessage}`);
+    }
+}
+/**
+ * Capture pane output from a tmux session
+ *
+ * @param sessionName - Target session name
+ * @param linesOrOptions - Number of lines or options object
+ * @returns Captured output as string
+ *
+ * @example
+ * ```typescript
+ * // Legacy usage
+ * const output = await capturePane('my-session');
+ * const recent = await capturePane('my-session', 100);
+ *
+ * // New usage with options
+ * const full = await capturePane('my-session', {
+ *   startLine: -10000,
+ *   endLine: -1,
+ * });
+ * ```
+ */
+async function capturePane(sessionName, linesOrOptions) {
+    let startLine;
+    let endLine;
+    if (typeof linesOrOptions === 'number') {
+        // Legacy signature
+        startLine = -linesOrOptions;
+        endLine = '-';
+    }
+    else if (linesOrOptions) {
+        // New signature with options
+        startLine = linesOrOptions.startLine ?? -10000;
+        endLine = linesOrOptions.endLine ?? '-';
+    }
+    else {
+        // Default
+        startLine = -1000;
+        endLine = '-';
+    }
+    try {
+        const { stdout } = await execAsync(`tmux capture-pane -t "${sessionName}" -p -e -S ${startLine} -E ${endLine}`, {
+            timeout: DEFAULT_TIMEOUT,
+            maxBuffer: 10 * 1024 * 1024 // 10MB buffer for large Claude outputs
+        });
+        return stdout;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to capture pane: ${errorMessage}`);
+    }
+}
+/**
+ * Kill a tmux session
+ *
+ * @param sessionName - Session name to kill
+ * @returns True if session was killed, false if session didn't exist
+ *
+ * @example
+ * ```typescript
+ * const killed = await killSession('my-session');
+ * if (killed) {
+ *   console.log('Session terminated');
+ * }
+ * ```
+ */
+async function killSession(sessionName) {
+    try {
+        await execAsync(`tmux kill-session -t "${sessionName}"`, {
+            timeout: DEFAULT_TIMEOUT,
+        });
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Session doesn't exist or already killed
+        if (errorMessage?.includes('no server running') ||
+            errorMessage?.includes("can't find session")) {
+            return false;
+        }
+        // Re-throw unexpected errors
+        throw new Error(`Failed to kill tmux session: ${errorMessage}`);
+    }
+}
+/**
+ * Ensure a tmux session exists, creating it if necessary
+ *
+ * @param sessionName - Session name
+ * @param cwd - Working directory for the session
+ *
+ * @example
+ * ```typescript
+ * // Will create session if it doesn't exist
+ * await ensureSession('my-session', '/path/to/project');
+ *
+ * // Safe to call multiple times
+ * await ensureSession('my-session', '/path/to/project');
+ * ```
+ */
+async function ensureSession(sessionName, cwd) {
+    const exists = await hasSession(sessionName);
+    if (!exists) {
+        await createSession(sessionName, cwd);
+    }
+}
+/**
+ * Send a special key to a tmux session
+ *
+ * @param sessionName - Target session name
+ * @param key - Special key to send (Escape, C-c, C-d)
+ *
+ * @throws {Error} If session doesn't exist or command fails
+ *
+ * @example
+ * ```typescript
+ * // Send Escape key to interrupt CLI processing
+ * await sendSpecialKey('my-session', 'Escape');
+ *
+ * // Send Ctrl+C for SIGINT
+ * await sendSpecialKey('my-session', 'C-c');
+ * ```
+ */
+async function sendSpecialKey(sessionName, key) {
+    try {
+        await execAsync(`tmux send-keys -t "${sessionName}" ${key}`, { timeout: DEFAULT_TIMEOUT });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to send special key: ${errorMessage}`);
+    }
+}

package/dist/server/src/lib/worktrees.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * Git worktree management
+ * Scans and manages git worktrees
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWorktreeId = generateWorktreeId;
+exports.parseWorktreeOutput = parseWorktreeOutput;
+exports.getRepositoryPaths = getRepositoryPaths;
+exports.scanWorktrees = scanWorktrees;
+exports.scanMultipleRepositories = scanMultipleRepositories;
+exports.syncWorktreesToDB = syncWorktreesToDB;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path_1 = __importDefault(require("path"));
+const db_1 = require("./db");
+const env_1 = require("./env");
+/**
+ * Generate URL-safe ID from repository name and branch name
+ *
+ * @param branchName - Git branch name (e.g., "feature/foo", "main")
+ * @param repositoryName - Repository name (e.g., "MyRepo")
+ * @returns URL-safe ID (e.g., "myrepo-feature-foo", "myrepo-main")
+ *
+ * @example
+ * ```typescript
+ * generateWorktreeId('feature/foo', 'MyRepo') // => 'myrepo-feature-foo'
+ * generateWorktreeId('main', 'MyRepo') // => 'myrepo-main'
+ * generateWorktreeId('Feature/Foo', 'Repo') // => 'repo-feature-foo'
+ * ```
+ */
+function generateWorktreeId(branchName, repositoryName) {
+    if (!branchName) {
+        return '';
+    }
+    const sanitize = (str) => str
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-') // Replace non-alphanumeric (except hyphen) with hyphen
+        .replace(/-+/g, '-') // Replace consecutive hyphens with single hyphen
+        .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens
+    const sanitizedBranch = sanitize(branchName);
+    if (repositoryName) {
+        const sanitizedRepo = sanitize(repositoryName);
+        return `${sanitizedRepo}-${sanitizedBranch}`;
+    }
+    return sanitizedBranch;
+}
+/**
+ * Parse git worktree list output
+ *
+ * @param output - Output from `git worktree list`
+ * @returns Array of parsed worktree information
+ *
+ * @example
+ * ```typescript
+ * const output = `
+ * /path/to/main abc123 [main]
+ * /path/to/feature def456 [feature/foo]
+ * `;
+ * parseWorktreeOutput(output);
+ * // => [
+ * //   { path: '/path/to/main', branch: 'main', commit: 'abc123' },
+ * //   { path: '/path/to/feature', branch: 'feature/foo', commit: 'def456' }
+ * // ]
+ * ```
+ */
+function parseWorktreeOutput(output) {
+    if (!output || output.trim() === '') {
+        return [];
+    }
+    const lines = output.trim().split('\n');
+    const worktrees = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Format: /path/to/worktree commit [branch]
+        // or:     /path/to/worktree commit (detached HEAD)
+        const match = trimmed.match(/^(.+?)\s+([a-z0-9]+)\s+(?:\[(.+?)\]|\(detached HEAD\))/);
+        if (match) {
+            const [, pathStr, commit, branch] = match;
+            worktrees.push({
+                path: pathStr.trim(),
+                branch: branch || `detached-${commit}`,
+                commit,
+            });
+        }
+    }
+    return worktrees;
+}
+/**
+ * Get repository paths from environment variables
+ * Supports both WORKTREE_REPOS (comma-separated) and CM_ROOT_DIR (single path)
+ *
+ * @returns Array of repository root paths
+ *
+ * @example
+ * ```typescript
+ * // WORKTREE_REPOS="/path/to/repo1,/path/to/repo2"
+ * getRepositoryPaths(); // => ['/path/to/repo1', '/path/to/repo2']
+ *
+ * // CM_ROOT_DIR="/path/to/repo"
+ * getRepositoryPaths(); // => ['/path/to/repo']
+ * ```
+ */
+function getRepositoryPaths() {
+    // Try WORKTREE_REPOS first (supports multiple repos)
+    const worktreeRepos = process.env.WORKTREE_REPOS;
+    if (worktreeRepos && worktreeRepos.trim()) {
+        return worktreeRepos
+            .split(',')
+            .map(p => p.trim())
+            .filter(p => p.length > 0);
+    }
+    // Fallback to CM_ROOT_DIR / MCBD_ROOT_DIR (Issue #76: env fallback support)
+    const rootDir = (0, env_1.getEnvByKey)('CM_ROOT_DIR');
+    if (rootDir && rootDir.trim()) {
+        return [rootDir.trim()];
+    }
+    return [];
+}
+/**
+ * Scan git worktrees in a single repository
+ *
+ * @param rootDir - Root directory to scan for worktrees
+ * @returns Array of Worktree objects
+ *
+ * @throws {Error} If git command fails (except for "not a git repository")
+ *
+ * @example
+ * ```typescript
+ * const worktrees = await scanWorktrees('/path/to/repo');
+ * console.log(worktrees[0].id); // => "main"
+ * ```
+ */
+async function scanWorktrees(rootDir) {
+    const execAsync = (0, util_1.promisify)(child_process_1.exec);
+    try {
+        const { stdout } = await execAsync('git worktree list', {
+            cwd: rootDir,
+        });
+        const parsed = parseWorktreeOutput(stdout);
+        // Get repository name from path
+        const repositoryPath = path_1.default.resolve(rootDir);
+        const repositoryName = path_1.default.basename(repositoryPath);
+        // Filter and validate worktree paths
+        return parsed
+            .map((wt) => ({
+            id: generateWorktreeId(wt.branch, repositoryName),
+            name: wt.branch,
+            path: path_1.default.resolve(wt.path),
+            repositoryPath,
+            repositoryName,
+        }))
+            .filter((wt) => {
+            // Git worktrees can be outside the repo root, so we use a more lenient validation
+            // Only filter out obviously dangerous system paths
+            const dangerousPaths = ['/etc', '/root', '/sys', '/proc', '/dev', '/boot', '/bin', '/sbin', '/usr/bin', '/usr/sbin'];
+            const isDangerous = dangerousPaths.some(danger => wt.path.startsWith(danger));
+            if (isDangerous) {
+                console.warn(`Skipping potentially unsafe worktree path: ${wt.path}`);
+                return false;
+            }
+            // Check for path traversal attempts in the path itself
+            if (wt.path.includes('\x00') || wt.path.includes('..')) {
+                console.warn(`Skipping path with potentially malicious characters: ${wt.path}`);
+                return false;
+            }
+            return true;
+        });
+    }
+    catch (error) {
+        // If not a git repository, return empty array
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorCode = error.code;
+        if (errorMessage?.includes('not a git repository') ||
+            errorCode === 128) {
+            return [];
+        }
+        // Re-throw other errors
+        throw error;
+    }
+}
+/**
+ * Scan git worktrees in multiple repositories
+ *
+ * @param repositoryPaths - Array of repository root paths
+ * @returns Array of all Worktree objects from all repositories
+ *
+ * @example
+ * ```typescript
+ * const repos = ['/path/to/repo1', '/path/to/repo2'];
+ * const worktrees = await scanMultipleRepositories(repos);
+ * ```
+ */
+async function scanMultipleRepositories(repositoryPaths) {
+    const allWorktrees = [];
+    for (const repoPath of repositoryPaths) {
+        try {
+            console.log(`Scanning repository: ${repoPath}`);
+            const worktrees = await scanWorktrees(repoPath);
+            allWorktrees.push(...worktrees);
+            console.log(`  Found ${worktrees.length} worktree(s)`);
+        }
+        catch (_error) {
+            console.error(`Error scanning repository ${repoPath}:`, _error);
+            // Continue with other repositories even if one fails
+        }
+    }
+    return allWorktrees;
+}
+/**
+ * Sync scanned worktrees to database
+ *
+ * @param db - Database instance
+ * @param worktrees - Array of worktrees to sync
+ *
+ * @example
+ * ```typescript
+ * const worktrees = await scanWorktrees('/path/to/repo');
+ * syncWorktreesToDB(db, worktrees);
+ * ```
+ */
+function syncWorktreesToDB(db, worktrees) {
+    for (const worktree of worktrees) {
+        (0, db_1.upsertWorktree)(db, worktree);
+    }
+}