@quantiya/codevibe-claude-plugin 1.0.11 → 1.0.12

package/dist/http-api.js

@@ -1,334 +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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpApi = void 0;
-const express_1 = __importDefault(require("express"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const codevibe_core_1 = require("@quantiya/codevibe-core");
-const logger_1 = require("./logger");
-const types_1 = require("./types");
-class HttpApi {
-    constructor() {
-        this.assignedPort = 0;
-        this.app = (0, express_1.default)();
-        this.setupMiddleware();
-        this.setupRoutes();
-    }
-    /**
-     * Set the session ID for this server instance (used for port file naming)
-     */
-    setSessionId(sessionId) {
-        this.sessionId = sessionId;
-    }
-    /**
-     * Get the assigned port after server starts
-     */
-    getPort() {
-        return this.assignedPort;
-    }
-    setupMiddleware() {
-        // Parse JSON bodies
-        this.app.use(express_1.default.json({ limit: '1mb' }));
-        // Request logging
-        this.app.use((req, res, next) => {
-            logger_1.logger.debug(`${req.method} ${req.path}`, {
-                body: req.body,
-                query: req.query,
-            });
-            next();
-        });
-        // Error handling middleware
-        this.app.use((err, req, res, next) => {
-            logger_1.logger.error('Express error:', err);
-            const response = {
-                success: false,
-                error: err.message || 'Internal server error',
-            };
-            res.status(500).json(response);
-        });
-    }
-    setupRoutes() {
-        // Health check endpoint
-        this.app.get('/health', this.handleHealth.bind(this));
-        // Event endpoint for hooks
-        this.app.post('/event', this.handleEvent.bind(this));
-        // Development testing endpoint
-        if (process.env.NODE_ENV !== 'production') {
-            this.app.post('/test/execute', this.handleTestExecute.bind(this));
-        }
-    }
-    handleHealth(req, res) {
-        const response = {
-            success: true,
-            data: {
-                status: 'healthy',
-                uptime: process.uptime(),
-                version: '0.1.0',
-                timestamp: new Date().toISOString(),
-            },
-        };
-        res.json(response);
-    }
-    async handleEvent(req, res) {
-        try {
-            const hookInput = req.body;
-            // Validate required fields
-            if (!hookInput.session_id) {
-                const response = {
-                    success: false,
-                    error: 'Missing required field: session_id',
-                };
-                res.status(400).json(response);
-                return;
-            }
-            if (!hookInput.hook_event_name) {
-                const response = {
-                    success: false,
-                    error: 'Missing required field: hook_event_name',
-                };
-                res.status(400).json(response);
-                return;
-            }
-            // Transform hook input to event payload
-            const eventPayload = this.transformHookToEvent(hookInput);
-            logger_1.logger.info('Received event from hook', {
-                sessionId: hookInput.session_id,
-                hookEvent: hookInput.hook_event_name,
-                type: eventPayload.type,
-            });
-            // Call event handler if registered
-            if (this.eventHandler) {
-                await this.eventHandler(eventPayload);
-            }
-            else {
-                logger_1.logger.warn('No event handler registered');
-            }
-            const response = {
-                success: true,
-                message: 'Event processed successfully',
-            };
-            res.json(response);
-        }
-        catch (error) {
-            logger_1.logger.error('Error handling event:', error);
-            const response = {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-            res.status(500).json(response);
-        }
-    }
-    async handleTestExecute(req, res) {
-        try {
-            const { sessionId, prompt } = req.body;
-            if (!sessionId || !prompt) {
-                const response = {
-                    success: false,
-                    error: 'Missing required fields: sessionId, prompt',
-                };
-                res.status(400).json(response);
-                return;
-            }
-            logger_1.logger.info('Test execute request', { sessionId, prompt });
-            const response = {
-                success: true,
-                message: 'Test execution endpoint - not implemented yet',
-                data: { sessionId, prompt },
-            };
-            res.json(response);
-        }
-        catch (error) {
-            logger_1.logger.error('Error in test execute:', error);
-            const response = {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-            res.status(500).json(response);
-        }
-    }
-    transformHookToEvent(hookInput) {
-        let type;
-        let content;
-        const metadata = {
-            cwd: hookInput.cwd,
-            hook_event_name: hookInput.hook_event_name,
-            ...(hookInput.metadata || {}), // Merge any metadata from hook
-        };
-        // Check if hook explicitly provides type and content (from Stop hook transcript parsing)
-        if (hookInput.type && hookInput.content !== undefined) {
-            type = hookInput.type;
-            content = hookInput.content;
-        }
-        else {
-            // Determine event type and content based on hook event name
-            switch (hookInput.hook_event_name) {
-                case 'SessionStart':
-                    type = types_1.EventType.NOTIFICATION;
-                    content = 'Session started';
-                    metadata.source = hookInput.source;
-                    break;
-                case 'SessionEnd':
-                    type = types_1.EventType.NOTIFICATION;
-                    content = `Session ended: ${hookInput.reason || 'unknown'}`;
-                    metadata.reason = hookInput.reason;
-                    break;
-                case 'UserPromptSubmit':
-                    type = types_1.EventType.USER_PROMPT;
-                    content = hookInput.prompt || '';
-                    break;
-                case 'PostToolUse':
-                    type = types_1.EventType.TOOL_USE;
-                    content = JSON.stringify({
-                        tool_name: hookInput.tool_name,
-                        tool_input: hookInput.tool_input,
-                        tool_response: hookInput.tool_response,
-                    });
-                    metadata.tool_name = hookInput.tool_name;
-                    break;
-                case 'Notification':
-                    type = types_1.EventType.NOTIFICATION;
-                    content = hookInput.message || '';
-                    metadata.notification_type = hookInput.notification_type;
-                    break;
-                default:
-                    type = types_1.EventType.NOTIFICATION;
-                    content = `Hook event: ${hookInput.hook_event_name}`;
-            }
-        }
-        return {
-            session_id: hookInput.session_id,
-            hook_event_name: hookInput.hook_event_name,
-            type,
-            source: types_1.EventSource.DESKTOP, // Events from hooks are always from desktop
-            content,
-            metadata,
-        };
-    }
-    // Register event handler
-    onEvent(handler) {
-        this.eventHandler = handler;
-    }
-    // Start the HTTP server with dynamic port allocation
-    async start(sessionId) {
-        // Use provided sessionId or the one set earlier
-        const sid = sessionId || this.sessionId;
-        if (sid) {
-            this.sessionId = sid;
-        }
-        return new Promise((resolve, reject) => {
-            try {
-                const config = (0, codevibe_core_1.getConfig)();
-                // Use port 0 for dynamic allocation, or configured port as fallback
-                const requestedPort = config.server.dynamicPort ? 0 : config.server.port;
-                this.server = this.app.listen(requestedPort, config.server.host, () => {
-                    const address = this.server.address();
-                    this.assignedPort = address.port;
-                    logger_1.logger.info(`HTTP API listening on http://${config.server.host}:${this.assignedPort}`);
-                    // Write port to session-specific file for hooks to discover
-                    if (this.sessionId) {
-                        this.writePortFile(this.sessionId, this.assignedPort);
-                    }
-                    resolve(this.assignedPort);
-                });
-                this.server.on('error', (error) => {
-                    logger_1.logger.error('HTTP server error:', error);
-                    reject(error);
-                });
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Write port to a session-specific file for hooks to discover
-     */
-    writePortFile(sessionId, port) {
-        const portFilePath = path.join(os.tmpdir(), `codevibe-claude-${sessionId}.port`);
-        try {
-            fs.writeFileSync(portFilePath, port.toString());
-            logger_1.logger.info(`Port file written: ${portFilePath} -> ${port}`);
-        }
-        catch (error) {
-            logger_1.logger.error(`Failed to write port file: ${portFilePath}`, error);
-        }
-    }
-    /**
-     * Remove the port file on shutdown
-     */
-    removePortFile() {
-        if (this.sessionId) {
-            const portFilePath = path.join(os.tmpdir(), `codevibe-claude-${this.sessionId}.port`);
-            try {
-                if (fs.existsSync(portFilePath)) {
-                    fs.unlinkSync(portFilePath);
-                    logger_1.logger.info(`Port file removed: ${portFilePath}`);
-                }
-            }
-            catch (error) {
-                logger_1.logger.warn(`Failed to remove port file: ${portFilePath}`, error);
-            }
-        }
-    }
-    // Stop the HTTP server
-    async stop() {
-        return new Promise((resolve, reject) => {
-            // Remove port file first
-            this.removePortFile();
-            if (this.server) {
-                this.server.close((err) => {
-                    if (err) {
-                        logger_1.logger.error('Error stopping HTTP server:', err);
-                        reject(err);
-                    }
-                    else {
-                        logger_1.logger.info('HTTP API stopped');
-                        resolve();
-                    }
-                });
-            }
-            else {
-                resolve();
-            }
-        });
-    }
-}
-exports.HttpApi = HttpApi;
-//# sourceMappingURL=http-api.js.map

package/dist/key-manager.js

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