@quantiya/codevibe-gemini-plugin 1.0.6 → 1.0.8

package/dist/key-manager.js

@@ -1,287 +0,0 @@
-"use strict";
-//
-// key-manager.ts
-// CodeVibe Gemini 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-gemini');
-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 Gemini 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-gemini',
-    logFile: path_1.default.join(os_1.default.tmpdir(), 'codevibe-gemini-mcp.log'),
-    level: 'info',
-});
-//# sourceMappingURL=logger.js.map

package/dist/prompt-responder.js

@@ -1,132 +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 {
-    /**
-     * Answer an interactive prompt by sending input to the waiting Gemini process
-     * Requires tmux session (set by codevibe-gemini wrapper)
-     */
-    async answerInteractivePrompt(sessionId, response) {
-        logger_1.logger.info('Attempting to answer interactive prompt', {
-            sessionId,
-            response,
-        });
-        try {
-            // Check if running in tmux (set by codevibe-gemini wrapper)
-            const tmuxSession = process.env.CODEVIBE_GEMINI_TMUX_SESSION;
-            logger_1.logger.info('Checking tmux session environment', {
-                tmuxSession: tmuxSession || '(not set)',
-                allEnvKeys: Object.keys(process.env).filter(k => k.includes('CODEVIBE') || k.includes('TMUX')),
-            });
-            if (!tmuxSession) {
-                logger_1.logger.error('No tmux session found - codevibe-gemini wrapper is required', {
-                    sessionId,
-                    hint: 'Start Gemini CLI using the codevibe-gemini wrapper script',
-                });
-                return false;
-            }
-            // Use tmux send-keys (works even when screen is locked)
-            logger_1.logger.info('Using tmux send-keys', { tmuxSession });
-            await this.sendViaTmux(tmuxSession, response);
-            logger_1.logger.info('Successfully sent response to interactive prompt', {
-                sessionId,
-                response,
-            });
-            return true;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to answer interactive prompt', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return false;
-        }
-    }
-    /**
-     * Send input via tmux send-keys
-     * Works even when screen is locked - this is the only supported method
-     */
-    async sendViaTmux(sessionName, input) {
-        // Escape special characters for tmux
-        // tmux send-keys interprets certain sequences, so we need to escape them
-        const escaped = input
-            .replace(/\\/g, '\\\\') // Escape backslashes first
-            .replace(/"/g, '\\"') // Escape double quotes
-            .replace(/\$/g, '\\$') // Escape dollar signs
-            .replace(/`/g, '\\`'); // Escape backticks
-        logger_1.logger.info('Sending via tmux', { sessionName, inputLength: input.length });
-        try {
-            // Step 1: Send the input text (without Enter)
-            const textCmd = `tmux send-keys -t "${sessionName}" -l "${escaped}"`;
-            const textResult = await execAsync(textCmd);
-            logger_1.logger.info('tmux send-keys (text) completed', {
-                stdout: textResult.stdout || '(empty)',
-                stderr: textResult.stderr || '(empty)'
-            });
-            // Step 2: Wait for the text to be processed by the terminal
-            // Longer delay needed for Gemini CLI's interactive prompts
-            await this.delay(500);
-            // Step 3: Send Enter key separately
-            const enterCmd = `tmux send-keys -t "${sessionName}" Enter`;
-            const enterResult = await execAsync(enterCmd);
-            logger_1.logger.info('tmux send-keys (Enter) completed', {
-                stdout: enterResult.stdout || '(empty)',
-                stderr: enterResult.stderr || '(empty)'
-            });
-        }
-        catch (error) {
-            logger_1.logger.error('tmux send-keys failed', { sessionName, error });
-            throw error;
-        }
-    }
-    /**
-     * Simple delay helper
-     */
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Check if a response looks like an answer to an interactive prompt
-     * Covers Y/N prompts, numbered choices, and other common responses
-     */
-    isPromptResponse(content) {
-        const normalized = content.trim().toLowerCase();
-        // Y/N responses
-        if (normalized === 'y' ||
-            normalized === 'n' ||
-            normalized === 'yes' ||
-            normalized === 'no') {
-            return true;
-        }
-        // Numbered choices (1-9, or just digits)
-        if (/^[0-9]+$/.test(normalized)) {
-            return true;
-        }
-        // Single letter choices (a, b, c, etc.)
-        if (/^[a-z]$/.test(normalized)) {
-            return true;
-        }
-        // Common terminal control inputs
-        // These are typically responses to prompts, not new commands
-        const controlInputs = [
-            'exit',
-            'quit',
-            'q',
-            'continue',
-            'skip',
-            'abort',
-            'retry',
-            'cancel',
-        ];
-        if (controlInputs.includes(normalized)) {
-            return true;
-        }
-        return false;
-    }
-}
-exports.PromptResponder = PromptResponder;
-//# sourceMappingURL=prompt-responder.js.map

package/dist/token-storage.js

@@ -1,169 +0,0 @@
-"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 });
-exports.saveTokens = saveTokens;
-exports.loadTokens = loadTokens;
-exports.deleteTokens = deleteTokens;
-exports.isTokenExpired = isTokenExpired;
-exports.isAuthenticated = isAuthenticated;
-exports.getTokenFilePath = getTokenFilePath;
-exports.getTokenExpiration = getTokenExpiration;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const logger_1 = require("./logger");
-// Token storage location - environment-specific
-const TOKEN_DIR = path.join(os.homedir(), '.codevibe-gemini');
-// Get environment-specific token file
-function getTokenFile() {
-    const environment = process.env.ENVIRONMENT || 'production';
-    return path.join(TOKEN_DIR, `tokens-${environment}.json`);
-}
-/**
- * Ensure the token directory exists with proper permissions
- */
-function ensureTokenDir() {
-    if (!fs.existsSync(TOKEN_DIR)) {
-        fs.mkdirSync(TOKEN_DIR, { mode: 0o700 }); // rwx------
-        logger_1.logger.debug('Created token directory', { path: TOKEN_DIR });
-    }
-}
-/**
- * Save tokens to secure file storage
- */
-function saveTokens(tokens) {
-    try {
-        ensureTokenDir();
-        const tokenFile = getTokenFile();
-        const content = JSON.stringify(tokens, null, 2);
-        fs.writeFileSync(tokenFile, content, { mode: 0o600 }); // rw-------
-        logger_1.logger.info('Tokens saved successfully', {
-            userId: tokens.userId,
-            email: tokens.email,
-            expiresAt: new Date(tokens.expiresAt).toISOString(),
-            environment: process.env.ENVIRONMENT || 'production',
-        });
-    }
-    catch (error) {
-        logger_1.logger.error('Failed to save tokens:', error);
-        throw new Error(`Failed to save tokens: ${error}`);
-    }
-}
-/**
- * Load tokens from secure file storage
- * Returns null if no tokens are stored or if they're invalid
- */
-function loadTokens() {
-    try {
-        const tokenFile = getTokenFile();
-        if (!fs.existsSync(tokenFile)) {
-            logger_1.logger.debug('No tokens file found', { environment: process.env.ENVIRONMENT || 'production' });
-            return null;
-        }
-        const content = fs.readFileSync(tokenFile, 'utf-8');
-        const tokens = JSON.parse(content);
-        // Validate required fields
-        if (!tokens.accessToken || !tokens.refreshToken || !tokens.expiresAt) {
-            logger_1.logger.warn('Invalid tokens file - missing required fields');
-            return null;
-        }
-        logger_1.logger.debug('Tokens loaded', {
-            userId: tokens.userId,
-            email: tokens.email,
-            expiresAt: new Date(tokens.expiresAt).toISOString(),
-            isExpired: isTokenExpired(tokens),
-        });
-        return tokens;
-    }
-    catch (error) {
-        logger_1.logger.error('Failed to load tokens:', error);
-        return null;
-    }
-}
-/**
- * Delete stored tokens (logout)
- */
-function deleteTokens() {
-    try {
-        const tokenFile = getTokenFile();
-        if (fs.existsSync(tokenFile)) {
-            fs.unlinkSync(tokenFile);
-            logger_1.logger.info('Tokens deleted successfully', { environment: process.env.ENVIRONMENT || 'production' });
-            return true;
-        }
-        logger_1.logger.debug('No tokens file to delete', { environment: process.env.ENVIRONMENT || 'production' });
-        return false;
-    }
-    catch (error) {
-        logger_1.logger.error('Failed to delete tokens:', error);
-        return false;
-    }
-}
-/**
- * Check if the access token is expired or about to expire
- * Considers token expired if less than 5 minutes remaining
- */
-function isTokenExpired(tokens) {
-    const bufferMs = 5 * 60 * 1000; // 5 minutes buffer
-    return Date.now() >= (tokens.expiresAt - bufferMs);
-}
-/**
- * Check if user is authenticated (has valid, non-expired tokens)
- */
-function isAuthenticated() {
-    const tokens = loadTokens();
-    if (!tokens) {
-        return false;
-    }
-    // Even if access token is expired, we can refresh if we have a refresh token
-    return !!tokens.refreshToken;
-}
-/**
- * Get the token file path (for display purposes)
- */
-function getTokenFilePath() {
-    return getTokenFile();
-}
-/**
- * Get token expiration date
- */
-function getTokenExpiration() {
-    const tokens = loadTokens();
-    if (!tokens) {
-        return null;
-    }
-    return new Date(tokens.expiresAt);
-}
-//# sourceMappingURL=token-storage.js.map