@quantiya/codevibe-claude-plugin 1.0.0

package/dist/server.js

@@ -0,0 +1,1154 @@
+"use strict";
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const logger_1 = require("./logger");
+// Import shared modules from codevibe-core
+const codevibe_core_1 = require("@quantiya/codevibe-core");
+// Import plugin-specific modules
+const http_api_1 = require("./http-api");
+const command_executor_1 = require("./command-executor");
+const prompt_responder_1 = require("./prompt-responder");
+class McpServer {
+    constructor(sessionId) {
+        this.activeSessions = new Map();
+        this.assignedPort = 0;
+        this.sessionKey = null; // E2E encryption session key
+        // Map Claude Code session IDs to backend session IDs (claude-{uuid} format)
+        this.claudeToBackendSessionId = new Map();
+        // Track prompts sent from mobile to avoid duplicate USER_PROMPT events
+        // When mobile sends a prompt, it gets typed into terminal which triggers UserPromptSubmit hook
+        // We track with timestamp and expire after 3 seconds to avoid false positives
+        this.pendingMobilePrompts = new Map();
+        this.httpApi = new http_api_1.HttpApi();
+        // AppSyncClient is created in start() after config is loaded with correct environment
+        this.commandExecutor = new command_executor_1.CommandExecutor();
+        this.promptResponder = new prompt_responder_1.PromptResponder();
+        this.initialSessionId = sessionId;
+    }
+    /**
+     * Get the port the server is listening on
+     */
+    getPort() {
+        return this.assignedPort;
+    }
+    /**
+     * Generate backend session ID from Claude Code session ID.
+     * Format: claude-{claudeSessionId}
+     */
+    generateBackendSessionId(claudeSessionId) {
+        return `claude-${claudeSessionId}`;
+    }
+    /**
+     * Track a mobile prompt to filter out the duplicate USER_PROMPT from desktop hook
+     */
+    trackMobilePrompt(sessionId, prompt) {
+        if (!this.pendingMobilePrompts.has(sessionId)) {
+            this.pendingMobilePrompts.set(sessionId, []);
+        }
+        this.pendingMobilePrompts.get(sessionId).push({
+            prompt: prompt.trim(),
+            timestamp: Date.now(),
+        });
+        logger_1.logger.debug('Tracking mobile prompt for deduplication', { sessionId, promptLength: prompt.length });
+    }
+    /**
+     * Check if a prompt was recently sent from mobile (within expiry window)
+     * Returns true and removes the entry if found
+     */
+    isRecentMobilePrompt(sessionId, prompt) {
+        const prompts = this.pendingMobilePrompts.get(sessionId);
+        if (!prompts)
+            return false;
+        const now = Date.now();
+        const trimmedPrompt = prompt.trim();
+        // Clean up expired entries and check for match
+        const validPrompts = [];
+        let found = false;
+        for (const entry of prompts) {
+            if (now - entry.timestamp > McpServer.MOBILE_PROMPT_EXPIRY_MS) {
+                // Expired, skip
+                continue;
+            }
+            if (!found && entry.prompt === trimmedPrompt) {
+                // Found match, mark as found but don't add to validPrompts (consume it)
+                found = true;
+                logger_1.logger.debug('Found matching mobile prompt, filtering duplicate', { sessionId });
+                continue;
+            }
+            validPrompts.push(entry);
+        }
+        // Update the list with remaining valid prompts
+        if (validPrompts.length > 0) {
+            this.pendingMobilePrompts.set(sessionId, validPrompts);
+        }
+        else {
+            this.pendingMobilePrompts.delete(sessionId);
+        }
+        return found;
+    }
+    /**
+     * Write port file for a session so hooks can discover the server port
+     */
+    writePortFile(sessionId) {
+        const portFilePath = path.join(os.tmpdir(), `codevibe-claude-${sessionId}.port`);
+        try {
+            fs.writeFileSync(portFilePath, this.assignedPort.toString());
+            logger_1.logger.info(`Port file written: ${portFilePath} -> ${this.assignedPort}`);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to write port file: ${portFilePath}`, error);
+        }
+    }
+    /**
+     * Remove port file for a session
+     */
+    removePortFile(sessionId) {
+        const portFilePath = path.join(os.tmpdir(), `codevibe-claude-${sessionId}.port`);
+        try {
+            if (fs.existsSync(portFilePath)) {
+                fs.unlinkSync(portFilePath);
+                logger_1.logger.info(`Port file removed: ${portFilePath}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to remove port file: ${portFilePath}`, error);
+        }
+    }
+    async start() {
+        try {
+            logger_1.logger.info('Starting CodeVibe MCP Server...', {
+                environment: (0, codevibe_core_1.getEnvironment)(),
+            });
+            // Create AppSyncClient (auto-configures from ENVIRONMENT env var)
+            this.appSyncClient = new codevibe_core_1.AppSyncClient();
+            // Authenticate using stored OAuth tokens (from 'codevibe-claude login')
+            const storedTokensAuth = await this.appSyncClient.authenticateWithStoredTokens();
+            if (storedTokensAuth) {
+                logger_1.logger.info('Authenticated with stored OAuth tokens', {
+                    userId: this.appSyncClient.getCurrentUserId(),
+                    email: this.appSyncClient.getCurrentUserEmail(),
+                });
+                // Register device encryption key for E2E encryption
+                await this.registerDeviceEncryptionKey();
+            }
+            else {
+                logger_1.logger.error('Authentication failed. Run "codevibe-claude login" first.');
+                console.error('Not authenticated. Run "codevibe-claude login" to sign in.');
+                process.exit(1);
+            }
+            // Register event handlers
+            this.httpApi.onEvent(this.handleEventFromHook.bind(this));
+            // Start HTTP API with dynamic port allocation
+            // Pass session ID if provided at startup
+            this.assignedPort = await this.httpApi.start(this.initialSessionId);
+            logger_1.logger.info('MCP Server started successfully', {
+                port: this.assignedPort,
+                host: (0, codevibe_core_1.getConfig)().server.host,
+                dynamicPort: (0, codevibe_core_1.getConfig)().server.dynamicPort,
+                sessionId: this.initialSessionId,
+                authenticated: this.appSyncClient.isAuthenticated(),
+                userId: this.appSyncClient.getCurrentUserId(),
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to start MCP Server:', error);
+            throw error;
+        }
+    }
+    async stop() {
+        logger_1.logger.info('Stopping MCP Server...');
+        // Mark all active sessions as INACTIVE before shutting down
+        const sessionIds = Array.from(this.activeSessions.keys());
+        logger_1.logger.info(`Marking ${sessionIds.length} active session(s) as INACTIVE...`);
+        for (const sessionId of sessionIds) {
+            try {
+                await this.appSyncClient.updateSession({
+                    sessionId,
+                    status: codevibe_core_1.SessionStatus.INACTIVE,
+                });
+                logger_1.logger.info('Session marked as INACTIVE during shutdown', { sessionId });
+                // Remove port file using raw Claude session ID
+                const state = this.activeSessions.get(sessionId);
+                if (state) {
+                    this.removePortFile(state.claudeSessionId);
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn('Failed to mark session as INACTIVE during shutdown', { sessionId, error });
+            }
+        }
+        // Cleanup subscriptions
+        this.appSyncClient.cleanupSubscriptions();
+        // Clear active sessions
+        this.activeSessions.clear();
+        // Stop HTTP API
+        await this.httpApi.stop();
+        logger_1.logger.info('MCP Server stopped');
+    }
+    /**
+     * Handle events received from hook scripts via HTTP API
+     */
+    async handleEventFromHook(payload) {
+        const { session_id, hook_event_name, type, content } = payload;
+        logger_1.logger.info('Processing hook event', {
+            sessionId: session_id,
+            hookEvent: hook_event_name,
+            type,
+        });
+        try {
+            // Handle session lifecycle events
+            if (hook_event_name === 'SessionStart') {
+                await this.handleSessionStart(payload);
+            }
+            else if (hook_event_name === 'SessionEnd') {
+                await this.handleSessionEnd(payload);
+            }
+            // Resolve backend session ID (claude-{uuid} format)
+            const backendSessionId = this.claudeToBackendSessionId.get(session_id)
+                || this.generateBackendSessionId(session_id);
+            // Skip USER_PROMPT events that originated from mobile
+            // When mobile sends a prompt via tmux, it triggers UserPromptSubmit hook
+            // This creates a duplicate since mobile already created the event
+            if (type === codevibe_core_1.EventType.USER_PROMPT &&
+                payload.source === codevibe_core_1.EventSource.DESKTOP &&
+                hook_event_name === 'UserPromptSubmit' &&
+                content &&
+                this.isRecentMobilePrompt(backendSessionId, content)) {
+                logger_1.logger.info('Skipping duplicate USER_PROMPT from mobile-originated prompt', {
+                    sessionId: backendSessionId,
+                    contentLength: content.length,
+                });
+                return; // Don't send to AppSync
+            }
+            // Intercept INTERACTIVE_PROMPT — handle async with tmux snapshot parsing
+            if (type === codevibe_core_1.EventType.INTERACTIVE_PROMPT) {
+                const sessionState = this.activeSessions.get(backendSessionId);
+                if (sessionState) {
+                    sessionState.waitingForPromptResponse = true;
+                    sessionState.pendingPromptId = payload.prompt_id;
+                    logger_1.logger.info('Interactive prompt detected - will parse options from tmux', {
+                        sessionId: backendSessionId,
+                        promptId: payload.prompt_id,
+                    });
+                }
+                // Fire async — capture tmux after prompt renders, then send to AppSync
+                this.sendInteractivePromptAsync(backendSessionId, payload, content).catch(e => {
+                    logger_1.logger.error('Failed to send interactive prompt with dynamic options', { error: e });
+                });
+                return; // Don't create AppSync event here — async handler will do it
+            }
+            // Encrypt event content if we have a session key
+            let eventContent = content;
+            let eventMetadata = payload.metadata;
+            let isEncrypted = false;
+            // DEBUG: Log session key state for hook events
+            logger_1.logger.info('Hook event encryption state', {
+                type,
+                sessionId: backendSessionId,
+                hasSessionKey: !!this.sessionKey,
+                sessionKeyLength: this.sessionKey?.length || 0,
+            });
+            if (this.sessionKey) {
+                eventContent = codevibe_core_1.cryptoService.encryptContent(content, this.sessionKey);
+                if (eventMetadata) {
+                    const encryptedMeta = codevibe_core_1.cryptoService.encryptMetadata(eventMetadata, this.sessionKey);
+                    eventMetadata = { encrypted: encryptedMeta };
+                }
+                isEncrypted = true;
+                logger_1.logger.info('Event encrypted for hook', { type, sessionId: backendSessionId, isEncrypted: true });
+            }
+            else {
+                logger_1.logger.warn('No session key - event will NOT be encrypted', { type, sessionId: backendSessionId });
+            }
+            // Send event to AppSync
+            const event = await this.appSyncClient.createEvent({
+                sessionId: backendSessionId,
+                type,
+                source: payload.source,
+                content: eventContent,
+                metadata: eventMetadata,
+                promptId: payload.prompt_id,
+                isEncrypted: isEncrypted ? true : undefined,
+            });
+            // Clear waiting state when user sends new prompt from desktop
+            // (means they answered the prompt locally or moved on)
+            if (type === codevibe_core_1.EventType.USER_PROMPT && payload.source === codevibe_core_1.EventSource.DESKTOP) {
+                const sessionState = this.activeSessions.get(backendSessionId);
+                if (sessionState?.waitingForPromptResponse) {
+                    sessionState.waitingForPromptResponse = false;
+                    sessionState.pendingPromptId = undefined;
+                    sessionState.pendingSubmitMap = undefined;
+                    logger_1.logger.info('Clearing prompt wait state - new desktop prompt received', {
+                        sessionId: backendSessionId,
+                    });
+                }
+            }
+            logger_1.logger.debug('Event sent to AppSync successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to process hook event:', error);
+            throw error;
+        }
+    }
+    /**
+     * Handle SessionStart hook event
+     *
+     * Handles both new sessions and /resume:
+     * - If session exists in backend → reactivate it (same session ID)
+     * - If session doesn't exist → create new one with that session ID
+     */
+    async handleSessionStart(payload) {
+        const claudeSessionId = payload.session_id;
+        const sessionId = this.generateBackendSessionId(claudeSessionId);
+        const cwd = payload.metadata?.cwd || process.cwd();
+        // Cache the Claude → backend session ID mapping
+        this.claudeToBackendSessionId.set(claudeSessionId, sessionId);
+        logger_1.logger.info('Session started', { claudeSessionId, sessionId, cwd });
+        // If there are other sessions in memory, mark them as INACTIVE
+        // This happens when user does /resume - the first session should be marked INACTIVE
+        const previousSessionIds = Array.from(this.activeSessions.keys()).filter(id => id !== sessionId);
+        if (previousSessionIds.length > 0) {
+            logger_1.logger.info(`Marking ${previousSessionIds.length} previous session(s) as INACTIVE`);
+            for (const prevId of previousSessionIds) {
+                try {
+                    await this.appSyncClient.updateSession({
+                        sessionId: prevId,
+                        status: codevibe_core_1.SessionStatus.INACTIVE,
+                    });
+                    logger_1.logger.info('Previous session marked INACTIVE', { prevId, newSessionId: sessionId });
+                }
+                catch (error) {
+                    logger_1.logger.warn('Failed to mark previous session as INACTIVE', { prevId, error });
+                }
+                // Use raw Claude session ID for port file (hooks use raw IDs)
+                const prevState = this.activeSessions.get(prevId);
+                if (prevState) {
+                    this.removePortFile(prevState.claudeSessionId);
+                }
+                this.activeSessions.delete(prevId);
+            }
+        }
+        // Write port file using raw Claude session ID (hooks use raw IDs to discover port)
+        this.writePortFile(claudeSessionId);
+        // Create session state with authenticated user ID
+        const userId = this.appSyncClient.getCurrentUserId();
+        const sessionState = {
+            sessionId,
+            claudeSessionId,
+            userId,
+            projectPath: cwd,
+            cwd,
+            createdAt: new Date(),
+            subscriptionActive: false,
+            waitingForPromptResponse: false,
+            metadata: payload.metadata || {},
+        };
+        this.activeSessions.set(sessionId, sessionState);
+        // Use centralized resume/create utility from codevibe-core
+        try {
+            const result = await (0, codevibe_core_1.resumeOrCreateSession)({
+                sessionId,
+                userId: sessionState.userId,
+                agentType: codevibe_core_1.AgentType.CLAUDE,
+                projectPath: cwd,
+                metadata: payload.metadata || {},
+            }, this.appSyncClient, logger_1.logger);
+            this.sessionKey = result.sessionKey;
+            // Claude-specific: warn if resumed encrypted session but no key found
+            // (device key was regenerated after session was created)
+            if (result.resumed && !result.sessionKey) {
+                const pluginDeviceId = await codevibe_core_1.keychainManager.getDeviceId();
+                logger_1.logger.error('Device key not found in session encryptedKeys', { sessionId, pluginDeviceId });
+                console.error('\n⚠️  E2E ENCRYPTION WARNING: Cannot decrypt this session!');
+                console.error(`    Your device ID (${pluginDeviceId.substring(0, 8)}...) is not in session's encryption keys.`);
+                console.error('    This happens if your device key was regenerated after the session was created.');
+                console.error('    SOLUTION: Start a new Claude Code session instead of resuming this one.\n');
+            }
+        }
+        catch (error) {
+            // createSession errors propagate from resumeOrCreateSession
+            if (this.isSessionLimitExceeded(error)) {
+                this.displaySubscriptionLimitError(error, 'session');
+                this.activeSessions.delete(sessionId);
+                this.removePortFile(claudeSessionId);
+                return;
+            }
+            logger_1.logger.error('Failed to create/resume session:', error);
+        }
+        // Subscribe to mobile events for this session
+        this.subscribeToMobileEvents(sessionId);
+        // Start heartbeat so iOS can detect if desktop is still connected
+        this.appSyncClient.startHeartbeat(sessionId);
+    }
+    /**
+     * Handle SessionEnd hook event
+     */
+    async handleSessionEnd(payload) {
+        const claudeSessionId = payload.session_id;
+        const sessionId = this.claudeToBackendSessionId.get(claudeSessionId)
+            || this.generateBackendSessionId(claudeSessionId);
+        logger_1.logger.info('Session ended', {
+            claudeSessionId,
+            sessionId,
+            reason: payload.metadata?.reason,
+        });
+        // Remove port file using raw Claude session ID (hooks use raw IDs)
+        this.removePortFile(claudeSessionId);
+        // Clear any waiting prompt state before ending session
+        const sessionState = this.activeSessions.get(sessionId);
+        if (sessionState?.waitingForPromptResponse) {
+            logger_1.logger.info('Clearing prompt wait state - session ending', { sessionId });
+            sessionState.waitingForPromptResponse = false;
+            sessionState.pendingPromptId = undefined;
+        }
+        // Stop heartbeat
+        this.appSyncClient.stopHeartbeat(sessionId);
+        // Update session status in AppSync
+        if (sessionState) {
+            try {
+                await this.appSyncClient.updateSession({
+                    sessionId,
+                    status: codevibe_core_1.SessionStatus.INACTIVE,
+                });
+                logger_1.logger.info('Session marked as INACTIVE in AppSync', { sessionId });
+            }
+            catch (error) {
+                logger_1.logger.warn('Failed to update session in AppSync:', error);
+            }
+        }
+        else {
+            logger_1.logger.warn('Cannot update session - session state not found', { sessionId });
+        }
+        // Remove from active sessions and ID mapping
+        this.activeSessions.delete(sessionId);
+        this.claudeToBackendSessionId.delete(claudeSessionId);
+        logger_1.logger.debug('Session cleanup completed', { sessionId });
+    }
+    /**
+     * Register device encryption key with backend for E2E encryption
+     * This ensures the current device's public key is known to the backend
+     * so session keys can be encrypted for this device
+     */
+    async registerDeviceEncryptionKey() {
+        try {
+            // Get or generate device key pair (async keychain access)
+            const deviceId = await codevibe_core_1.keychainManager.getDeviceId();
+            const publicKey = await codevibe_core_1.keychainManager.getDevicePublicKey();
+            const platform = codevibe_core_1.keychainManager.getDevicePlatform();
+            const deviceName = codevibe_core_1.keychainManager.getDeviceName();
+            logger_1.logger.info('Registering device encryption key', { deviceId, platform, deviceName });
+            // Register with backend (will update if deviceId already exists)
+            await this.appSyncClient.registerDeviceKey(deviceId, publicKey, platform, deviceName);
+            codevibe_core_1.keychainManager.setIsRegistered(true);
+            logger_1.logger.info('Device encryption key registered successfully', { deviceId });
+        }
+        catch (error) {
+            // Don't fail startup if registration fails - encryption is optional
+            logger_1.logger.warn('Failed to register device encryption key (E2E encryption may not work):', error);
+        }
+    }
+    /**
+     * Subscribe to mobile events for a session
+     */
+    subscribeToMobileEvents(sessionId) {
+        logger_1.logger.info('Subscribing to mobile events', { sessionId });
+        const sessionState = this.activeSessions.get(sessionId);
+        if (!sessionState) {
+            logger_1.logger.error('Session not found', { sessionId });
+            return;
+        }
+        this.appSyncClient.subscribeToEvents(sessionId, async (event) => {
+            logger_1.logger.info('Received mobile event', {
+                eventId: event.eventId,
+                type: event.type,
+                sessionId: event.sessionId,
+                isEncrypted: event.isEncrypted,
+            });
+            // Decrypt event content if encrypted
+            let decryptedContent = event.content || '';
+            if (event.isEncrypted && this.sessionKey) {
+                try {
+                    decryptedContent = codevibe_core_1.cryptoService.decryptContent(event.content, this.sessionKey);
+                    logger_1.logger.debug('Event decrypted successfully', { eventId: event.eventId });
+                }
+                catch (error) {
+                    logger_1.logger.error('Failed to decrypt event:', { eventId: event.eventId, error });
+                    // Fall back to original content (might not work, but better than nothing)
+                    decryptedContent = event.content;
+                }
+            }
+            // Create a modified event with decrypted content for processing
+            const processedEvent = { ...event, content: decryptedContent };
+            // Mark event as DELIVERED (MCP server received it) - double gray checkmark
+            try {
+                await this.appSyncClient.updateEventStatus({
+                    eventId: event.eventId,
+                    sessionId: event.sessionId,
+                    timestamp: event.timestamp,
+                    deliveryStatus: codevibe_core_1.DeliveryStatus.DELIVERED,
+                });
+                logger_1.logger.info('Event marked as DELIVERED', { eventId: event.eventId });
+            }
+            catch (error) {
+                logger_1.logger.warn('Failed to mark event as DELIVERED', { eventId: event.eventId, error });
+            }
+            // Handle different event types from mobile
+            if (event.type === codevibe_core_1.EventType.USER_PROMPT) {
+                const sessionState = this.activeSessions.get(sessionId);
+                // Check if session is waiting for prompt response
+                if (sessionState?.waitingForPromptResponse) {
+                    // Parse the input to determine action
+                    const content = decryptedContent.trim();
+                    const optionCount = sessionState.pendingSubmitMap
+                        ? Object.keys(sessionState.pendingSubmitMap).length
+                        : 3;
+                    const parsed = this.parseInteractivePromptInput(content, optionCount);
+                    logger_1.logger.info('Parsed interactive prompt input', {
+                        sessionId,
+                        content,
+                        parsed,
+                        hasSubmitMap: !!sessionState.pendingSubmitMap,
+                    });
+                    if (parsed.action === 'select_option') {
+                        // Translate via submitMap before sending to terminal
+                        const terminalInput = sessionState.pendingSubmitMap?.[parsed.option] || parsed.option;
+                        logger_1.logger.info('User selected option', { option: parsed.option, terminalInput });
+                        const success = await this.promptResponder.answerInteractivePrompt(sessionId, terminalInput);
+                        if (success) {
+                            await this.markEventExecuted(event);
+                            sessionState.waitingForPromptResponse = false;
+                            sessionState.pendingPromptId = undefined;
+                            sessionState.pendingSubmitMap = undefined;
+                            await this.appSyncClient.createEvent({
+                                sessionId,
+                                type: codevibe_core_1.EventType.NOTIFICATION,
+                                source: codevibe_core_1.EventSource.DESKTOP,
+                                content: `Selected option ${parsed.option}`,
+                                metadata: { promptAnswered: true },
+                            });
+                        }
+                        else {
+                            await this.sendPromptError(sessionId, 'Failed to select option');
+                        }
+                    }
+                    else if (parsed.action === 'option_with_followup') {
+                        // Translate option via submitMap, send it, then send follow-up text
+                        const terminalInput = sessionState.pendingSubmitMap?.[parsed.option] || parsed.option;
+                        logger_1.logger.info('User selected option with follow-up', {
+                            option: parsed.option,
+                            terminalInput,
+                            followUpText: parsed.followUpText,
+                        });
+                        const optionSuccess = await this.promptResponder.answerInteractivePrompt(sessionId, terminalInput);
+                        // Clear waiting state
+                        sessionState.waitingForPromptResponse = false;
+                        sessionState.pendingPromptId = undefined;
+                        sessionState.pendingSubmitMap = undefined;
+                        if (optionSuccess) {
+                            await this.appSyncClient.createEvent({
+                                sessionId,
+                                type: codevibe_core_1.EventType.NOTIFICATION,
+                                source: codevibe_core_1.EventSource.DESKTOP,
+                                content: `Selected option ${parsed.option}`,
+                                metadata: { promptAnswered: true },
+                            });
+                            // If there's follow-up text, send it after a short delay
+                            if (parsed.followUpText) {
+                                // Wait for Claude to process the option selection
+                                await new Promise(resolve => setTimeout(resolve, 1000));
+                                // Send the follow-up text as a new prompt
+                                const modifiedEvent = { ...event, content: parsed.followUpText };
+                                await this.executeMobilePrompt(sessionId, modifiedEvent);
+                            }
+                            await this.markEventExecuted(event);
+                        }
+                        else {
+                            await this.sendPromptError(sessionId, 'Failed to select option');
+                        }
+                    }
+                    else {
+                        // 'send_as_response' - send content as-is to interactive prompt
+                        logger_1.logger.info('Sending as free-form response to interactive prompt', {
+                            response: content,
+                        });
+                        const success = await this.promptResponder.answerInteractivePrompt(sessionId, content);
+                        if (success) {
+                            await this.markEventExecuted(event);
+                            sessionState.waitingForPromptResponse = false;
+                            sessionState.pendingPromptId = undefined;
+                            sessionState.pendingSubmitMap = undefined;
+                            await this.appSyncClient.createEvent({
+                                sessionId,
+                                type: codevibe_core_1.EventType.NOTIFICATION,
+                                source: codevibe_core_1.EventSource.DESKTOP,
+                                content: `Response sent to interactive prompt`,
+                                metadata: { promptAnswered: true },
+                            });
+                        }
+                        else {
+                            await this.sendPromptError(sessionId, 'Failed to send response');
+                        }
+                    }
+                }
+                else {
+                    // No interactive prompt waiting - execute as regular prompt
+                    await this.executeMobilePrompt(sessionId, processedEvent);
+                }
+            }
+        }, (error) => {
+            logger_1.logger.error('Subscription error', { sessionId, error });
+            // TODO: Implement reconnection logic
+        });
+        sessionState.subscriptionActive = true;
+        logger_1.logger.info('Subscription active', { sessionId });
+    }
+    /**
+     * Send INTERACTIVE_PROMPT to AppSync after capturing dynamic options from tmux.
+     * Waits 500ms for Claude Code to render the prompt, then captures the terminal.
+     */
+    async sendInteractivePromptAsync(backendSessionId, payload, content) {
+        // Wait for hook to return and Claude Code to render the prompt
+        await new Promise(resolve => setTimeout(resolve, 500));
+        const tmuxSession = process.env.CODEVIBE_TMUX_SESSION;
+        const metadata = { ...(payload.metadata || {}) };
+        if (tmuxSession) {
+            try {
+                const { exec } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                const execAsync = (cmd) => new Promise((resolve, reject) => {
+                    exec(cmd, { timeout: 5000 }, (err, stdout) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve({ stdout: stdout || '' });
+                    });
+                });
+                const { stdout } = await execAsync(`tmux capture-pane -p -e -S -30 -t '${tmuxSession}'`);
+                // Log captured snapshot for debugging
+                const snapshotLines = stdout.split('\n');
+                logger_1.logger.info('tmux capture result', {
+                    tmuxSession,
+                    totalLines: snapshotLines.length,
+                    lastLines: snapshotLines.slice(-15).map(l => l.replace(/\x1B[^m]*m/g, '').trim()).filter(Boolean),
+                });
+                const parsed = (0, codevibe_core_1.parseInteractivePrompt)(stdout);
+                if (parsed && parsed.options.length > 0) {
+                    metadata.options = parsed.options;
+                    metadata.submitMap = parsed.submitMap;
+                    metadata.instructions = this.buildPromptInstructions(parsed);
+                    logger_1.logger.info('Parsed dynamic options from tmux', {
+                        optionCount: parsed.options.length,
+                        kind: parsed.kind,
+                        options: parsed.options,
+                    });
+                }
+                else {
+                    logger_1.logger.info('No dynamic options parsed from tmux, using fallback', {
+                        parsedResult: parsed,
+                    });
+                    this.addFallbackOptions(metadata);
+                }
+            }
+            catch (e) {
+                logger_1.logger.warn('Failed to capture tmux pane for options', { error: e });
+                this.addFallbackOptions(metadata);
+            }
+        }
+        else {
+            logger_1.logger.warn('No tmux session — using fallback options');
+            this.addFallbackOptions(metadata);
+        }
+        // Store submitMap in session state for response translation
+        const sessionState = this.activeSessions.get(backendSessionId);
+        if (sessionState && metadata.submitMap) {
+            sessionState.pendingSubmitMap = metadata.submitMap;
+        }
+        // Encrypt and send to AppSync
+        let eventContent = content;
+        let eventMetadata = metadata;
+        let isEncrypted = false;
+        if (this.sessionKey) {
+            eventContent = codevibe_core_1.cryptoService.encryptContent(content, this.sessionKey);
+            const encryptedMeta = codevibe_core_1.cryptoService.encryptMetadata(eventMetadata, this.sessionKey);
+            eventMetadata = { encrypted: encryptedMeta };
+            isEncrypted = true;
+        }
+        await this.appSyncClient.createEvent({
+            sessionId: backendSessionId,
+            type: codevibe_core_1.EventType.INTERACTIVE_PROMPT,
+            source: payload.source,
+            content: eventContent,
+            metadata: eventMetadata,
+            promptId: payload.prompt_id,
+            isEncrypted: isEncrypted ? true : undefined,
+        });
+        logger_1.logger.info('Interactive prompt sent to AppSync with dynamic options', {
+            sessionId: backendSessionId,
+        });
+    }
+    addFallbackOptions(metadata) {
+        metadata.options = [
+            { number: '1', text: 'Yes' },
+            { number: '2', text: 'Yes, and don\'t ask again' },
+            { number: '3', text: 'Reject and tell Claude what to do differently' },
+        ];
+        metadata.submitMap = { '1': '1', '2': '2', '3': '3' };
+        metadata.instructions = 'Reply with 1, 2, or 3. Append a message to provide alternative instructions.';
+    }
+    buildPromptInstructions(parsed) {
+        const nums = parsed.options.map(o => o.number).join(', ');
+        return `Reply with ${nums}. Append a message to provide alternative instructions.`;
+    }
+    /**
+     * Parse mobile input when an interactive prompt is waiting.
+     * Dynamically supports any number of options (not hardcoded to 3).
+     *
+     * Input patterns:
+     * - "N" (exact number) → select that option
+     * - "N <text>" → select option N, then send <text> as follow-up prompt
+     * - anything else → send as free-form response
+     */
+    parseInteractivePromptInput(content, optionCount = 3) {
+        const trimmed = content.trim();
+        // Check for exact option number (e.g., "1", "2", "3")
+        const exactMatch = trimmed.match(/^(\d+)$/);
+        if (exactMatch) {
+            const num = parseInt(exactMatch[1]);
+            if (num >= 1 && num <= optionCount) {
+                return { action: 'select_option', option: exactMatch[1] };
+            }
+        }
+        // Check for "N <text>" or "N\n<text>" pattern (option + follow-up)
+        const withTextMatch = trimmed.match(/^(\d+)[\s\n]+(.+)$/s);
+        if (withTextMatch) {
+            const num = parseInt(withTextMatch[1]);
+            if (num >= 1 && num <= optionCount) {
+                return { action: 'option_with_followup', option: withTextMatch[1], followUpText: withTextMatch[2].trim() };
+            }
+        }
+        // Anything else — send as free-form response
+        return { action: 'send_as_response' };
+    }
+    /**
+     * Helper to mark an event as EXECUTED
+     */
+    async markEventExecuted(event) {
+        try {
+            await this.appSyncClient.updateEventStatus({
+                eventId: event.eventId,
+                sessionId: event.sessionId,
+                timestamp: event.timestamp,
+                deliveryStatus: codevibe_core_1.DeliveryStatus.EXECUTED,
+            });
+            logger_1.logger.info('Event marked as EXECUTED', { eventId: event.eventId });
+        }
+        catch (error) {
+            logger_1.logger.warn('Failed to mark event as EXECUTED', { eventId: event.eventId, error });
+        }
+    }
+    /**
+     * Helper to send error notification to mobile
+     */
+    async sendPromptError(sessionId, message) {
+        await this.appSyncClient.createEvent({
+            sessionId,
+            type: codevibe_core_1.EventType.NOTIFICATION,
+            source: codevibe_core_1.EventSource.DESKTOP,
+            content: message,
+            metadata: { error: true },
+        });
+    }
+    /**
+     * Check if error is a subscription limit exceeded error
+     */
+    isSessionLimitExceeded(error) {
+        const errorMessage = this.getErrorMessage(error);
+        return errorMessage.includes('SESSION_LIMIT_EXCEEDED');
+    }
+    /**
+     * Check if error is a usage limit exceeded error (message or image)
+     */
+    isUsageLimitExceeded(error) {
+        const errorMessage = this.getErrorMessage(error);
+        return errorMessage.includes('MESSAGE_LIMIT_EXCEEDED') || errorMessage.includes('IMAGE_LIMIT_EXCEEDED');
+    }
+    /**
+     * Extract error message from various error types
+     */
+    getErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'object' && error !== null) {
+            const errorObj = error;
+            // Check for GraphQL error format
+            if (errorObj.errors && Array.isArray(errorObj.errors)) {
+                return errorObj.errors.map((e) => e.message || '').join(' ');
+            }
+            // Check for message property
+            if (typeof errorObj.message === 'string') {
+                return errorObj.message;
+            }
+        }
+        return String(error);
+    }
+    /**
+     * Display subscription limit error to user
+     */
+    displaySubscriptionLimitError(error, limitType) {
+        const errorMessage = this.getErrorMessage(error);
+        // Extract tier and limit info from error message if available
+        let tierInfo = '';
+        const tierMatch = errorMessage.match(/for your (\w+) plan/i);
+        if (tierMatch) {
+            tierInfo = ` (${tierMatch[1]} tier)`;
+        }
+        let limitInfo = '';
+        const limitMatch = errorMessage.match(/of (\d+)/);
+        if (limitMatch) {
+            limitInfo = ` [Limit: ${limitMatch[1]}]`;
+        }
+        // Display user-friendly console message with formatting
+        console.log('\n' + '='.repeat(60));
+        console.log('⚠️  SUBSCRIPTION LIMIT REACHED');
+        console.log('='.repeat(60));
+        switch (limitType) {
+            case 'session':
+                console.log(`You have reached the maximum number of active sessions${tierInfo}.`);
+                console.log(`${limitInfo}`);
+                console.log('\nTo continue, please:');
+                console.log('  • Close an existing Claude Code session, or');
+                console.log('  • Upgrade your subscription in the CodeVibe iOS app');
+                break;
+            case 'message':
+                console.log(`You have reached your monthly message limit${tierInfo}.`);
+                console.log(`${limitInfo}`);
+                console.log('\nTo continue, please:');
+                console.log('  • Wait until your usage resets next month, or');
+                console.log('  • Upgrade your subscription in the CodeVibe iOS app');
+                break;
+            case 'image':
+                console.log(`You have reached your monthly image attachment limit${tierInfo}.`);
+                console.log(`${limitInfo}`);
+                console.log('\nTo continue, please:');
+                console.log('  • Wait until your usage resets next month, or');
+                console.log('  • Upgrade your subscription in the CodeVibe iOS app');
+                break;
+        }
+        console.log('\nNote: You can still use Claude Code normally from your desktop.');
+        console.log('This limit only affects syncing with the mobile app.');
+        console.log('='.repeat(60) + '\n');
+        logger_1.logger.error('Subscription limit exceeded', { limitType, errorMessage });
+    }
+    /**
+     * Download an attachment from S3 and save it to a temp file
+     * If the attachment is encrypted, decrypts it using the session key
+     * Returns the local file path
+     * @param attachment The attachment to download
+     * @param sessionId The session ID for organizing temp files
+     * @param eventIsEncrypted Whether the parent event is encrypted (fallback for attachment.isEncrypted)
+     */
+    async downloadAttachment(attachment, sessionId, eventIsEncrypted) {
+        try {
+            // Use attachment.isEncrypted if available, otherwise fall back to event.isEncrypted
+            // This handles AppSync subscription limitation where nested object fields may be null
+            const shouldDecrypt = attachment.isEncrypted ?? eventIsEncrypted ?? false;
+            logger_1.logger.info('Downloading attachment - START', {
+                id: attachment.id,
+                type: attachment.type,
+                filename: attachment.filename,
+                s3Key: attachment.s3Key,
+                attachmentIsEncrypted: attachment.isEncrypted,
+                eventIsEncrypted,
+                shouldDecrypt,
+                hasSessionKey: !!this.sessionKey,
+            });
+            // Get pre-signed download URL
+            const { downloadUrl } = await this.appSyncClient.getAttachmentDownloadUrl(attachment.s3Key);
+            // Download the file
+            const response = await fetch(downloadUrl);
+            if (!response.ok) {
+                throw new Error(`Failed to download attachment: ${response.status} ${response.statusText}`);
+            }
+            let buffer = Buffer.from(await response.arrayBuffer());
+            logger_1.logger.info('Attachment downloaded', {
+                id: attachment.id,
+                downloadedSize: buffer.length,
+                first20Bytes: buffer.slice(0, 20).toString('hex'),
+            });
+            // Decrypt if encrypted
+            logger_1.logger.info('Checking decryption conditions', {
+                id: attachment.id,
+                shouldDecrypt,
+                hasSessionKey: !!this.sessionKey,
+                willDecrypt: !!(shouldDecrypt && this.sessionKey),
+            });
+            if (shouldDecrypt && this.sessionKey) {
+                try {
+                    logger_1.logger.info('Decrypting attachment', { id: attachment.id, encryptedSize: buffer.length });
+                    buffer = codevibe_core_1.cryptoService.decryptData(buffer, this.sessionKey);
+                    logger_1.logger.info('Attachment decrypted successfully', {
+                        id: attachment.id,
+                        decryptedSize: buffer.length,
+                        first20Bytes: buffer.slice(0, 20).toString('hex'),
+                    });
+                }
+                catch (decryptError) {
+                    logger_1.logger.error('Failed to decrypt attachment:', { id: attachment.id, error: decryptError });
+                    throw new Error('Failed to decrypt attachment');
+                }
+            }
+            else if (shouldDecrypt && !this.sessionKey) {
+                logger_1.logger.warn('Cannot decrypt attachment - no session key available', { id: attachment.id });
+                // Continue with encrypted data - Claude Code won't be able to view it properly
+            }
+            else {
+                logger_1.logger.info('Skipping decryption - attachment not encrypted or no session key', {
+                    id: attachment.id,
+                    shouldDecrypt,
+                    hasSessionKey: !!this.sessionKey,
+                });
+            }
+            // Create temp directory for this session if it doesn't exist
+            const tempDir = path.join(os.tmpdir(), 'codevibe-claude', sessionId);
+            if (!fs.existsSync(tempDir)) {
+                fs.mkdirSync(tempDir, { recursive: true });
+            }
+            // Determine file extension from MIME type or filename
+            let extension = '';
+            // If filename is encrypted, decrypt it
+            let actualFilename = attachment.filename;
+            if (shouldDecrypt && attachment.filename && this.sessionKey) {
+                try {
+                    actualFilename = codevibe_core_1.cryptoService.decryptContent(attachment.filename, this.sessionKey);
+                }
+                catch {
+                    // Filename decryption failed, use as-is (might be plaintext)
+                    actualFilename = attachment.filename;
+                }
+            }
+            if (actualFilename) {
+                const ext = path.extname(actualFilename);
+                if (ext)
+                    extension = ext;
+            }
+            if (!extension) {
+                // Fallback to MIME type
+                const mimeToExt = {
+                    'image/jpeg': '.jpg',
+                    'image/png': '.png',
+                    'image/gif': '.gif',
+                    'image/webp': '.webp',
+                    'image/heic': '.heic',
+                    'application/pdf': '.pdf',
+                };
+                extension = mimeToExt[attachment.type] || '.bin';
+            }
+            // Save to temp file
+            const filename = `attachment-${attachment.id}${extension}`;
+            const filePath = path.join(tempDir, filename);
+            fs.writeFileSync(filePath, buffer);
+            logger_1.logger.info('Attachment saved to temp file', {
+                id: attachment.id,
+                filePath,
+                size: buffer.length,
+                wasDecrypted: shouldDecrypt && !!this.sessionKey,
+            });
+            return filePath;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to download attachment:', { id: attachment.id, error });
+            return null;
+        }
+    }
+    /**
+     * Execute a prompt from mobile in the desktop Claude Code session
+     * Uses tmux send-keys to send the prompt to the Claude Code session
+     * If the event has attachments, downloads them and includes file paths in prompt
+     */
+    async executeMobilePrompt(sessionId, event) {
+        let prompt = event.content || '';
+        const attachments = event.attachments || [];
+        logger_1.logger.info('Executing mobile prompt via tmux', {
+            sessionId,
+            promptLength: prompt.length,
+            attachmentCount: attachments.length,
+        });
+        // Download attachments and build file paths to include in prompt
+        const attachmentPaths = [];
+        if (attachments.length > 0) {
+            logger_1.logger.info('Downloading attachments for prompt', { count: attachments.length });
+            for (const attachment of attachments) {
+                const filePath = await this.downloadAttachment(attachment, sessionId, event.isEncrypted // Pass event encryption status as fallback
+                );
+                if (filePath) {
+                    attachmentPaths.push(filePath);
+                }
+            }
+            // If we have downloaded files, prepend them to the prompt
+            if (attachmentPaths.length > 0) {
+                const fileReferences = attachmentPaths
+                    .map(p => `[Attached file: ${p}]`)
+                    .join('\n');
+                // Format: file references first, then the user's message
+                if (prompt) {
+                    prompt = `${fileReferences}\n\n${prompt}`;
+                }
+                else {
+                    // No text content, just file references with instruction
+                    prompt = `${fileReferences}\n\nPlease analyze the attached file(s).`;
+                }
+                logger_1.logger.info('Prompt updated with attachment paths', {
+                    attachmentCount: attachmentPaths.length,
+                    newPromptLength: prompt.length,
+                });
+            }
+        }
+        // Track this prompt to filter out the duplicate USER_PROMPT from the hook
+        this.trackMobilePrompt(sessionId, prompt);
+        try {
+            // Use tmux send-keys to send the prompt (same as answering interactive prompts)
+            const success = await this.promptResponder.answerInteractivePrompt(sessionId, prompt);
+            if (success) {
+                // Mark event as EXECUTED (fed into Claude Code) - double blue checkmark
+                try {
+                    await this.appSyncClient.updateEventStatus({
+                        eventId: event.eventId,
+                        sessionId: event.sessionId,
+                        timestamp: event.timestamp,
+                        deliveryStatus: codevibe_core_1.DeliveryStatus.EXECUTED,
+                    });
+                    logger_1.logger.info('Event marked as EXECUTED', { eventId: event.eventId });
+                }
+                catch (error) {
+                    logger_1.logger.warn('Failed to mark event as EXECUTED', { eventId: event.eventId, error });
+                }
+                logger_1.logger.info('Mobile prompt sent successfully', { sessionId });
+                // Send confirmation to mobile
+                const confirmationMsg = attachmentPaths.length > 0
+                    ? `Prompt with ${attachmentPaths.length} attachment(s) sent to Claude Code`
+                    : `Prompt "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}" sent to Claude Code`;
+                await this.appSyncClient.createEvent({
+                    sessionId,
+                    type: codevibe_core_1.EventType.NOTIFICATION,
+                    source: codevibe_core_1.EventSource.DESKTOP,
+                    content: confirmationMsg,
+                    metadata: {
+                        mobilePrompt: true,
+                        attachmentCount: attachmentPaths.length,
+                    },
+                });
+            }
+            else {
+                logger_1.logger.error('Failed to send mobile prompt', { sessionId });
+                // Send error notification to mobile
+                await this.appSyncClient.createEvent({
+                    sessionId,
+                    type: codevibe_core_1.EventType.NOTIFICATION,
+                    source: codevibe_core_1.EventSource.DESKTOP,
+                    content: `Failed to send prompt to Claude Code`,
+                    metadata: {
+                        error: true,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to execute mobile prompt:', error);
+        }
+    }
+}
+McpServer.MOBILE_PROMPT_EXPIRY_MS = 3000; // 3 seconds
+// Main entry point
+async function main() {
+    // Get session ID from command line argument or environment variable
+    const sessionId = process.argv[2] || process.env.CLAUDE_SESSION_ID;
+    if (sessionId) {
+        logger_1.logger.info(`Starting MCP server for session: ${sessionId}`);
+    }
+    else {
+        logger_1.logger.info('Starting MCP server without initial session ID (will be set on SessionStart)');
+    }
+    const server = new McpServer(sessionId);
+    try {
+        await server.start();
+        // Output the assigned port for the session-start hook to capture
+        const port = server.getPort();
+        console.log(`PORT=${port}`);
+        // Handle graceful shutdown
+        let isShuttingDown = false;
+        const shutdown = async (signal) => {
+            if (isShuttingDown) {
+                logger_1.logger.info('Shutdown already in progress, ignoring additional signal');
+                return;
+            }
+            isShuttingDown = true;
+            logger_1.logger.info(`Received ${signal} signal, stopping server...`);
+            try {
+                await server.stop();
+                logger_1.logger.info('Graceful shutdown completed');
+                process.exit(0);
+            }
+            catch (error) {
+                logger_1.logger.error('Error during shutdown:', error);
+                process.exit(1);
+            }
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        process.on('SIGHUP', () => shutdown('SIGHUP'));
+        // Handle uncaught exceptions - try to cleanup before exit
+        process.on('uncaughtException', async (error) => {
+            logger_1.logger.error('Uncaught exception:', error);
+            await shutdown('uncaughtException');
+        });
+        process.on('unhandledRejection', async (reason) => {
+            logger_1.logger.error('Unhandled rejection:', reason);
+            await shutdown('unhandledRejection');
+        });
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to start MCP Server:', error);
+        process.exit(1);
+    }
+}
+// Start the server
+main().catch((error) => {
+    logger_1.logger.error('Unhandled error in main:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=server.js.map