@quantiya/codevibe-gemini-plugin 1.0.0

package/dist/server.js

@@ -0,0 +1,1422 @@
+"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 crypto = __importStar(require("crypto"));
+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");
+// Import plugin-specific types
+const types_1 = require("./types");
+class McpServer {
+    constructor(sessionId, workingDirectory) {
+        this.activeSessions = new Map();
+        this.assignedPort = 0;
+        // Track prompts sent from mobile to avoid duplicate USER_PROMPT events
+        // When mobile sends a prompt, it gets typed into terminal and appears in BeforeAgent hook
+        // We track with timestamp and expire after 10 seconds
+        this.pendingMobilePrompts = new Map();
+        // Map Gemini's session ID to our generated backend session ID
+        this.geminiToBackendSessionId = new Map();
+        // Track pending interactive prompts from BeforeTool hooks waiting for mobile response
+        this.pendingInteractivePrompts = new Map();
+        this.sessionKey = null; // E2E encryption session key
+        // The backend session ID from the most recent SessionStart or session switch.
+        // When Gemini CLI resumes a session via /resume, hooks fire with the ORIGINAL
+        // session ID. This tracks the current active session for switch detection.
+        this.currentBackendSessionId = null;
+        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;
+        this.workingDirectory = workingDirectory || process.cwd();
+    }
+    /**
+     * Get the port the server is listening on
+     */
+    getPort() {
+        return this.assignedPort;
+    }
+    /**
+     * Generate a deterministic backend session ID for a Gemini session.
+     * Format: gemini-<hash of geminiSessionId>
+     *
+     * Deterministic IDs enable session resume: the same Gemini session always maps
+     * to the same backend session, allowing getSession() to find previously created sessions.
+     */
+    generateBackendSessionId(geminiSessionId) {
+        const hash = crypto.createHash('sha256')
+            .update(geminiSessionId)
+            .digest('hex').substring(0, 16);
+        return `gemini-${hash}`;
+    }
+    /**
+     * Get the backend session ID for a Gemini session ID
+     * Creates a new mapping if one doesn't exist
+     */
+    getBackendSessionId(geminiSessionId) {
+        let backendSessionId = this.geminiToBackendSessionId.get(geminiSessionId);
+        if (!backendSessionId) {
+            backendSessionId = this.generateBackendSessionId(geminiSessionId);
+            this.geminiToBackendSessionId.set(geminiSessionId, backendSessionId);
+            logger_1.logger.info('Generated backend session ID', {
+                geminiSessionId,
+                backendSessionId,
+            });
+        }
+        return backendSessionId;
+    }
+    /**
+     * 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-gemini-${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-gemini-${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 Gemini Companion 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-gemini 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(),
+                });
+            }
+            else {
+                logger_1.logger.error('Authentication failed. Run "codevibe-gemini login" first.');
+                console.error('Not authenticated. Run "codevibe-gemini login" to sign in.');
+                process.exit(1);
+            }
+            // Register event handlers
+            this.httpApi.onEvent(this.handleEventFromHook.bind(this));
+            // Register interactive prompt handlers for BeforeTool hooks
+            this.httpApi.onInteractivePrompt(this.handleInteractivePromptRequest.bind(this));
+            this.httpApi.onGetPromptResponse(this.getInteractivePromptResponse.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(),
+            });
+            // Write default port file so hooks can find us before any session is created
+            const defaultPortFile = path.join(os.tmpdir(), 'codevibe-gemini-default.port');
+            fs.writeFileSync(defaultPortFile, this.assignedPort.toString());
+            logger_1.logger.info(`Default port file written: ${defaultPortFile} -> ${this.assignedPort}`);
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to start MCP Server:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create an event with optional E2E encryption
+     * Encrypts content and metadata if session key is available
+     */
+    async createEncryptedEvent(params) {
+        let eventContent = params.content;
+        let eventMetadata = params.metadata;
+        let isEncrypted = false;
+        // Encrypt event content if we have a session key
+        if (this.sessionKey) {
+            eventContent = codevibe_core_1.cryptoService.encryptContent(params.content, this.sessionKey);
+            if (eventMetadata) {
+                const encryptedMeta = codevibe_core_1.cryptoService.encryptMetadata(eventMetadata, this.sessionKey);
+                eventMetadata = { encrypted: encryptedMeta };
+            }
+            isEncrypted = true;
+        }
+        await this.appSyncClient.createEvent({
+            sessionId: params.sessionId,
+            type: params.type,
+            source: params.source,
+            content: eventContent,
+            metadata: eventMetadata,
+            promptId: params.promptId,
+            timestamp: params.timestamp,
+            isEncrypted,
+        });
+    }
+    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
+                this.removePortFile(sessionId);
+            }
+            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();
+        this.currentBackendSessionId = null;
+        // Remove default port file
+        const defaultPortFile = path.join(os.tmpdir(), 'codevibe-gemini-default.port');
+        try {
+            fs.unlinkSync(defaultPortFile);
+        }
+        catch { }
+        // 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 } = payload;
+        let { 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);
+            }
+            // Map Gemini session ID to backend session ID
+            // Session lifecycle events (SessionStart/SessionEnd) are handled separately and create the mapping
+            let backendSessionId = this.geminiToBackendSessionId.get(session_id);
+            if (!backendSessionId) {
+                // Try the session_id directly in case it's already a backend session ID
+                if (this.activeSessions.has(session_id)) {
+                    backendSessionId = session_id;
+                }
+                else {
+                    // Unknown session ID — likely from /resume within an active session.
+                    // When Gemini CLI resumes via /resume, there's NO new SessionStart hook;
+                    // hooks just start using the ORIGINAL session ID.
+                    const generatedId = this.generateBackendSessionId(session_id);
+                    if (this.activeSessions.has(generatedId)) {
+                        // Already active (e.g. multiple hooks arrived), just cache the mapping
+                        backendSessionId = generatedId;
+                        this.geminiToBackendSessionId.set(session_id, generatedId);
+                        logger_1.logger.info('Mapped unknown session ID to existing active session', {
+                            geminiSessionId: session_id,
+                            backendSessionId: generatedId,
+                        });
+                    }
+                    else {
+                        // Resumed session — switch to it
+                        logger_1.logger.info('Detected resumed session from hook, switching backend session', {
+                            geminiSessionId: session_id,
+                            newBackendSessionId: generatedId,
+                            previousBackendSessionId: this.currentBackendSessionId,
+                        });
+                        await this.switchToResumedSession(session_id, generatedId);
+                        backendSessionId = generatedId;
+                    }
+                }
+            }
+            // Skip USER_PROMPT events that originated from mobile
+            // When mobile sends a prompt via tmux, it triggers BeforeAgent 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' || hook_event_name === 'BeforeAgent') &&
+                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
+            }
+            // For INTERACTIVE_PROMPT from Notification hook:
+            // The Notification hook script blocks Gemini CLI — the prompt is NOT rendered
+            // until the hook returns. So we must return immediately and defer tmux capture.
+            // After the hook returns (and Gemini renders the prompt), we capture tmux
+            // to parse the actual options dynamically.
+            if (type === codevibe_core_1.EventType.INTERACTIVE_PROMPT && hook_event_name === 'Notification') {
+                // Track interactive prompt state immediately (before async work)
+                const sessionState = this.activeSessions.get(backendSessionId);
+                if (sessionState) {
+                    sessionState.waitingForPromptResponse = true;
+                    sessionState.pendingPromptId = payload.prompt_id;
+                }
+                // Fire async — don't await, so handleEventFromHook returns immediately,
+                // the HTTP response goes back to the hook script, and Gemini CLI renders the prompt.
+                this.sendInteractivePromptAsync(backendSessionId, payload, content).catch(e => {
+                    logger_1.logger.error('Failed to send interactive prompt with dynamic options', { error: e });
+                });
+                return;
+            }
+            // Send event to AppSync (with encryption if available)
+            // Default source to DESKTOP since all hook events originate from desktop
+            await this.createEncryptedEvent({
+                sessionId: backendSessionId,
+                type,
+                source: payload.source || codevibe_core_1.EventSource.DESKTOP,
+                content,
+                metadata: payload.metadata,
+                promptId: payload.prompt_id,
+            });
+            // Track interactive prompts (for non-Notification paths like BeforeTool)
+            if (type === codevibe_core_1.EventType.INTERACTIVE_PROMPT) {
+                const sessionState = this.activeSessions.get(backendSessionId);
+                if (sessionState) {
+                    sessionState.waitingForPromptResponse = true;
+                    sessionState.pendingPromptId = payload.prompt_id;
+                    if (payload.metadata?.submitMap) {
+                        sessionState.pendingSubmitMap = payload.metadata.submitMap;
+                    }
+                    logger_1.logger.info('Interactive prompt detected - waiting for response', {
+                        sessionId: backendSessionId,
+                        promptId: payload.prompt_id,
+                    });
+                }
+            }
+            // 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;
+                    logger_1.logger.info('Clearing prompt wait state - new desktop prompt received', {
+                        sessionId: backendSessionId,
+                    });
+                }
+            }
+            logger_1.logger.info('Event sent to AppSync successfully', { sessionId: backendSessionId, type, hookEvent: hook_event_name });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to process hook event:', error);
+            throw error;
+        }
+    }
+    /**
+     * Handle SessionStart hook event
+     *
+     * Supports both new sessions and resumed sessions via centralized
+     * resumeOrCreateSession() from codevibe-core.
+     */
+    async handleSessionStart(payload) {
+        const geminiSessionId = payload.session_id;
+        const backendSessionId = this.getBackendSessionId(geminiSessionId);
+        const cwd = payload.metadata?.cwd || process.cwd();
+        logger_1.logger.info('Session started', {
+            backendSessionId,
+            geminiSessionId,
+            cwd,
+            source: payload.metadata?.source,
+        });
+        // Mark any previous sessions as INACTIVE
+        const previousSessionIds = Array.from(this.activeSessions.keys()).filter(id => id !== backendSessionId);
+        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: backendSessionId });
+                }
+                catch (error) {
+                    logger_1.logger.warn('Failed to mark previous session as INACTIVE', { prevId, error });
+                }
+                this.removePortFile(prevId);
+                this.activeSessions.delete(prevId);
+            }
+        }
+        // Write port files for both backend and Gemini session IDs
+        this.writePortFile(backendSessionId);
+        this.writePortFile(geminiSessionId);
+        const userId = this.appSyncClient.getCurrentUserId();
+        // Create session state
+        const sessionState = {
+            sessionId: backendSessionId,
+            userId,
+            projectPath: cwd,
+            cwd,
+            createdAt: new Date(),
+            subscriptionActive: false,
+            waitingForPromptResponse: false,
+            metadata: payload.metadata || {},
+        };
+        this.activeSessions.set(backendSessionId, sessionState);
+        // Resume or create session via centralized utility
+        try {
+            const result = await (0, codevibe_core_1.resumeOrCreateSession)({
+                sessionId: backendSessionId,
+                userId,
+                agentType: codevibe_core_1.AgentType.GEMINI,
+                projectPath: cwd,
+                metadata: payload.metadata || {},
+            }, this.appSyncClient, logger_1.logger);
+            this.sessionKey = result.sessionKey;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to create/resume session:', error);
+            if (this.isSessionLimitExceeded(error)) {
+                this.displaySubscriptionLimitError(error, 'session');
+                this.activeSessions.delete(backendSessionId);
+                this.removePortFile(backendSessionId);
+                return;
+            }
+            logger_1.logger.warn('Session creation failed but continuing...', { error: error.message });
+        }
+        this.currentBackendSessionId = backendSessionId;
+        this.subscribeToMobileEvents(backendSessionId);
+        this.appSyncClient.startHeartbeat(backendSessionId);
+    }
+    /**
+     * Handle session switch when hooks reveal a resumed session (via /resume).
+     * Looks up the existing backend session, reactivates it, and marks previous session INACTIVE.
+     */
+    async switchToResumedSession(geminiSessionId, backendSessionId) {
+        // Cache the mapping
+        this.geminiToBackendSessionId.set(geminiSessionId, backendSessionId);
+        const userId = this.appSyncClient.getCurrentUserId();
+        // Resume or create session via centralized utility
+        try {
+            const result = await (0, codevibe_core_1.resumeOrCreateSession)({
+                sessionId: backendSessionId,
+                userId,
+                agentType: codevibe_core_1.AgentType.GEMINI,
+                projectPath: this.workingDirectory,
+                metadata: {},
+            }, this.appSyncClient, logger_1.logger);
+            this.sessionKey = result.sessionKey;
+            logger_1.logger.info('Resumed session via switchToResumedSession', {
+                backendSessionId,
+                resumed: result.resumed,
+                hasSessionKey: !!result.sessionKey,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to resume/create session during switch:', error);
+            if (this.isSessionLimitExceeded(error)) {
+                this.displaySubscriptionLimitError(error, 'session');
+                return;
+            }
+        }
+        // Create session state
+        const sessionState = {
+            sessionId: backendSessionId,
+            userId,
+            projectPath: this.workingDirectory,
+            cwd: this.workingDirectory,
+            createdAt: new Date(),
+            subscriptionActive: false,
+            waitingForPromptResponse: false,
+            metadata: {},
+        };
+        this.activeSessions.set(backendSessionId, sessionState);
+        this.writePortFile(backendSessionId);
+        this.writePortFile(geminiSessionId);
+        // Mark previous session as INACTIVE
+        if (this.currentBackendSessionId && this.currentBackendSessionId !== backendSessionId) {
+            try {
+                await this.appSyncClient.updateSession({
+                    sessionId: this.currentBackendSessionId,
+                    status: codevibe_core_1.SessionStatus.INACTIVE,
+                });
+                logger_1.logger.info('Previous session marked INACTIVE during resume switch', {
+                    previousSessionId: this.currentBackendSessionId,
+                    newSessionId: backendSessionId,
+                });
+            }
+            catch (error) {
+                logger_1.logger.warn('Failed to mark previous session INACTIVE', { error });
+            }
+            this.appSyncClient.stopHeartbeat(this.currentBackendSessionId);
+            this.removePortFile(this.currentBackendSessionId);
+            this.activeSessions.delete(this.currentBackendSessionId);
+        }
+        this.currentBackendSessionId = backendSessionId;
+        this.subscribeToMobileEvents(backendSessionId);
+        this.appSyncClient.startHeartbeat(backendSessionId);
+    }
+    /**
+     * Handle SessionEnd hook event
+     */
+    async handleSessionEnd(payload) {
+        const geminiSessionId = payload.session_id;
+        // Look up the backend session ID; try generated ID as fallback for resumed sessions
+        let sessionId = this.geminiToBackendSessionId.get(geminiSessionId);
+        if (!sessionId) {
+            const generated = this.generateBackendSessionId(geminiSessionId);
+            if (this.activeSessions.has(generated)) {
+                sessionId = generated;
+            }
+            else {
+                sessionId = geminiSessionId; // last resort fallback
+            }
+        }
+        logger_1.logger.info('Session ended', {
+            sessionId,
+            geminiSessionId,
+            reason: payload.metadata?.reason,
+        });
+        // Stop heartbeat
+        this.appSyncClient.stopHeartbeat(sessionId);
+        // Remove port files for both session IDs
+        this.removePortFile(sessionId);
+        this.removePortFile(geminiSessionId);
+        // 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;
+        }
+        // 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
+        this.activeSessions.delete(sessionId);
+        logger_1.logger.debug('Session cleanup completed', { sessionId });
+    }
+    /**
+     * Handle interactive prompt request from BeforeTool hook
+     * Creates an INTERACTIVE_PROMPT event and waits for mobile response
+     */
+    async handleInteractivePromptRequest(request) {
+        const promptId = `prompt-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        logger_1.logger.info('Handling interactive prompt request', {
+            promptId,
+            sessionId: request.sessionId,
+            toolName: request.toolName,
+        });
+        // Get the backend session ID (the request may use Gemini session ID)
+        const backendSessionId = this.geminiToBackendSessionId.get(request.sessionId) || request.sessionId;
+        // Map tool name to iOS-expected display name
+        const mappedToolName = this.mapGeminiToolName(request.toolName);
+        // Build the prompt content
+        const toolDescription = this.buildToolDescription(mappedToolName, request.toolInput);
+        const promptContent = `Gemini wants to use ${mappedToolName}:\n${toolDescription}`;
+        // Build metadata with tool info and options
+        // Match Claude plugin format exactly for iOS compatibility
+        const metadata = {
+            tool_name: mappedToolName,
+            tool_input: request.toolInput,
+            options: types_1.DEFAULT_TOOL_APPROVAL_OPTIONS,
+            instructions: 'Select an option',
+        };
+        // Send INTERACTIVE_PROMPT event to iOS
+        try {
+            await this.createEncryptedEvent({
+                sessionId: backendSessionId,
+                type: codevibe_core_1.EventType.INTERACTIVE_PROMPT,
+                source: codevibe_core_1.EventSource.DESKTOP,
+                content: promptContent,
+                metadata,
+                promptId,
+            });
+            logger_1.logger.info('Interactive prompt event sent to iOS', {
+                promptId,
+                backendSessionId,
+                toolName: request.toolName,
+            });
+            // Track the pending prompt
+            const pendingPrompt = {
+                promptId,
+                sessionId: backendSessionId,
+                toolName: request.toolName,
+                toolInput: request.toolInput,
+                createdAt: new Date(),
+                resolve: () => { }, // Will be set by the Promise
+                reject: () => { }, // Will be set by the Promise
+            };
+            this.pendingInteractivePrompts.set(promptId, pendingPrompt);
+            // Update session state to track waiting for response
+            const sessionState = this.activeSessions.get(backendSessionId);
+            if (sessionState) {
+                sessionState.waitingForPromptResponse = true;
+                sessionState.pendingPromptId = promptId;
+            }
+            // Set timeout to auto-reject after 5 minutes
+            pendingPrompt.timeoutId = setTimeout(() => {
+                const prompt = this.pendingInteractivePrompts.get(promptId);
+                if (prompt) {
+                    logger_1.logger.warn('Interactive prompt timed out', { promptId });
+                    this.pendingInteractivePrompts.delete(promptId);
+                    // Clear session state
+                    const state = this.activeSessions.get(backendSessionId);
+                    if (state?.pendingPromptId === promptId) {
+                        state.waitingForPromptResponse = false;
+                        state.pendingPromptId = undefined;
+                    }
+                }
+            }, McpServer.INTERACTIVE_PROMPT_TIMEOUT_MS);
+            return {
+                promptId,
+                status: 'pending',
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to send interactive prompt event:', error);
+            throw error;
+        }
+    }
+    /**
+     * Send INTERACTIVE_PROMPT event asynchronously after capturing tmux options.
+     * Called from handleEventFromHook for Notification/ToolPermission events.
+     * The 500ms delay allows the hook script to return so Gemini CLI renders the prompt.
+     */
+    async sendInteractivePromptAsync(backendSessionId, payload, content) {
+        // Wait for hook script to return and Gemini CLI to render the prompt
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Try to capture dynamic options from tmux
+        const tmuxSession = process.env.CODEVIBE_GEMINI_TMUX_SESSION;
+        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, stderr) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve({ stdout, stderr });
+                    });
+                });
+                const { stdout } = await execAsync(`tmux capture-pane -p -e -S -30 -t '${tmuxSession}'`);
+                const parsed = (0, codevibe_core_1.parseInteractivePrompt)(stdout);
+                if (parsed && parsed.options.length > 0) {
+                    payload.metadata = payload.metadata || {};
+                    payload.metadata.options = parsed.options;
+                    payload.metadata.submitMap = parsed.submitMap;
+                    logger_1.logger.info('Parsed dynamic options from tmux', {
+                        optionCount: parsed.options.length,
+                        kind: parsed.kind,
+                        options: parsed.options,
+                    });
+                }
+                else {
+                    logger_1.logger.debug('No dynamic options parsed from tmux, using defaults from hook data');
+                }
+            }
+            catch (e) {
+                logger_1.logger.warn('Failed to capture tmux pane for options', { error: e });
+            }
+        }
+        // Send event to AppSync
+        await this.createEncryptedEvent({
+            sessionId: backendSessionId,
+            type: codevibe_core_1.EventType.INTERACTIVE_PROMPT,
+            source: payload.source || codevibe_core_1.EventSource.DESKTOP,
+            content,
+            metadata: payload.metadata,
+            promptId: payload.prompt_id,
+        });
+        // Update session state with submitMap
+        const sessionState = this.activeSessions.get(backendSessionId);
+        if (sessionState && payload.metadata?.submitMap) {
+            sessionState.pendingSubmitMap = payload.metadata.submitMap;
+        }
+        logger_1.logger.info('Interactive prompt sent to AppSync with dynamic options', {
+            sessionId: backendSessionId,
+            promptId: payload.prompt_id,
+        });
+    }
+    /**
+     * Map Gemini CLI tool type names to iOS-expected display names
+     */
+    mapGeminiToolName(name) {
+        switch (name.toLowerCase()) {
+            case 'exec':
+            case 'shell':
+                return 'Bash';
+            case 'edit':
+            case 'edit_file':
+                return 'Edit';
+            case 'write':
+            case 'write_file':
+                return 'Write';
+            case 'read':
+            case 'read_file':
+                return 'Read';
+            default:
+                return name;
+        }
+    }
+    /**
+     * Build a human-readable description of the tool operation
+     */
+    buildToolDescription(toolName, toolInput) {
+        switch (toolName.toLowerCase()) {
+            case 'edit':
+            case 'write':
+                if (toolInput.file_path) {
+                    return `File: ${toolInput.file_path}`;
+                }
+                return JSON.stringify(toolInput, null, 2);
+            case 'shell':
+            case 'bash':
+                if (toolInput.command) {
+                    return `Command: ${toolInput.command}`;
+                }
+                return JSON.stringify(toolInput, null, 2);
+            case 'read':
+                if (toolInput.file_path) {
+                    return `Reading: ${toolInput.file_path}`;
+                }
+                return JSON.stringify(toolInput, null, 2);
+            default:
+                return JSON.stringify(toolInput, null, 2);
+        }
+    }
+    /**
+     * Get the response for a pending interactive prompt
+     * Called by hook script polling for mobile response
+     */
+    getInteractivePromptResponse(promptId) {
+        const pendingPrompt = this.pendingInteractivePrompts.get(promptId);
+        if (!pendingPrompt) {
+            logger_1.logger.debug('No pending prompt found', { promptId });
+            return null;
+        }
+        // Check if we have a decision stored
+        const sessionState = this.activeSessions.get(pendingPrompt.sessionId);
+        // If no response yet, return pending status
+        if (sessionState?.waitingForPromptResponse) {
+            return {
+                promptId,
+                decision: 'pending',
+            };
+        }
+        // If waitingForPromptResponse is false, the prompt was answered
+        // Check the stored decision based on session state
+        const prompt = this.pendingInteractivePrompts.get(promptId);
+        if (prompt) {
+            // The decision was handled in subscribeToMobileEvents
+            // Clean up and return the stored decision
+            const decision = prompt.decision || 'ask';
+            const reason = prompt.reason;
+            // Clear the pending prompt
+            if (prompt.timeoutId) {
+                clearTimeout(prompt.timeoutId);
+            }
+            this.pendingInteractivePrompts.delete(promptId);
+            logger_1.logger.info('Returning interactive prompt decision', { promptId, decision, reason });
+            return {
+                promptId,
+                decision,
+                reason,
+            };
+        }
+        return null;
+    }
+    /**
+     * Resolve a pending interactive prompt with a decision from mobile
+     * Called when mobile user responds to the prompt
+     */
+    resolveInteractivePrompt(promptId, decision, reason) {
+        const pendingPrompt = this.pendingInteractivePrompts.get(promptId);
+        if (!pendingPrompt) {
+            logger_1.logger.warn('Cannot resolve - prompt not found', { promptId });
+            return;
+        }
+        logger_1.logger.info('Resolving interactive prompt', {
+            promptId,
+            decision,
+            reason,
+        });
+        // Store the decision on the pending prompt for getInteractivePromptResponse to read
+        pendingPrompt.decision = decision;
+        pendingPrompt.reason = reason;
+        // Clear the waiting state
+        const sessionState = this.activeSessions.get(pendingPrompt.sessionId);
+        if (sessionState) {
+            sessionState.waitingForPromptResponse = false;
+            sessionState.pendingPromptId = undefined;
+        }
+    }
+    /**
+     * 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 parsed = this.parseInteractivePromptInput(content);
+                    logger_1.logger.info('Parsed interactive prompt input', {
+                        sessionId,
+                        content,
+                        parsed,
+                    });
+                    if (parsed.action === 'select_option') {
+                        // User selected option - translate via submitMap if available
+                        const submitMap = sessionState.pendingSubmitMap;
+                        const terminalInput = submitMap?.[parsed.option] || parsed.option;
+                        logger_1.logger.info('User selected option', {
+                            option: parsed.option,
+                            terminalInput,
+                            hasSubmitMap: !!submitMap,
+                        });
+                        // Resolve the pending interactive prompt for BeforeTool hook polling
+                        if (sessionState.pendingPromptId) {
+                            const decision = parsed.option === '1' || parsed.option === '2' ? 'allow' : 'deny';
+                            const reason = parsed.option === '2' ? 'allowed_for_session' : undefined;
+                            this.resolveInteractivePrompt(sessionState.pendingPromptId, decision, reason);
+                        }
+                        const success = await this.promptResponder.answerInteractivePrompt(sessionId, terminalInput);
+                        if (success) {
+                            await this.markEventExecuted(event);
+                            sessionState.waitingForPromptResponse = false;
+                            sessionState.pendingPromptId = undefined;
+                            delete sessionState.pendingSubmitMap;
+                            await this.createEncryptedEvent({
+                                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 === 'reject_and_prompt') {
+                        // User typed "3" or "3 <text>" - reject prompt and send new prompt
+                        logger_1.logger.info('User rejecting prompt and sending new prompt', {
+                            newPrompt: parsed.newPrompt,
+                        });
+                        // Resolve the pending interactive prompt for BeforeTool hook polling
+                        if (sessionState.pendingPromptId) {
+                            this.resolveInteractivePrompt(sessionState.pendingPromptId, 'deny');
+                        }
+                        // First, reject the interactive prompt by sending "3" (the reject option)
+                        const rejectSuccess = await this.promptResponder.answerInteractivePrompt(sessionId, '3');
+                        // Clear waiting state
+                        sessionState.waitingForPromptResponse = false;
+                        sessionState.pendingPromptId = undefined;
+                        delete sessionState.pendingSubmitMap;
+                        if (rejectSuccess) {
+                            await this.createEncryptedEvent({
+                                sessionId,
+                                type: codevibe_core_1.EventType.NOTIFICATION,
+                                source: codevibe_core_1.EventSource.DESKTOP,
+                                content: 'Interactive prompt rejected',
+                                metadata: { promptRejected: true },
+                            });
+                            // If there's a new prompt to send, execute it after a short delay
+                            if (parsed.newPrompt) {
+                                // Wait for Gemini to process the rejection
+                                await new Promise(resolve => setTimeout(resolve, 1000));
+                                // Send the new prompt
+                                const modifiedEvent = { ...event, content: parsed.newPrompt };
+                                await this.executeMobilePrompt(sessionId, modifiedEvent);
+                            }
+                            await this.markEventExecuted(event);
+                        }
+                        else {
+                            await this.sendPromptError(sessionId, 'Failed to reject prompt');
+                        }
+                    }
+                    else {
+                        // 'send_as_response' - send content as-is to interactive prompt (free-form for option 3)
+                        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;
+                            await this.createEncryptedEvent({
+                                sessionId,
+                                type: codevibe_core_1.EventType.NOTIFICATION,
+                                source: codevibe_core_1.EventSource.DESKTOP,
+                                content: `Response "${content}" 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 });
+    }
+    /**
+     * Parse mobile input when an interactive prompt is waiting
+     * Determines what action to take based on the input pattern
+     *
+     * Input patterns:
+     * - "1" or "2" → select that option
+     * - "3" → reject prompt, wait for next message as new prompt
+     * - "3 <text>" or "3<newline><text>" → reject prompt, send <text> as new prompt
+     * - anything else → send as free-form response to interactive prompt
+     */
+    parseInteractivePromptInput(content) {
+        const trimmed = content.trim();
+        // Check for option 1 or 2 (exact match)
+        if (trimmed === '1' || trimmed === '2') {
+            return { action: 'select_option', option: trimmed };
+        }
+        // Check for option 3 patterns
+        if (trimmed === '3') {
+            // Just "3" - reject prompt, but no new prompt yet
+            // The next message will be treated as a new prompt since waitingForPromptResponse will be false
+            return { action: 'reject_and_prompt', newPrompt: undefined };
+        }
+        // Check for "3 <text>" or "3\n<text>" pattern
+        const option3Match = trimmed.match(/^3[\s\n]+(.+)$/s);
+        if (option3Match) {
+            return { action: 'reject_and_prompt', newPrompt: option3Match[1].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.createEncryptedEvent({
+            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 Gemini CLI 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 Gemini CLI 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 the working directory
+     * Returns the relative file path (for Gemini CLI's @./path syntax)
+     *
+     * Gemini CLI requires @./path format for local file references.
+     * Files are saved to .codevibe-attachments/ in the working directory.
+     * @param attachment The attachment to download
+     * @param sessionId The session ID for organizing 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', {
+                id: attachment.id,
+                type: attachment.type,
+                filename: attachment.filename,
+                s3Key: attachment.s3Key,
+                attachmentIsEncrypted: attachment.isEncrypted,
+                eventIsEncrypted,
+                shouldDecrypt,
+            });
+            // 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());
+            // Decrypt if encrypted
+            if (shouldDecrypt && this.sessionKey) {
+                try {
+                    logger_1.logger.info('Decrypting attachment', { id: attachment.id });
+                    buffer = codevibe_core_1.cryptoService.decryptData(buffer, this.sessionKey);
+                    logger_1.logger.info('Attachment decrypted successfully', {
+                        id: attachment.id,
+                        decryptedSize: buffer.length,
+                    });
+                }
+                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 - Gemini CLI won't be able to view it properly
+            }
+            // Create attachments directory in the working directory
+            // Gemini CLI requires relative paths starting with ./
+            const attachmentsDir = path.join(this.workingDirectory, '.codevibe-attachments');
+            if (!fs.existsSync(attachmentsDir)) {
+                fs.mkdirSync(attachmentsDir, { recursive: true });
+            }
+            // Determine file extension from MIME type or filename
+            let extension = '';
+            if (attachment.filename) {
+                const ext = path.extname(attachment.filename);
+                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 attachments directory with unique filename
+            const filename = `attachment-${attachment.id}${extension}`;
+            const absolutePath = path.join(attachmentsDir, filename);
+            fs.writeFileSync(absolutePath, buffer);
+            // Return relative path for Gemini CLI's @./path syntax
+            const relativePath = `./.codevibe-attachments/${filename}`;
+            logger_1.logger.info('Attachment saved to working directory', {
+                id: attachment.id,
+                absolutePath,
+                relativePath,
+                size: buffer.length,
+            });
+            return relativePath;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to download attachment:', { id: attachment.id, error });
+            return null;
+        }
+    }
+    /**
+     * Execute a prompt from mobile in the desktop Gemini CLI session
+     * Uses tmux send-keys to send the prompt to the Gemini CLI 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
+            // Gemini CLI uses @path/to/file format for file references
+            if (attachmentPaths.length > 0) {
+                const fileReferences = attachmentPaths
+                    .map(p => `@${p}`)
+                    .join(' ');
+                // Format: @file references first, then the user's message
+                if (prompt) {
+                    prompt = `${fileReferences} ${prompt}`;
+                }
+                else {
+                    // No text content, just file references with instruction
+                    prompt = `${fileReferences} Please 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 });
+                // Note: Suppressed confirmation notification to reduce noise in iOS app
+                // The double checkmarks (DELIVERED → EXECUTED) already indicate success
+            }
+            else {
+                logger_1.logger.error('Failed to send mobile prompt', { sessionId });
+                // Send error notification to mobile
+                await this.createEncryptedEvent({
+                    sessionId,
+                    type: codevibe_core_1.EventType.NOTIFICATION,
+                    source: codevibe_core_1.EventSource.DESKTOP,
+                    content: `Failed to send prompt to Gemini CLI`,
+                    metadata: {
+                        error: true,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to execute mobile prompt:', error);
+        }
+    }
+}
+McpServer.MOBILE_PROMPT_EXPIRY_MS = 10000; // 10 seconds
+McpServer.INTERACTIVE_PROMPT_TIMEOUT_MS = 300000; // 5 minutes
+// Main entry point
+async function main() {
+    // Get session ID from command line argument or environment variable
+    const sessionId = process.argv[2] || process.env.GEMINI_SESSION_ID;
+    // Get working directory from environment variable or use current directory
+    const workingDirectory = process.env.GEMINI_WORKING_DIRECTORY || process.cwd();
+    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 discovered from transcript)');
+    }
+    logger_1.logger.info(`Working directory: ${workingDirectory}`);
+    const server = new McpServer(sessionId, workingDirectory);
+    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