@quantiya/codevibe-codex-plugin 1.0.0

package/dist/server.js

@@ -0,0 +1,1045 @@
+"use strict";
+/**
+ * CodeVibe Codex Plugin - Main Server
+ *
+ * Watches Codex CLI session logs and syncs events to iOS app via AWS AppSync.
+ * Receives mobile prompts via subscription and sends them to Codex via tmux.
+ */
+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 uuid_1 = require("uuid");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Import shared modules from codevibe-core
+const codevibe_core_1 = require("@quantiya/codevibe-core");
+// Import plugin-specific logger
+const logger_1 = require("./logger");
+// Import plugin-specific modules
+const session_log_watcher_1 = require("./session-log-watcher");
+const event_mapper_1 = require("./event-mapper");
+const approval_detector_1 = require("./approval-detector");
+const prompt_responder_1 = require("./prompt-responder");
+const tmux_pane_observer_1 = require("./tmux-pane-observer");
+const prompt_parser_1 = require("./prompt-parser");
+class CodexCompanionServer {
+    constructor() {
+        this.sessionState = null;
+        this.unsubscribe = null;
+        this.sessionKey = null; // E2E encryption session key
+        this.pendingInteractivePrompt = null;
+        this.isInitializingSession = false;
+        this.bufferedLogEntries = [];
+        // AppSyncClient is created in start() after config is loaded
+        this.sessionWatcher = new session_log_watcher_1.SessionLogWatcher();
+        this.approvalDetector = new approval_detector_1.ApprovalDetector();
+        this.promptResponder = new prompt_responder_1.PromptResponder();
+        this.tmuxPaneObserver = new tmux_pane_observer_1.TmuxPaneObserver();
+    }
+    /**
+     * Start the server
+     */
+    async start() {
+        logger_1.logger.info('Starting CodeVibe Codex companion server', {
+            environment: (0, codevibe_core_1.getEnvironment)(),
+        });
+        // Create AppSyncClient (auto-configures from ENVIRONMENT env var)
+        this.appSyncClient = new codevibe_core_1.AppSyncClient();
+        // Authenticate with stored tokens
+        const authenticated = await this.appSyncClient.authenticateWithStoredTokens();
+        if (!authenticated) {
+            logger_1.logger.error('Authentication failed. Run "codevibe-codex login" first.');
+            console.error('Not authenticated. Run "codevibe-codex login" to sign in.');
+            process.exit(1);
+        }
+        logger_1.logger.info('Authenticated successfully', {
+            userId: this.appSyncClient.getCurrentUserId(),
+            email: this.appSyncClient.getCurrentUserEmail(),
+        });
+        // Register device encryption key for E2E encryption
+        await this.registerDeviceEncryptionKey();
+        // Set up event handlers
+        this.setupEventHandlers();
+        // Start watching session logs
+        this.sessionWatcher.start();
+        logger_1.logger.info('CodeVibe Codex companion server started');
+    }
+    /**
+     * Set up event handlers for session watcher and approval detector
+     */
+    setupEventHandlers() {
+        // Handle new Codex session
+        this.sessionWatcher.on('session-started', async (meta) => {
+            await this.handleSessionStarted(meta);
+        });
+        // Handle log entries
+        this.sessionWatcher.on('log-entry', async (entry) => {
+            await this.handleLogEntry(entry);
+        });
+        // Handle approval pending detection
+        this.approvalDetector.on('approval-pending', async (data) => {
+            await this.handleApprovalPending(data);
+        });
+        this.tmuxPaneObserver.on('prompt-candidate', async (candidate) => {
+            await this.handleTmuxPromptCandidate(candidate.snapshot);
+        });
+        this.tmuxPaneObserver.on('observer-error', (error) => {
+            logger_1.logger.debug('Tmux pane observer error', { error });
+        });
+        // Handle errors
+        this.sessionWatcher.on('error', (error) => {
+            logger_1.logger.error('Session watcher error:', error);
+        });
+    }
+    /**
+     * Register device encryption key with backend for E2E encryption
+     */
+    async registerDeviceEncryptionKey() {
+        try {
+            // Get or generate device key pair
+            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
+            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);
+        }
+    }
+    /**
+     * Handle new Codex session started
+     */
+    async handleSessionStarted(meta) {
+        logger_1.logger.info('Handling new Codex session', { codexSessionId: meta.id });
+        // Mark that session initialization is in progress so log entries
+        // arriving before sessionState is set are buffered instead of dropped.
+        this.isInitializingSession = true;
+        this.bufferedLogEntries = [];
+        // If we already have an active session, mark it inactive before starting a new one
+        if (this.sessionState) {
+            await this.endActiveSession('new-codex-session-started');
+        }
+        const projectPath = process.env.CODEX_WORKING_DIRECTORY || meta.cwd || process.cwd();
+        // Use Codex's actual runtime session ID so concurrent Codex sessions in the
+        // same directory appear as separate sessions in the iOS app.
+        const sessionId = this.generateSessionId(meta.id);
+        const userId = this.appSyncClient.getCurrentUserId();
+        // Base metadata (unencrypted)
+        const baseMetadata = {
+            codexSessionId: meta.id,
+            cliVersion: meta.cli_version,
+            modelProvider: meta.model_provider,
+        };
+        // Use centralized resume/create utility from codevibe-core
+        try {
+            const result = await (0, codevibe_core_1.resumeOrCreateSession)({
+                sessionId,
+                userId,
+                agentType: codevibe_core_1.AgentType.CODEX,
+                projectPath,
+                metadata: baseMetadata,
+            }, this.appSyncClient, logger_1.logger);
+            this.sessionKey = result.sessionKey;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to create/resume session:', error);
+            throw error;
+        }
+        try {
+            // Store session state
+            this.sessionState = {
+                sessionId,
+                userId,
+                projectPath,
+                cwd: meta.cwd,
+                createdAt: new Date(),
+                subscriptionActive: false,
+                metadata: baseMetadata,
+                codexSessionId: meta.id,
+                codexLogFile: this.sessionWatcher.getActiveLogFile() || undefined,
+            };
+            // Flush any log entries that arrived while we were initializing
+            await this.flushBufferedLogEntries();
+            await this.startTmuxObserver();
+            // Subscribe to mobile events
+            this.subscribeToMobileEvents(sessionId);
+            // Start heartbeat so iOS can detect if desktop is still connected
+            this.appSyncClient.startHeartbeat(sessionId);
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to create session:', error);
+            this.bufferedLogEntries = [];
+        }
+        finally {
+            this.isInitializingSession = false;
+        }
+    }
+    /**
+     * Flush log entries that were buffered during async session initialization.
+     */
+    async flushBufferedLogEntries() {
+        if (this.bufferedLogEntries.length === 0) {
+            return;
+        }
+        const entries = this.bufferedLogEntries;
+        this.bufferedLogEntries = [];
+        logger_1.logger.info('Flushing buffered log entries after session initialization', {
+            count: entries.length,
+            sessionId: this.sessionState?.sessionId,
+        });
+        for (const entry of entries) {
+            await this.handleLogEntry(entry);
+        }
+    }
+    /**
+     * Handle a log entry from Codex
+     */
+    async handleLogEntry(entry) {
+        if (!this.sessionState) {
+            if (this.isInitializingSession) {
+                this.bufferedLogEntries.push(entry);
+                logger_1.logger.debug('Buffering log entry until session initialization completes', {
+                    type: entry.type,
+                    bufferedCount: this.bufferedLogEntries.length,
+                });
+                return;
+            }
+            logger_1.logger.warn('Received log entry but no active session');
+            return;
+        }
+        // Track tool calls for approval detection
+        if (entry.type === 'response_item' && entry.payload) {
+            const itemType = entry.payload.type;
+            if (itemType === 'function_call' || itemType === 'custom_tool_call') {
+                this.approvalDetector.onToolCallStart(entry.payload.call_id, entry.payload.name, entry.payload.arguments || entry.payload.input || '');
+            }
+            else if (itemType === 'function_call_output' || itemType === 'custom_tool_call_output') {
+                this.approvalDetector.onToolCallComplete(entry.payload.call_id);
+                if (this.pendingInteractivePrompt?.callId === entry.payload.call_id) {
+                    this.pendingInteractivePrompt = null;
+                }
+            }
+        }
+        // Map to CodeVibe event
+        const eventInput = (0, event_mapper_1.mapLogEntryToEvent)(entry, this.sessionState.sessionId);
+        if (!eventInput) {
+            return; // Entry should not be synced
+        }
+        try {
+            // Encrypt event content if we have a session key
+            if (this.sessionKey) {
+                eventInput.content = codevibe_core_1.cryptoService.encryptContent(eventInput.content, this.sessionKey);
+                if (eventInput.metadata) {
+                    const encryptedMetadata = codevibe_core_1.cryptoService.encryptMetadata(eventInput.metadata, this.sessionKey);
+                    eventInput.metadata = { encrypted: encryptedMetadata };
+                }
+                eventInput.isEncrypted = true;
+                logger_1.logger.debug('Event encrypted', { type: eventInput.type });
+            }
+            await this.appSyncClient.createEvent(eventInput);
+            logger_1.logger.debug('Event synced to backend', { type: eventInput.type, encrypted: !!this.sessionKey });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to sync event:', error);
+        }
+    }
+    /**
+     * Handle approval pending notification
+     */
+    async handleApprovalPending(data) {
+        if (!this.sessionState) {
+            return;
+        }
+        logger_1.logger.info('Sending approval pending interactive prompt', data);
+        try {
+            const tmuxPrompt = await this.tryParseInteractivePromptFromTmux();
+            const parsedPrompt = tmuxPrompt?.parsedPrompt ?? null;
+            if (parsedPrompt &&
+                this.pendingInteractivePrompt &&
+                this.pendingInteractivePrompt.source === 'tmux' &&
+                this.pendingInteractivePrompt.promptText === parsedPrompt.promptText) {
+                logger_1.logger.debug('Skipping heuristic prompt because tmux prompt is already active', {
+                    promptText: parsedPrompt.promptText,
+                });
+                return;
+            }
+            const toolDetails = this.buildToolDetailsForInteractivePrompt(data, tmuxPrompt?.snapshot);
+            const toolNameForMetadata = toolDetails.tool_name || this.mapToolNameForApproval(data.toolName);
+            const toolInputForMetadata = toolDetails.tool_input || this.buildFallbackToolInput(data);
+            const hasDetails = !!(toolNameForMetadata && toolInputForMetadata);
+            const promptPresentation = this.buildPromptPresentation(parsedPrompt);
+            const options = promptPresentation.options;
+            const fileLine = data.filePath ? `File: ${data.filePath}` : undefined;
+            let content = promptPresentation.content || `Codex is waiting for approval.\n${data.hint}`;
+            if (fileLine && !content.includes(fileLine)) {
+                content = `${content}\n${fileLine}`;
+            }
+            this.pendingInteractivePrompt = {
+                promptId: data.callId,
+                callId: data.callId,
+                kind: promptPresentation.kind,
+                options,
+                submitMap: promptPresentation.submitMap,
+                promptText: promptPresentation.promptText,
+                createdAt: Date.now(),
+                source: parsedPrompt ? 'tmux' : 'heuristic',
+                requiresFollowUpText: promptPresentation.requiresFollowUpText,
+            };
+            let metadata = {
+                isApprovalHint: true,
+                toolName: data.toolName,
+                toolInput: data.toolInput,
+                hint: data.hint,
+                callId: data.callId,
+                filePath: data.filePath,
+                diff: data.diff,
+                rawInput: data.rawInput,
+                tool_name: toolNameForMetadata,
+                tool_input: toolInputForMetadata,
+                has_details: hasDetails,
+                options,
+                instructions: promptPresentation.instructions,
+                prompt_source: parsedPrompt ? 'tmux' : 'heuristic',
+            };
+            let isEncrypted = false;
+            // Debug log before encryption so we can see what iOS should receive
+            logger_1.logger.debug('Interactive prompt (pre-encryption)', {
+                sessionId: this.sessionState.sessionId,
+                callId: data.callId,
+                contentPreview: content.substring(0, 200),
+                toolDetails,
+                metadata,
+            });
+            // Encrypt notification if we have a session key
+            if (this.sessionKey) {
+                content = codevibe_core_1.cryptoService.encryptContent(content, this.sessionKey);
+                const encryptedMetadata = codevibe_core_1.cryptoService.encryptMetadata(metadata, this.sessionKey);
+                metadata = { encrypted: encryptedMetadata };
+                isEncrypted = true;
+            }
+            await this.appSyncClient.createEvent({
+                sessionId: this.sessionState.sessionId,
+                type: codevibe_core_1.EventType.INTERACTIVE_PROMPT,
+                source: codevibe_core_1.EventSource.DESKTOP,
+                content,
+                metadata,
+                promptId: data.callId,
+                ...(isEncrypted ? { isEncrypted: true } : {}),
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to send approval interactive prompt:', error);
+        }
+    }
+    async handleTmuxPromptCandidate(snapshot) {
+        if (!this.sessionState) {
+            return;
+        }
+        const parsedPrompt = (0, prompt_parser_1.parseInteractivePrompt)(snapshot);
+        if (!parsedPrompt) {
+            return;
+        }
+        if (this.pendingInteractivePrompt &&
+            this.pendingInteractivePrompt.source === 'tmux' &&
+            this.pendingInteractivePrompt.promptText === parsedPrompt.promptText) {
+            return;
+        }
+        const promptPresentation = this.buildPromptPresentation(parsedPrompt);
+        const pendingCall = this.getMostRecentPendingToolCall();
+        const pendingCallContext = pendingCall ? this.buildApprovalPromptContextFromPendingCall(pendingCall) : null;
+        const toolDetails = pendingCallContext
+            ? this.buildToolDetailsForInteractivePrompt(pendingCallContext, snapshot)
+            : {};
+        const toolNameForMetadata = toolDetails.tool_name || this.mapToolNameForApproval(pendingCall?.name);
+        const toolInputForMetadata = toolDetails.tool_input || (pendingCallContext ? this.buildFallbackToolInput(pendingCallContext) : undefined);
+        const hasDetails = !!(toolNameForMetadata && toolInputForMetadata);
+        const promptId = this.pendingInteractivePrompt?.callId || pendingCall?.callId || (0, uuid_1.v4)();
+        this.pendingInteractivePrompt = {
+            promptId,
+            callId: this.pendingInteractivePrompt?.callId || pendingCall?.callId,
+            kind: promptPresentation.kind,
+            options: promptPresentation.options,
+            submitMap: promptPresentation.submitMap,
+            promptText: promptPresentation.promptText,
+            createdAt: Date.now(),
+            source: 'tmux',
+            requiresFollowUpText: promptPresentation.requiresFollowUpText,
+        };
+        let metadata = {
+            options: promptPresentation.options,
+            instructions: promptPresentation.instructions,
+            prompt_source: 'tmux_live',
+            tool_name: toolNameForMetadata,
+            tool_input: toolInputForMetadata,
+            has_details: hasDetails,
+        };
+        let content = promptPresentation.content;
+        let isEncrypted = false;
+        if (this.sessionKey) {
+            content = codevibe_core_1.cryptoService.encryptContent(content, this.sessionKey);
+            const encryptedMetadata = codevibe_core_1.cryptoService.encryptMetadata(metadata, this.sessionKey);
+            metadata = { encrypted: encryptedMetadata };
+            isEncrypted = true;
+        }
+        try {
+            await this.appSyncClient.createEvent({
+                sessionId: this.sessionState.sessionId,
+                type: codevibe_core_1.EventType.INTERACTIVE_PROMPT,
+                source: codevibe_core_1.EventSource.DESKTOP,
+                content,
+                metadata,
+                promptId,
+                ...(isEncrypted ? { isEncrypted: true } : {}),
+            });
+            logger_1.logger.info('Sent tmux-detected interactive prompt', {
+                sessionId: this.sessionState.sessionId,
+                promptText: parsedPrompt.promptText,
+                kind: parsedPrompt.kind,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to send tmux-detected interactive prompt', { error });
+        }
+    }
+    async startTmuxObserver() {
+        const tmuxSession = process.env.CODEVIBE_CODEX_TMUX_SESSION;
+        if (!tmuxSession) {
+            logger_1.logger.debug('Skipping tmux pane observer start - no tmux session in environment');
+            return;
+        }
+        try {
+            await this.tmuxPaneObserver.start(tmuxSession);
+        }
+        catch (error) {
+            logger_1.logger.warn('Failed to start tmux pane observer', { tmuxSession, error });
+        }
+    }
+    async tryParseInteractivePromptFromTmux() {
+        try {
+            const snapshot = await this.tmuxPaneObserver.captureSnapshot();
+            const parsed = (0, prompt_parser_1.parseInteractivePrompt)(snapshot);
+            logger_1.logger.debug('tmux prompt parse result', {
+                parsed: !!parsed,
+                kind: parsed?.kind,
+                promptText: parsed?.promptText,
+                snapshotPreview: this.summarizePromptSnapshot(snapshot),
+            });
+            return {
+                parsedPrompt: parsed,
+                snapshot,
+            };
+        }
+        catch (error) {
+            logger_1.logger.debug('tmux prompt parsing unavailable', { error });
+            return null;
+        }
+    }
+    buildPromptPresentation(parsedPrompt) {
+        if (parsedPrompt) {
+            return {
+                content: parsedPrompt.promptText,
+                promptText: parsedPrompt.promptText,
+                kind: parsedPrompt.kind,
+                options: parsedPrompt.options,
+                submitMap: parsedPrompt.submitMap,
+                instructions: this.buildPromptInstructions(parsedPrompt),
+                requiresFollowUpText: parsedPrompt.requiresFollowUpText,
+            };
+        }
+        return {
+            content: 'Codex is waiting for approval.',
+            promptText: 'Codex is waiting for approval.',
+            kind: 'yes_no',
+            options: [
+                { number: '1', text: 'Yes (sends "y")' },
+                { number: '2', text: 'No, tell Codex what to change (sends "n <instructions>")' },
+            ],
+            submitMap: {
+                '1': 'y',
+                '2': 'n',
+            },
+            instructions: 'Reply with 1 to approve, or 2 followed by what to change',
+            requiresFollowUpText: true,
+        };
+    }
+    getMostRecentPendingToolCall() {
+        const pendingCalls = this.approvalDetector.getPendingCalls();
+        if (pendingCalls.length === 0) {
+            return null;
+        }
+        return pendingCalls.reduce((latest, current) => {
+            return current.timestamp > latest.timestamp ? current : latest;
+        });
+    }
+    buildApprovalPromptContextFromPendingCall(pendingCall) {
+        return {
+            toolName: pendingCall.name,
+            filePath: pendingCall.filePath,
+            diff: pendingCall.diff,
+            toolInput: pendingCall.parsedInput,
+            rawInput: pendingCall.input,
+            hint: pendingCall.filePath ? `File: ${pendingCall.filePath}` : `Tool: ${this.mapToolNameForApproval(pendingCall.name) || pendingCall.name}`,
+        };
+    }
+    buildPromptInstructions(parsedPrompt) {
+        if (parsedPrompt.kind === 'yes_no' && parsedPrompt.requiresFollowUpText) {
+            return 'Reply with 1 to approve, or 2 followed by what to change';
+        }
+        if (parsedPrompt.kind === 'yes_no') {
+            return 'Reply with 1 for yes or 2 for no';
+        }
+        if (parsedPrompt.kind === 'numbered') {
+            return 'Reply with the number of the option you want';
+        }
+        return 'Reply with your response';
+    }
+    summarizePromptSnapshot(snapshot) {
+        return snapshot
+            .split('\n')
+            .map((line) => line.trimEnd())
+            .filter((line) => line.length > 0)
+            .slice(-12)
+            .map((line) => line.slice(0, 160))
+            .join('\n');
+    }
+    translatePromptResponse(input) {
+        const prompt = this.pendingInteractivePrompt;
+        if (!prompt) {
+            return { primaryInput: input };
+        }
+        const trimmed = input.trim();
+        const match = trimmed.match(/^(\d+)(?:\s+([\s\S]+))?$/);
+        if (!match) {
+            return { primaryInput: input };
+        }
+        const selected = match[1];
+        const followUpText = match[2]?.trim();
+        const mapped = prompt.submitMap[selected];
+        if (!mapped) {
+            return { primaryInput: input };
+        }
+        if (prompt.requiresFollowUpText && followUpText) {
+            return {
+                primaryInput: mapped,
+                followUpInput: followUpText,
+            };
+        }
+        return { primaryInput: mapped };
+    }
+    /**
+     * Build tool metadata for INTERACTIVE_PROMPT so iOS can render previews/diffs.
+     * The mobile app expects metadata JSON with tool_name/tool_input (same shape as TOOL_USE content).
+     */
+    buildToolDetailsForInteractivePrompt(data, snapshot) {
+        const toolName = data.toolName;
+        const parsedInput = data.toolInput && typeof data.toolInput === 'object' ? data.toolInput : undefined;
+        // apply_patch → expose an Edit payload with extracted old/new buffers for iOS diff rendering.
+        if (toolName === 'apply_patch') {
+            const content = data.diff || data.rawInput;
+            if (content) {
+                const { oldString, newString, oldStartLine, newStartLine } = this.extractOldNewFromPatch(content);
+                const snapshotLineAnchors = snapshot ? this.extractDiffLineAnchorsFromSnapshot(snapshot) : {};
+                return {
+                    tool_name: 'Edit',
+                    tool_input: {
+                        file_path: data.filePath,
+                        content,
+                        diff: data.diff,
+                        raw_patch: data.rawInput,
+                        old_string: oldString,
+                        new_string: newString,
+                        old_start_line: oldStartLine ?? snapshotLineAnchors.oldStartLine,
+                        new_start_line: newStartLine ?? snapshotLineAnchors.newStartLine,
+                    },
+                };
+            }
+        }
+        // shell_command / shell → treat as Bash so iOS shows command preview
+        if (toolName === 'shell_command' || toolName === 'shell') {
+            const command = parsedInput?.command || data.rawInput || data.hint;
+            if (command) {
+                return {
+                    tool_name: 'Bash',
+                    tool_input: {
+                        command,
+                        output: parsedInput?.output,
+                    },
+                };
+            }
+        }
+        // Fallback: include whatever context we have
+        const fallbackInput = {};
+        if (data.filePath)
+            fallbackInput.file_path = data.filePath;
+        if (data.diff)
+            fallbackInput.diff = data.diff;
+        if (data.rawInput)
+            fallbackInput.raw_input = data.rawInput;
+        if (Object.keys(fallbackInput).length > 0) {
+            return {
+                tool_name: toolName || 'Tool',
+                tool_input: fallbackInput,
+            };
+        }
+        return {};
+    }
+    /**
+     * Fallback tool input for interactive prompts (keeps file path + diff/raw input).
+     */
+    buildFallbackToolInput(data) {
+        const input = {};
+        if (data.filePath)
+            input.file_path = data.filePath;
+        if (data.diff)
+            input.diff = data.diff;
+        if (data.rawInput)
+            input.raw_input = data.rawInput;
+        if (data.toolInput && typeof data.toolInput === 'object') {
+            input.parsed_input = data.toolInput;
+        }
+        return Object.keys(input).length > 0 ? input : undefined;
+    }
+    /**
+     * Map Codex tool names to mobile-friendly labels for approval prompts.
+     */
+    mapToolNameForApproval(name) {
+        if (!name)
+            return undefined;
+        const mapping = {
+            apply_patch: 'Edit',
+            shell_command: 'Bash',
+            shell: 'Bash',
+        };
+        return mapping[name] || name;
+    }
+    /**
+     * Extract old/new buffers from an apply_patch diff so the iOS diff UI can render.
+     * Includes hunk context lines and preserves start-line metadata for single-hunk patches.
+     */
+    extractOldNewFromPatch(patch) {
+        const oldLines = [];
+        const newLines = [];
+        const hunkHeaderPattern = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+        let hunkCount = 0;
+        let currentOldLine = 0;
+        let currentNewLine = 0;
+        let oldStartLine;
+        let newStartLine;
+        for (const line of patch.split('\n')) {
+            const hunkMatch = line.match(hunkHeaderPattern);
+            if (hunkMatch) {
+                hunkCount += 1;
+                currentOldLine = Number.parseInt(hunkMatch[1], 10);
+                currentNewLine = Number.parseInt(hunkMatch[2], 10);
+                continue;
+            }
+            if (line.startsWith('***') ||
+                line.startsWith('---') ||
+                line.startsWith('+++') ||
+                line.startsWith('*** End Patch')) {
+                continue;
+            }
+            if (line.startsWith('-')) {
+                if (oldStartLine === undefined) {
+                    oldStartLine = currentOldLine;
+                }
+                oldLines.push(line.slice(1));
+                currentOldLine += 1;
+            }
+            else if (line.startsWith('+')) {
+                if (newStartLine === undefined) {
+                    newStartLine = currentNewLine;
+                }
+                newLines.push(line.slice(1));
+                currentNewLine += 1;
+            }
+            else if (line.startsWith(' ')) {
+                const contextLine = line.slice(1);
+                oldLines.push(contextLine);
+                newLines.push(contextLine);
+                currentOldLine += 1;
+                currentNewLine += 1;
+            }
+        }
+        // Use empty string instead of undefined so keys are always present in JSON
+        // This ensures iOS can detect the diff (checks for nil, not empty string)
+        return {
+            oldString: oldLines.join('\n'), // Empty string if no old lines (new file)
+            newString: newLines.join('\n'), // Empty string if no new lines (deleted file)
+            // Only attach exact start lines when the patch has a single hunk.
+            oldStartLine: hunkCount === 1 ? oldStartLine : undefined,
+            newStartLine: hunkCount === 1 ? newStartLine : undefined,
+        };
+    }
+    /**
+     * Codex's apply_patch payload often uses bare "@@" markers without absolute
+     * hunk coordinates. When that happens, recover visible line anchors from the
+     * tmux-rendered diff preview instead.
+     */
+    extractDiffLineAnchorsFromSnapshot(snapshot) {
+        const normalized = (0, prompt_parser_1.normalizeSnapshot)(snapshot);
+        let oldStartLine;
+        let newStartLine;
+        for (const line of normalized.split('\n')) {
+            const match = line.match(/^\s*(\d+)\s+(.*)$/);
+            if (!match) {
+                continue;
+            }
+            const lineNumber = Number.parseInt(match[1], 10);
+            const diffText = match[2];
+            if (!Number.isFinite(lineNumber)) {
+                continue;
+            }
+            if (diffText.startsWith('-')) {
+                oldStartLine ?? (oldStartLine = lineNumber);
+                continue;
+            }
+            if (diffText.startsWith('+')) {
+                newStartLine ?? (newStartLine = lineNumber);
+                continue;
+            }
+            oldStartLine ?? (oldStartLine = lineNumber);
+            newStartLine ?? (newStartLine = lineNumber);
+        }
+        logger_1.logger.debug('Recovered diff line anchors from tmux snapshot', {
+            oldStartLine,
+            newStartLine,
+            snapshotPreview: this.summarizePromptSnapshot(snapshot),
+        });
+        return { oldStartLine, newStartLine };
+    }
+    /**
+     * Subscribe to mobile events for this session
+     */
+    subscribeToMobileEvents(sessionId) {
+        logger_1.logger.info('Subscribing to mobile events', { sessionId });
+        // Clean up existing subscription
+        if (this.unsubscribe) {
+            this.unsubscribe();
+        }
+        this.unsubscribe = this.appSyncClient.subscribeToEvents(sessionId, async (event) => {
+            await this.handleMobileEvent(event);
+        }, (error) => {
+            logger_1.logger.error('Subscription error:', error);
+        });
+        if (this.sessionState) {
+            this.sessionState.subscriptionActive = true;
+        }
+        logger_1.logger.info('Subscribed to mobile events');
+    }
+    /**
+     * Download an attachment from S3 and save it to a temp file
+     * 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', {
+                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 - Codex CLI won't be able to view it properly
+            }
+            // Create temp directory for this session if it doesn't exist
+            const tempDir = path.join(os.tmpdir(), 'codevibe-codex', sessionId);
+            if (!fs.existsSync(tempDir)) {
+                fs.mkdirSync(tempDir, { 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 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,
+            });
+            return filePath;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to download attachment:', { id: attachment.id, error });
+            return null;
+        }
+    }
+    /**
+     * Handle event from mobile app
+     * If the event has attachments, downloads them and includes file paths in prompt
+     */
+    async handleMobileEvent(event) {
+        // Debug: log raw attachment data to diagnose isEncrypted issue
+        if (event.attachments && event.attachments.length > 0) {
+            logger_1.logger.info('DEBUG: Raw attachment data from subscription', {
+                attachments: JSON.stringify(event.attachments),
+                eventIsEncrypted: event.isEncrypted,
+            });
+        }
+        logger_1.logger.info('Received mobile event', {
+            eventId: event.eventId,
+            type: event.type,
+            content: event.content?.substring(0, 50),
+            attachmentCount: event.attachments?.length || 0,
+            isEncrypted: event.isEncrypted,
+        });
+        if (!this.sessionState) {
+            logger_1.logger.warn('Received mobile event but no active session');
+            return;
+        }
+        // Decrypt event 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;
+            }
+        }
+        // Update delivery status to DELIVERED
+        try {
+            await this.appSyncClient.updateEventStatus({
+                eventId: event.eventId,
+                sessionId: event.sessionId,
+                timestamp: event.timestamp,
+                deliveryStatus: codevibe_core_1.DeliveryStatus.DELIVERED,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to update delivery status:', error);
+        }
+        // Handle based on event type
+        if (event.type === codevibe_core_1.EventType.USER_PROMPT || event.type === codevibe_core_1.EventType.PROMPT_RESPONSE) {
+            let prompt = decryptedContent;
+            const attachments = event.attachments || [];
+            // 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, this.sessionState.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,
+                    });
+                }
+            }
+            const translated = this.translatePromptResponse(prompt);
+            const success = await this.promptResponder.sendInput(this.sessionState.sessionId, translated.primaryInput);
+            if (success && translated.followUpInput) {
+                await this.promptResponder.sendInput(this.sessionState.sessionId, translated.followUpInput);
+            }
+            if (success && this.pendingInteractivePrompt && event.type === codevibe_core_1.EventType.PROMPT_RESPONSE) {
+                this.pendingInteractivePrompt = null;
+            }
+            // Update status to EXECUTED if successful
+            if (success) {
+                try {
+                    await this.appSyncClient.updateEventStatus({
+                        eventId: event.eventId,
+                        sessionId: event.sessionId,
+                        timestamp: event.timestamp,
+                        deliveryStatus: codevibe_core_1.DeliveryStatus.EXECUTED,
+                    });
+                }
+                catch (error) {
+                    logger_1.logger.error('Failed to update executed status:', error);
+                }
+            }
+        }
+    }
+    /**
+     * Generate a backend session ID from Codex's runtime session ID.
+     *
+     * This keeps concurrent Codex sessions isolated even when they share the same
+     * working directory. The tradeoff is that cross-process resume is no longer
+     * represented as a single backend session.
+     */
+    generateSessionId(codexSessionId) {
+        return `codex-${codexSessionId}`;
+    }
+    /**
+     * Mark the current session inactive and clean up local state.
+     */
+    async endActiveSession(reason) {
+        if (!this.sessionState) {
+            return;
+        }
+        logger_1.logger.info('Ending active session', {
+            sessionId: this.sessionState.sessionId,
+            codexSessionId: this.sessionState.codexSessionId,
+            reason,
+        });
+        // Stop heartbeat
+        this.appSyncClient.stopHeartbeat(this.sessionState.sessionId);
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        await this.tmuxPaneObserver.stop();
+        this.pendingInteractivePrompt = null;
+        this.isInitializingSession = false;
+        this.bufferedLogEntries = [];
+        if (this.sessionKey) {
+            codevibe_core_1.keychainManager.clearSessionKey(this.sessionState.sessionId);
+            this.sessionKey = null;
+        }
+        try {
+            await this.appSyncClient.updateSession({
+                sessionId: this.sessionState.sessionId,
+                status: codevibe_core_1.SessionStatus.INACTIVE,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to update session status:', error);
+        }
+        this.sessionState = null;
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        logger_1.logger.info('Stopping CodeVibe Codex companion server');
+        // Mark any active session inactive and clean up
+        await this.endActiveSession('shutdown');
+        // Stop watching session logs
+        this.sessionWatcher.stop();
+        // Clear approval detector
+        this.approvalDetector.shutdown();
+        // Clear pending calls
+        (0, event_mapper_1.clearPendingCalls)();
+        // Cleanup subscriptions
+        this.appSyncClient.cleanupSubscriptions();
+        logger_1.logger.info('CodeVibe Codex companion server stopped');
+    }
+}
+// Main entry point
+const server = new CodexCompanionServer();
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+    logger_1.logger.info('Received SIGINT, shutting down...');
+    await server.stop();
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    logger_1.logger.info('Received SIGTERM, shutting down...');
+    await server.stop();
+    process.exit(0);
+});
+// Start the server
+server.start().catch((error) => {
+    logger_1.logger.error('Failed to start server:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=server.js.map