commandmate 0.1.0 → 0.1.6

package/README.md

@@ -49,39 +49,43 @@ Claude Code での開発経験があり、本業の傍らで個人開発を続
 
 - macOS / Linux（tmux 依存のため Windows は非対応）
 - Node.js v20+、npm、git、tmux、openssl
-- Claude CLI（CLAUDE_HOOKS_STOP 対応）
+- Claude CLI（オプション）
 
-### CLIコマンドによるセットアップ（推奨）
+### インストール
 
 ```bash
-# グローバルインストール
 npm install -g commandmate
+```
 
-# 初期化（依存関係チェック、.env作成、DB初期化）
-commandmate init
+### セットアップと起動
 
-# サーバー起動
-commandmate start
+```bash
+commandmate init              # 依存チェック、環境設定、DB初期化
+commandmate start --daemon    # バックグラウンドで起動
 ```
 
 ブラウザで http://localhost:3000 にアクセスしてください。
 
-#### CLIコマンド一覧
+### CLI コマンド
 
 | コマンド | 説明 |
 |---------|------|
-| `commandmate --version` | バージョン表示 |
-| `commandmate init` | 初期化（対話形式で設定） |
-| `commandmate init --defaults` | デフォルト値で初期化（非対話） |
-| `commandmate start` | サーバー起動（フォアグラウンド） |
-| `commandmate start --dev` | 開発モードで起動 |
-| `commandmate start --daemon` | バックグラウンドで起動 |
+| `commandmate init` | 初期設定（対話形式） |
+| `commandmate init --defaults` | 初期設定（デフォルト値） |
+| `commandmate start --daemon` | バックグラウンド起動 |
+| `commandmate start -p 3001` | ポート指定で起動 |
 | `commandmate stop` | サーバー停止 |
-| `commandmate status` | サーバー状態確認 |
+| `commandmate status` | 状態確認 |
+
+詳しくは [CLI セットアップガイド](./docs/user-guide/cli-setup-guide.md) を参照してください。
+
+### モバイルからのアクセス
+
+`commandmate init` で外部アクセスを有効にすると、`CM_BIND=0.0.0.0` と `CM_AUTH_TOKEN` が自動設定されます。同一LAN内から `http://<PCのIP>:3000` にアクセスします。
 
-### シェルスクリプトによるセットアップ（レガシー）
+## 開発者向けセットアップ
 
-> **Note**: シェルスクリプトは非推奨です。CLIコマンドの使用を推奨します。
+コントリビューターや開発環境を構築する場合は、git clone を使用してください。
 
 ```bash
 git clone https://github.com/Kewton/CommandMate.git
@@ -102,7 +106,7 @@ npm run build
 npm start
 ```
 
-スマホから利用する場合は `commandmate init` または `./scripts/setup-env.sh` で外部アクセスを有効にすると、`CM_BIND=0.0.0.0` と `CM_AUTH_TOKEN` が自動設定されます。同一LAN内から `http://<PCのIP>:3000` にアクセスします。
+> **Note**: `./scripts/*` スクリプトは開発環境でのみ使用可能です。グローバルインストール（`npm install -g`）では `commandmate` CLI を使用してください。
 
 > **Note**: 旧名称の環境変数（`MCBD_*`）も後方互換性のためサポートされていますが、新名称（`CM_*`）の使用を推奨します。
 
@@ -130,13 +134,14 @@ A: 現時点では個人利用を想定しています。複数人での同時
 
 | ドキュメント | 説明 |
 |-------------|------|
+| [CLI セットアップガイド](./docs/user-guide/cli-setup-guide.md) | インストールと初期設定 |
+| [Webアプリ操作ガイド](./docs/user-guide/webapp-guide.md) | Webアプリの基本操作 |
+| [クイックスタート](./docs/user-guide/quick-start.md) | Claude Codeコマンドの使い方 |
 | [コンセプト](./docs/concept.md) | ビジョンと解決する課題 |
 | [アーキテクチャ](./docs/architecture.md) | システム設計 |
 | [デプロイガイド](./docs/DEPLOYMENT.md) | 本番環境構築手順 |
 | [移行ガイド](./docs/migration-to-commandmate.md) | MyCodeBranchDesk からの移行手順 |
 | [UI/UXガイド](./docs/UI_UX_GUIDE.md) | UI実装の詳細 |
-| [Webアプリ操作ガイド](./docs/user-guide/webapp-guide.md) | Webアプリの基本操作 |
-| [クイックスタート](./docs/user-guide/quick-start.md) | Claude Codeコマンドの使い方 |
 | [Trust & Safety](./docs/TRUST_AND_SAFETY.md) | セキュリティと権限の考え方 |
 
 ## Contributing

package/dist/cli/commands/start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/start.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,YAAY,EAAY,MAAM,UAAU,CAAC;AAQlD;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAoHvE"}
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/start.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,YAAY,EAAY,MAAM,UAAU,CAAC;AASlD;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAuHvE"}

package/dist/cli/commands/start.js

@@ -13,6 +13,7 @@ const types_1 = require("../types");
 const logger_1 = require("../utils/logger");
 const daemon_1 = require("../utils/daemon");
 const security_logger_1 = require("../utils/security-logger");
+const paths_1 = require("../utils/paths");
 const logger = new logger_1.CLILogger();
 const PID_FILE = (0, path_1.join)(process.cwd(), '.commandmate.pid');
 /**
@@ -77,8 +78,10 @@ async function startCommand(options) {
         if (options.port) {
             env.CM_PORT = String(options.port);
         }
+        // Use package installation directory, not current working directory
+        const packageRoot = (0, paths_1.getPackageRoot)();
         const child = (0, child_process_1.spawn)('npm', ['run', npmScript], {
-            cwd: process.cwd(),
+            cwd: packageRoot,
             env,
             stdio: 'inherit',
         });

package/dist/cli/utils/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/daemon.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGtD;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAa;gBAEnB,WAAW,EAAE,MAAM;IAI/B;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IA6CnD;;;;OAIG;IACG,IAAI,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IA8BpD;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IA6B/C;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAInC;;OAEG;YACW,WAAW;CAiB1B"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/daemon.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAItD;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAa;gBAEnB,WAAW,EAAE,MAAM;IAI/B;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IA8CnD;;;;OAIG;IACG,IAAI,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IA8BpD;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IA6B/C;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAInC;;OAEG;YACW,WAAW;CAiB1B"}

package/dist/cli/utils/daemon.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DaemonManager = void 0;
 const child_process_1 = require("child_process");
 const pid_manager_1 = require("./pid-manager");
+const paths_1 = require("./paths");
 /**
  * Daemon manager for background server process
  */
@@ -29,7 +30,8 @@ class DaemonManager {
         // Clean up stale PID file
         this.pidManager.removePid();
         const npmScript = options.dev ? 'dev' : 'start';
-        const cwd = process.cwd();
+        // Use package installation directory, not current working directory
+        const packageRoot = (0, paths_1.getPackageRoot)();
         // Build environment
         const env = { ...process.env };
         if (options.port) {
@@ -37,7 +39,7 @@ class DaemonManager {
         }
         // Spawn detached process
         const child = (0, child_process_1.spawn)('npm', ['run', npmScript], {
-            cwd,
+            cwd: packageRoot,
             env,
             detached: true,
             stdio: 'ignore',

package/dist/cli/utils/paths.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Path Utilities for CLI
+ * Issue #96: npm install CLI support
+ *
+ * Provides utilities to resolve package installation directory
+ * regardless of where the CLI is invoked from.
+ */
+/**
+ * Get the root directory of the CommandMate package installation.
+ *
+ * When installed globally via npm, the CLI runs from:
+ *   <global-modules>/commandmate/dist/cli/utils/paths.js
+ *
+ * This function returns the package root:
+ *   <global-modules>/commandmate/
+ *
+ * @returns Absolute path to the package root directory
+ */
+export declare function getPackageRoot(): string;
+/**
+ * Get the path to package.json
+ * @returns Absolute path to package.json
+ */
+export declare function getPackageJsonPath(): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/cli/utils/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/paths.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAIvC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C"}

package/dist/cli/utils/paths.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Path Utilities for CLI
+ * Issue #96: npm install CLI support
+ *
+ * Provides utilities to resolve package installation directory
+ * regardless of where the CLI is invoked from.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageRoot = getPackageRoot;
+exports.getPackageJsonPath = getPackageJsonPath;
+const path_1 = require("path");
+/**
+ * Get the root directory of the CommandMate package installation.
+ *
+ * When installed globally via npm, the CLI runs from:
+ *   <global-modules>/commandmate/dist/cli/utils/paths.js
+ *
+ * This function returns the package root:
+ *   <global-modules>/commandmate/
+ *
+ * @returns Absolute path to the package root directory
+ */
+function getPackageRoot() {
+    // __dirname points to dist/cli/utils when this file is compiled
+    // We need to go up 3 levels: utils → cli → dist → package root
+    return (0, path_1.join)(__dirname, '..', '..', '..');
+}
+/**
+ * Get the path to package.json
+ * @returns Absolute path to package.json
+ */
+function getPackageJsonPath() {
+    return (0, path_1.join)(getPackageRoot(), 'package.json');
+}

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);
+}