@quantiya/codevibe-codex-plugin 1.0.7 → 1.0.8

package/dist/event-mapper.js

@@ -1,302 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapLogEntryToEvent = mapLogEntryToEvent;
-exports.extractOldNewFromPatch = extractOldNewFromPatch;
-exports.extractFileFromPatch = extractFileFromPatch;
-exports.clearPendingCalls = clearPendingCalls;
-exports.getPendingCallsCount = getPendingCallsCount;
-exports.getPendingCall = getPendingCall;
-const uuid_1 = require("uuid");
-const codevibe_core_1 = require("@quantiya/codevibe-core");
-const logger_1 = require("./logger");
-/**
- * Maps Codex JSONL log entries to CodeVibe events
- *
- * Codex log entry types:
- * - session_meta: Session metadata (handled by watcher)
- * - event_msg: User/agent messages, reasoning, token counts
- * - response_item: Function calls and outputs
- * - turn_context: Turn metadata (ignored)
- */
-// Track pending function calls to match with outputs
-const pendingCalls = new Map();
-/**
- * Map a Codex log entry to a CodeVibe event
- * Returns null if the entry should not be synced
- */
-function mapLogEntryToEvent(entry, sessionId) {
-    const base = {
-        sessionId,
-        source: codevibe_core_1.EventSource.DESKTOP,
-    };
-    // Handle event_msg types
-    if (entry.type === 'event_msg' && entry.payload) {
-        const payloadType = entry.payload.type;
-        switch (payloadType) {
-            case 'user_message':
-                return {
-                    ...base,
-                    type: codevibe_core_1.EventType.USER_PROMPT,
-                    content: entry.payload.message || '',
-                    metadata: {
-                        images: entry.payload.images || [],
-                    },
-                };
-            case 'agent_message':
-                return {
-                    ...base,
-                    type: codevibe_core_1.EventType.ASSISTANT_RESPONSE,
-                    content: entry.payload.message || '',
-                };
-            case 'agent_reasoning':
-                // Send as REASONING event type for visual indicator in iOS
-                return {
-                    ...base,
-                    type: codevibe_core_1.EventType.REASONING,
-                    content: entry.payload.text || '',
-                };
-            case 'token_count':
-                // Skip token counts - could be used for metadata updates
-                logger_1.logger.debug('Skipping token_count entry');
-                return null;
-            default:
-                logger_1.logger.debug('Unknown event_msg type', { type: payloadType });
-                return null;
-        }
-    }
-    // Handle response_item types (tool calls)
-    if (entry.type === 'response_item' && entry.payload) {
-        const itemType = entry.payload.type;
-        // Function call start (shell commands, etc.)
-        if (itemType === 'function_call') {
-            const { name, arguments: args, call_id } = entry.payload;
-            // Parse arguments
-            let parsedArgs = {};
-            try {
-                parsedArgs = JSON.parse(args || '{}');
-            }
-            catch {
-                parsedArgs = { raw: args };
-            }
-            // Generate event ID so we can update it later
-            const eventId = (0, uuid_1.v4)();
-            // Store for matching with output
-            pendingCalls.set(call_id, {
-                name,
-                input: args,
-                eventId,
-            });
-            // Map tool name to friendly name
-            const toolName = mapToolName(name);
-            const content = formatToolCallContent(name, parsedArgs);
-            return {
-                ...base,
-                type: codevibe_core_1.EventType.TOOL_USE,
-                content,
-                metadata: {
-                    toolName,
-                    toolInput: parsedArgs,
-                    callId: call_id,
-                    status: 'running',
-                },
-            };
-        }
-        // Function call output
-        if (itemType === 'function_call_output') {
-            const { call_id, output } = entry.payload;
-            const pending = pendingCalls.get(call_id);
-            pendingCalls.delete(call_id);
-            const toolName = pending?.name ? mapToolName(pending.name) : 'Tool';
-            const truncatedOutput = truncateOutput(output, 500);
-            return {
-                ...base,
-                type: codevibe_core_1.EventType.TOOL_USE,
-                content: `${toolName} completed:\n${truncatedOutput}`,
-                metadata: {
-                    toolName,
-                    toolOutput: output,
-                    callId: call_id,
-                    status: 'completed',
-                },
-            };
-        }
-        // Custom tool call (file edits with apply_patch)
-        if (itemType === 'custom_tool_call') {
-            const { name, call_id, input, status } = entry.payload;
-            // Store for matching with output
-            pendingCalls.set(call_id, {
-                name,
-                input,
-                eventId: (0, uuid_1.v4)(),
-            });
-            // Parse the patch to extract file info and diff content
-            const fileInfo = extractFileFromPatch(input);
-            const { oldString, newString } = extractOldNewFromPatch(input);
-            const content = fileInfo
-                ? `Editing: ${fileInfo.filePath}`
-                : `Applying patch`;
-            return {
-                ...base,
-                type: codevibe_core_1.EventType.TOOL_USE,
-                content,
-                metadata: {
-                    tool_name: 'Edit',
-                    tool_input: {
-                        file_path: fileInfo?.filePath || '',
-                        old_string: oldString,
-                        new_string: newString,
-                    },
-                    callId: call_id,
-                    status: status || 'running',
-                },
-            };
-        }
-        // Custom tool call output
-        if (itemType === 'custom_tool_call_output') {
-            const { call_id, output } = entry.payload;
-            const pending = pendingCalls.get(call_id);
-            pendingCalls.delete(call_id);
-            // Parse output JSON
-            let parsedOutput = {};
-            try {
-                parsedOutput = JSON.parse(output || '{}');
-            }
-            catch {
-                parsedOutput = { raw: output };
-            }
-            const success = parsedOutput.output?.includes('Success') || !parsedOutput.error;
-            return {
-                ...base,
-                type: codevibe_core_1.EventType.TOOL_USE,
-                content: success ? 'File edit applied successfully' : `Edit failed: ${parsedOutput.error || 'Unknown error'}`,
-                metadata: {
-                    toolName: 'Edit',
-                    toolOutput: parsedOutput,
-                    callId: call_id,
-                    status: 'completed',
-                    success,
-                },
-            };
-        }
-        logger_1.logger.debug('Unknown response_item type', { type: itemType });
-        return null;
-    }
-    // Skip turn_context and other types
-    if (entry.type === 'turn_context') {
-        logger_1.logger.debug('Skipping turn_context entry');
-        return null;
-    }
-    logger_1.logger.debug('Unhandled log entry type', { type: entry.type });
-    return null;
-}
-/**
- * Map Codex tool names to friendly display names
- */
-function mapToolName(name) {
-    const mapping = {
-        'shell_command': 'Bash',
-        'shell': 'Bash',
-        'apply_patch': 'Edit',
-        'write_file': 'Write',
-        'read_file': 'Read',
-        'list_files': 'Glob',
-        'search_files': 'Grep',
-        'web_search': 'WebSearch',
-        'web_fetch': 'WebFetch',
-    };
-    return mapping[name] || name;
-}
-/**
- * Format tool call content for display
- */
-function formatToolCallContent(name, args) {
-    switch (name) {
-        case 'shell_command':
-        case 'shell':
-            return `Running: ${args.command || 'command'}`;
-        case 'read_file':
-            return `Reading: ${args.file_path || args.path || 'file'}`;
-        case 'write_file':
-            return `Writing: ${args.file_path || args.path || 'file'}`;
-        case 'list_files':
-            return `Listing: ${args.path || '.'}`;
-        case 'search_files':
-            return `Searching for: ${args.pattern || args.query || 'pattern'}`;
-        case 'web_search':
-            return `Searching web: ${args.query || 'query'}`;
-        default:
-            return `Running ${mapToolName(name)}`;
-    }
-}
-/**
- * Extract old and new strings from a Codex apply_patch payload.
- * Parses unified-diff-style hunks into old/new content for iOS diff preview.
- */
-function extractOldNewFromPatch(patch) {
-    const oldLines = [];
-    const newLines = [];
-    const hunkHeaderPattern = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
-    for (const line of patch.split('\n')) {
-        if (hunkHeaderPattern.test(line) || line.startsWith('***') || line.startsWith('---') || line.startsWith('+++')) {
-            continue;
-        }
-        if (line.startsWith('-')) {
-            oldLines.push(line.slice(1));
-        }
-        else if (line.startsWith('+')) {
-            newLines.push(line.slice(1));
-        }
-        else if (line.startsWith(' ')) {
-            const ctx = line.slice(1);
-            oldLines.push(ctx);
-            newLines.push(ctx);
-        }
-    }
-    return {
-        oldString: oldLines.join('\n'),
-        newString: newLines.join('\n'),
-    };
-}
-/**
- * Extract file path from patch content
- * Patch format: *** Begin Patch\n*** Update File: path\n...
- */
-function extractFileFromPatch(input) {
-    if (!input)
-        return null;
-    // Match "*** Update File: path" or "*** Add File: path"
-    const match = input.match(/\*\*\* (?:Update|Add|Delete) File: (.+)/);
-    if (match) {
-        return { filePath: match[1].trim() };
-    }
-    return null;
-}
-/**
- * Truncate output for display
- */
-function truncateOutput(output, maxLength) {
-    if (!output)
-        return '';
-    if (output.length <= maxLength)
-        return output;
-    return output.substring(0, maxLength) + '...';
-}
-/**
- * Clear pending calls (call on session end)
- */
-function clearPendingCalls() {
-    pendingCalls.clear();
-}
-/**
- * Get count of pending calls (for approval detection)
- */
-function getPendingCallsCount() {
-    return pendingCalls.size;
-}
-/**
- * Get pending call info by ID
- */
-function getPendingCall(callId) {
-    return pendingCalls.get(callId);
-}
-//# sourceMappingURL=event-mapper.js.map

package/dist/key-manager.js

@@ -1,287 +0,0 @@
-"use strict";
-//
-// key-manager.ts
-// CodeVibe Codex Plugin
-//
-// Manages device encryption keys and session keys for E2E encryption
-//
-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 });
-exports.keyManager = exports.KeyManager = exports.KeyManagerError = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const uuid_1 = require("uuid");
-const crypto_service_1 = require("./crypto-service");
-const logger_1 = require("./logger");
-// Errors that can occur during key management
-class KeyManagerError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'KeyManagerError';
-    }
-}
-exports.KeyManagerError = KeyManagerError;
-// Storage directory for keys
-const CONFIG_DIR = path.join(os.homedir(), '.codevibe-codex');
-const DEVICE_KEY_FILE = 'device-key.json';
-/**
- * Manages device and session encryption keys
- */
-class KeyManager {
-    constructor() {
-        this.deviceKey = null;
-        this.sessionKeyCache = new Map(); // sessionId -> base64 session key
-        this.isRegistered = false;
-        this.ensureConfigDir();
-        this.loadDeviceKey();
-    }
-    static getInstance() {
-        if (!KeyManager.instance) {
-            KeyManager.instance = new KeyManager();
-        }
-        return KeyManager.instance;
-    }
-    // MARK: - Device Key Management
-    /**
-     * Get or generate the device ID
-     */
-    getDeviceId() {
-        if (this.deviceKey) {
-            return this.deviceKey.deviceId;
-        }
-        // Generate and store new device key if none exists
-        this.generateAndStoreDeviceKey();
-        return this.deviceKey.deviceId;
-    }
-    /**
-     * Get the current device's key pair, generating if needed
-     */
-    getOrCreateDeviceKeyPair() {
-        if (!this.deviceKey) {
-            this.generateAndStoreDeviceKey();
-        }
-        return {
-            privateKey: this.deviceKey.privateKey,
-            publicKey: this.deviceKey.publicKey,
-        };
-    }
-    /**
-     * Get the device's public key (base64)
-     */
-    getDevicePublicKey() {
-        const keyPair = this.getOrCreateDeviceKeyPair();
-        return keyPair.publicKey;
-    }
-    /**
-     * Check if we have a device key
-     */
-    hasDeviceKey() {
-        return this.deviceKey !== null;
-    }
-    /**
-     * Check if device key is registered with backend
-     */
-    getIsRegistered() {
-        return this.isRegistered;
-    }
-    /**
-     * Set registration status
-     */
-    setIsRegistered(registered) {
-        this.isRegistered = registered;
-    }
-    // MARK: - Session Key Management
-    /**
-     * Get session key for a session, decrypting from encryptedKeys if needed
-     */
-    getSessionKey(sessionId, encryptedKeys) {
-        // Check cache first
-        const cachedKey = this.sessionKeyCache.get(sessionId);
-        if (cachedKey) {
-            return cachedKey;
-        }
-        // Try to decrypt from encrypted keys
-        if (!encryptedKeys || encryptedKeys.length === 0) {
-            return null;
-        }
-        const deviceId = this.getDeviceId();
-        const ourEncryptedKey = encryptedKeys.find((k) => k.deviceId === deviceId);
-        if (!ourEncryptedKey) {
-            return null;
-        }
-        // Load our private key
-        if (!this.deviceKey) {
-            throw new KeyManagerError('Device key not found');
-        }
-        // Decrypt session key
-        const sessionKey = crypto_service_1.cryptoService.decryptSessionKey(ourEncryptedKey, this.deviceKey.privateKey);
-        // Cache for future use
-        this.sessionKeyCache.set(sessionId, sessionKey);
-        return sessionKey;
-    }
-    /**
-     * Generate and encrypt a new session key for all devices
-     */
-    createSessionKey(devicePublicKeys) {
-        // Generate random session key
-        const sessionKey = crypto_service_1.cryptoService.generateSessionKey();
-        // Encrypt for each device
-        const encryptedKeys = devicePublicKeys.map((device) => {
-            const encrypted = crypto_service_1.cryptoService.encryptSessionKey(sessionKey, device.publicKey);
-            return {
-                deviceId: device.deviceId,
-                encryptedKey: encrypted.encryptedKey,
-                ephemeralPublicKey: encrypted.ephemeralPublicKey,
-            };
-        });
-        return { sessionKey, encryptedKeys };
-    }
-    /**
-     * Cache a session key (after successfully decrypting or creating)
-     */
-    cacheSessionKey(sessionId, sessionKey) {
-        this.sessionKeyCache.set(sessionId, sessionKey);
-    }
-    /**
-     * Clear cached session key (on session end)
-     */
-    clearSessionKey(sessionId) {
-        this.sessionKeyCache.delete(sessionId);
-    }
-    /**
-     * Clear all cached session keys (on sign out)
-     */
-    clearAllSessionKeys() {
-        this.sessionKeyCache.clear();
-    }
-    // MARK: - Key Storage
-    ensureConfigDir() {
-        if (!fs.existsSync(CONFIG_DIR)) {
-            fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-        }
-    }
-    getKeyFilePath() {
-        return path.join(CONFIG_DIR, DEVICE_KEY_FILE);
-    }
-    loadDeviceKey() {
-        const keyFilePath = this.getKeyFilePath();
-        if (!fs.existsSync(keyFilePath)) {
-            this.deviceKey = null;
-            return;
-        }
-        try {
-            const data = fs.readFileSync(keyFilePath, 'utf8');
-            const stored = JSON.parse(data);
-            this.deviceKey = stored.device;
-            logger_1.logger.info(`[KeyManager] Loaded device key: ${this.deviceKey.deviceId}`);
-        }
-        catch (error) {
-            logger_1.logger.error(`[KeyManager] Failed to load device key: ${error}`);
-            this.deviceKey = null;
-        }
-    }
-    saveDeviceKey() {
-        if (!this.deviceKey) {
-            return;
-        }
-        const keyFilePath = this.getKeyFilePath();
-        const stored = {
-            device: this.deviceKey,
-        };
-        try {
-            fs.writeFileSync(keyFilePath, JSON.stringify(stored, null, 2), {
-                mode: 0o600, // Owner read/write only
-            });
-            logger_1.logger.info(`[KeyManager] Saved device key: ${this.deviceKey.deviceId}`);
-        }
-        catch (error) {
-            logger_1.logger.error(`[KeyManager] Failed to save device key: ${error}`);
-            throw new KeyManagerError(`Failed to save device key: ${error}`);
-        }
-    }
-    generateAndStoreDeviceKey() {
-        const keyPair = crypto_service_1.cryptoService.generateKeyPair();
-        const deviceId = (0, uuid_1.v4)().toUpperCase();
-        this.deviceKey = {
-            deviceId,
-            privateKey: keyPair.privateKey,
-            publicKey: keyPair.publicKey,
-            createdAt: new Date().toISOString(),
-        };
-        this.saveDeviceKey();
-        logger_1.logger.info(`[KeyManager] Generated new device key: ${deviceId}`);
-    }
-    // MARK: - Helpers
-    /**
-     * Get device name for registration
-     */
-    getDeviceName() {
-        return os.hostname() || 'CLI Client';
-    }
-    /**
-     * Get platform for registration
-     */
-    getDevicePlatform() {
-        const platform = os.platform();
-        if (platform === 'darwin') {
-            return 'MACOS';
-        }
-        else if (platform === 'linux') {
-            return 'LINUX';
-        }
-        else if (platform === 'win32') {
-            return 'WINDOWS';
-        }
-        return 'CLI';
-    }
-    /**
-     * Clear all encryption data (on sign out)
-     */
-    clearAllData() {
-        const keyFilePath = this.getKeyFilePath();
-        if (fs.existsSync(keyFilePath)) {
-            fs.unlinkSync(keyFilePath);
-        }
-        this.deviceKey = null;
-        this.sessionKeyCache.clear();
-        this.isRegistered = false;
-        logger_1.logger.info('[KeyManager] Cleared all encryption data');
-    }
-}
-exports.KeyManager = KeyManager;
-// Export singleton instance
-exports.keyManager = KeyManager.getInstance();
-//# sourceMappingURL=key-manager.js.map

package/dist/logger.js

@@ -1,18 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-/**
- * Plugin-specific logger for CodeVibe Codex Plugin
- */
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const codevibe_core_1 = require("@quantiya/codevibe-core");
-exports.logger = (0, codevibe_core_1.createLogger)({
-    name: 'codevibe-codex',
-    logFile: path_1.default.join(os_1.default.tmpdir(), 'codevibe-codex-mcp.log'),
-    level: 'debug',
-});
-//# sourceMappingURL=logger.js.map

package/dist/prompt-parser.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeSnapshot = exports.parseInteractivePrompt = void 0;
-// Re-export shared prompt parser from codevibe-core
-var codevibe_core_1 = require("@quantiya/codevibe-core");
-Object.defineProperty(exports, "parseInteractivePrompt", { enumerable: true, get: function () { return codevibe_core_1.parseInteractivePrompt; } });
-Object.defineProperty(exports, "normalizeSnapshot", { enumerable: true, get: function () { return codevibe_core_1.normalizeSnapshot; } });
-//# sourceMappingURL=prompt-parser.js.map

package/dist/prompt-responder.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptResponder = void 0;
-const child_process_1 = require("child_process");
-const util_1 = require("util");
-const logger_1 = require("./logger");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
-class PromptResponder {
-    /**
-     * Send input to the Codex CLI via tmux
-     * Requires tmux session (set by codevibe-codex wrapper)
-     */
-    async sendInput(sessionId, input) {
-        logger_1.logger.info('Attempting to send input to Codex', { sessionId, input });
-        try {
-            const tmuxSession = process.env.CODEVIBE_CODEX_TMUX_SESSION;
-            if (!tmuxSession) {
-                logger_1.logger.error('No tmux session found - codevibe-codex wrapper is required', {
-                    sessionId,
-                    hint: 'Start Codex CLI using the codevibe-codex wrapper script',
-                });
-                return false;
-            }
-            logger_1.logger.info('Using tmux send-keys', { tmuxSession });
-            await this.sendViaTmux(tmuxSession, input);
-            logger_1.logger.info('Successfully sent input to Codex', { sessionId, input });
-            return true;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to send input to Codex', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return false;
-        }
-    }
-    /**
-     * Send input via tmux send-keys
-     * Works even when screen is locked
-     */
-    async sendViaTmux(sessionName, input) {
-        // Escape special characters for tmux
-        const escaped = input
-            .replace(/\\/g, '\\\\')
-            .replace(/"/g, '\\"')
-            .replace(/\$/g, '\\$')
-            .replace(/`/g, '\\`');
-        logger_1.logger.info('Sending via tmux', { sessionName, inputLength: input.length });
-        try {
-            // Send the input text
-            const textCmd = `tmux send-keys -t "${sessionName}" -l "${escaped}"`;
-            await execAsync(textCmd);
-            // Wait for text to be processed
-            await this.delay(500);
-            // Send Enter key
-            const enterCmd = `tmux send-keys -t "${sessionName}" Enter`;
-            await execAsync(enterCmd);
-            logger_1.logger.info('tmux send-keys completed');
-        }
-        catch (error) {
-            logger_1.logger.error('tmux send-keys failed', { sessionName, error });
-            throw error;
-        }
-    }
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Check if input looks like an approval response
-     */
-    isApprovalResponse(content) {
-        const normalized = content.trim().toLowerCase();
-        const approvalResponses = ['y', 'n', 'a', 'q', 'e', 'yes', 'no'];
-        return approvalResponses.includes(normalized) || /^[0-9]+$/.test(normalized);
-    }
-}
-exports.PromptResponder = PromptResponder;
-//# sourceMappingURL=prompt-responder.js.map