@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.1

package/node_modules/@quantiya/codevibe-core/dist/keychain/keychain-manager.d.ts

@@ -0,0 +1,125 @@
+import { DeviceIdentity, TokenData, EncryptedSessionKey } from '../types';
+/**
+ * Error class for keychain operations
+ */
+export declare class KeychainError extends Error {
+    constructor(message: string);
+}
+/**
+ * Manages device identity and OAuth tokens using native keychain
+ */
+export declare class KeychainManager {
+    private static instance;
+    private deviceIdentity;
+    private sessionKeyCache;
+    private isRegistered;
+    private _serviceName;
+    private constructor();
+    /**
+     * Get the keychain service name (lazy-loaded from config)
+     */
+    private get serviceName();
+    static getInstance(): KeychainManager;
+    /**
+     * Get the device identity from keychain
+     */
+    getDeviceIdentity(): Promise<DeviceIdentity | null>;
+    /**
+     * Set the device identity in keychain
+     */
+    setDeviceIdentity(identity: DeviceIdentity): Promise<void>;
+    /**
+     * Get or create device identity
+     */
+    getOrCreateDeviceIdentity(): Promise<DeviceIdentity>;
+    /**
+     * Get device ID (creates identity if needed)
+     */
+    getDeviceId(): Promise<string>;
+    /**
+     * Get device public key (creates identity if needed)
+     */
+    getDevicePublicKey(): Promise<string>;
+    /**
+     * Get device private key (creates identity if needed)
+     */
+    getDevicePrivateKey(): Promise<string>;
+    /**
+     * Check if device identity exists
+     */
+    hasDeviceIdentity(): Promise<boolean>;
+    /**
+     * Delete device identity (reset device)
+     */
+    deleteDeviceIdentity(): Promise<void>;
+    /**
+     * Get token account name for environment
+     */
+    private getTokenAccount;
+    /**
+     * Get OAuth tokens for environment
+     */
+    getTokens(environment?: string): Promise<TokenData | null>;
+    /**
+     * Save OAuth tokens for environment
+     */
+    setTokens(tokens: TokenData, environment?: string): Promise<void>;
+    /**
+     * Delete OAuth tokens for environment
+     */
+    deleteTokens(environment?: string): Promise<boolean>;
+    /**
+     * Check if token is expired
+     */
+    isTokenExpired(tokens: TokenData): boolean;
+    /**
+     * Get session key for a session, decrypting from encryptedKeys if needed
+     */
+    getSessionKey(sessionId: string, encryptedKeys?: EncryptedSessionKey[]): Promise<string | null>;
+    /**
+     * Generate and encrypt a new session key for all devices
+     */
+    createSessionKey(devicePublicKeys: Array<{
+        deviceId: string;
+        publicKey: string;
+    }>): {
+        sessionKey: string;
+        encryptedKeys: EncryptedSessionKey[];
+    };
+    /**
+     * Cache a session key
+     */
+    cacheSessionKey(sessionId: string, sessionKey: string): void;
+    /**
+     * Clear cached session key
+     */
+    clearSessionKey(sessionId: string): void;
+    /**
+     * Clear all cached session keys
+     */
+    clearAllSessionKeys(): void;
+    /**
+     * Get registration status
+     */
+    getIsRegistered(): boolean;
+    /**
+     * Set registration status
+     */
+    setIsRegistered(registered: boolean): void;
+    /**
+     * Get device name for registration
+     */
+    getDeviceName(): string;
+    /**
+     * Get platform for registration
+     */
+    getDevicePlatform(): string;
+    /**
+     * Clear all data (device identity + all tokens)
+     */
+    clearAllData(): Promise<void>;
+}
+/**
+ * Export singleton instance
+ */
+export declare const keychainManager: KeychainManager;

package/node_modules/@quantiya/codevibe-core/dist/keychain/keychain-manager.js

@@ -0,0 +1,375 @@
+"use strict";
+//
+// keychain-manager.ts
+// CodeVibe Core
+//
+// Manages device encryption keys and OAuth tokens using native keychain
+// Uses keytar for cross-platform keychain access:
+// - macOS: Keychain
+// - Linux: libsecret
+// - Windows: Credential Manager
+//
+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.keychainManager = exports.KeychainManager = exports.KeychainError = void 0;
+const os = __importStar(require("os"));
+const uuid_1 = require("uuid");
+const keytar = __importStar(require("keytar"));
+const crypto_1 = require("../crypto");
+const config_1 = require("../config");
+const logger_1 = require("../logger");
+/**
+ * Error class for keychain operations
+ */
+class KeychainError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'KeychainError';
+    }
+}
+exports.KeychainError = KeychainError;
+// Keychain account names
+const DEVICE_IDENTITY_ACCOUNT = 'device-identity';
+const TOKEN_ACCOUNT_PREFIX = 'tokens-'; // tokens-development, tokens-production
+/**
+ * Manages device identity and OAuth tokens using native keychain
+ */
+class KeychainManager {
+    constructor() {
+        this.deviceIdentity = null;
+        this.sessionKeyCache = new Map();
+        this.isRegistered = false;
+        this._serviceName = null;
+        // Service name is lazy-loaded to avoid calling getConfig() before config is initialized
+    }
+    /**
+     * Get the keychain service name (lazy-loaded from config)
+     */
+    get serviceName() {
+        if (!this._serviceName) {
+            this._serviceName = (0, config_1.getConfig)().keychain.serviceName;
+        }
+        return this._serviceName;
+    }
+    static getInstance() {
+        if (!KeychainManager.instance) {
+            KeychainManager.instance = new KeychainManager();
+        }
+        return KeychainManager.instance;
+    }
+    // MARK: - Device Identity Management
+    /**
+     * Get the device identity from keychain
+     */
+    async getDeviceIdentity() {
+        if (this.deviceIdentity) {
+            return this.deviceIdentity;
+        }
+        try {
+            const data = await keytar.getPassword(this.serviceName, DEVICE_IDENTITY_ACCOUNT);
+            if (!data) {
+                return null;
+            }
+            this.deviceIdentity = JSON.parse(data);
+            logger_1.logger.info(`[KeychainManager] Loaded device identity: ${this.deviceIdentity.deviceId}`);
+            return this.deviceIdentity;
+        }
+        catch (error) {
+            logger_1.logger.error(`[KeychainManager] Failed to load device identity: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Set the device identity in keychain
+     */
+    async setDeviceIdentity(identity) {
+        try {
+            await keytar.setPassword(this.serviceName, DEVICE_IDENTITY_ACCOUNT, JSON.stringify(identity));
+            this.deviceIdentity = identity;
+            logger_1.logger.info(`[KeychainManager] Saved device identity: ${identity.deviceId}`);
+        }
+        catch (error) {
+            logger_1.logger.error(`[KeychainManager] Failed to save device identity: ${error}`);
+            throw new KeychainError(`Failed to save device identity: ${error}`);
+        }
+    }
+    /**
+     * Get or create device identity
+     */
+    async getOrCreateDeviceIdentity() {
+        let identity = await this.getDeviceIdentity();
+        if (identity) {
+            return identity;
+        }
+        // Generate new device identity
+        const keyPair = crypto_1.cryptoService.generateKeyPair();
+        identity = {
+            deviceId: (0, uuid_1.v4)().toUpperCase(),
+            privateKey: keyPair.privateKey,
+            publicKey: keyPair.publicKey,
+            createdAt: new Date().toISOString(),
+        };
+        await this.setDeviceIdentity(identity);
+        logger_1.logger.info(`[KeychainManager] Generated new device identity: ${identity.deviceId}`);
+        return identity;
+    }
+    /**
+     * Get device ID (creates identity if needed)
+     */
+    async getDeviceId() {
+        const identity = await this.getOrCreateDeviceIdentity();
+        return identity.deviceId;
+    }
+    /**
+     * Get device public key (creates identity if needed)
+     */
+    async getDevicePublicKey() {
+        const identity = await this.getOrCreateDeviceIdentity();
+        return identity.publicKey;
+    }
+    /**
+     * Get device private key (creates identity if needed)
+     */
+    async getDevicePrivateKey() {
+        const identity = await this.getOrCreateDeviceIdentity();
+        return identity.privateKey;
+    }
+    /**
+     * Check if device identity exists
+     */
+    async hasDeviceIdentity() {
+        const identity = await this.getDeviceIdentity();
+        return identity !== null;
+    }
+    /**
+     * Delete device identity (reset device)
+     */
+    async deleteDeviceIdentity() {
+        try {
+            await keytar.deletePassword(this.serviceName, DEVICE_IDENTITY_ACCOUNT);
+            this.deviceIdentity = null;
+            this.sessionKeyCache.clear();
+            this.isRegistered = false;
+            logger_1.logger.info('[KeychainManager] Deleted device identity');
+        }
+        catch (error) {
+            logger_1.logger.error(`[KeychainManager] Failed to delete device identity: ${error}`);
+            throw new KeychainError(`Failed to delete device identity: ${error}`);
+        }
+    }
+    // MARK: - Token Management
+    /**
+     * Get token account name for environment
+     */
+    getTokenAccount(environment) {
+        return `${TOKEN_ACCOUNT_PREFIX}${environment}`;
+    }
+    /**
+     * Get OAuth tokens for environment
+     */
+    async getTokens(environment = 'production') {
+        try {
+            const data = await keytar.getPassword(this.serviceName, this.getTokenAccount(environment));
+            if (!data) {
+                return null;
+            }
+            const tokens = JSON.parse(data);
+            logger_1.logger.debug(`[KeychainManager] Loaded tokens for ${environment}`);
+            return tokens;
+        }
+        catch (error) {
+            logger_1.logger.error(`[KeychainManager] Failed to load tokens: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Save OAuth tokens for environment
+     */
+    async setTokens(tokens, environment = 'production') {
+        try {
+            await keytar.setPassword(this.serviceName, this.getTokenAccount(environment), JSON.stringify(tokens));
+            logger_1.logger.info(`[KeychainManager] Saved tokens for ${environment}`, {
+                userId: tokens.userId,
+                email: tokens.email,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error(`[KeychainManager] Failed to save tokens: ${error}`);
+            throw new KeychainError(`Failed to save tokens: ${error}`);
+        }
+    }
+    /**
+     * Delete OAuth tokens for environment
+     */
+    async deleteTokens(environment = 'production') {
+        try {
+            const deleted = await keytar.deletePassword(this.serviceName, this.getTokenAccount(environment));
+            if (deleted) {
+                logger_1.logger.info(`[KeychainManager] Deleted tokens for ${environment}`);
+            }
+            return deleted;
+        }
+        catch (error) {
+            logger_1.logger.error(`[KeychainManager] Failed to delete tokens: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Check if token is expired
+     */
+    isTokenExpired(tokens) {
+        const bufferMs = 5 * 60 * 1000; // 5 minutes buffer
+        return Date.now() >= (tokens.expiresAt - bufferMs);
+    }
+    // MARK: - Session Key Management
+    /**
+     * Get session key for a session, decrypting from encryptedKeys if needed
+     */
+    async 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 = await this.getDeviceId();
+        const ourEncryptedKey = encryptedKeys.find((k) => k.deviceId === deviceId);
+        if (!ourEncryptedKey) {
+            logger_1.logger.warn(`[KeychainManager] Device ${deviceId} not found in encryptedKeys`);
+            return null;
+        }
+        // Get our private key
+        const privateKey = await this.getDevicePrivateKey();
+        // Decrypt session key
+        const sessionKey = crypto_1.cryptoService.decryptSessionKey(ourEncryptedKey, privateKey);
+        // Cache for future use
+        this.sessionKeyCache.set(sessionId, sessionKey);
+        logger_1.logger.info(`[KeychainManager] Decrypted and cached session key for ${sessionId}`);
+        return sessionKey;
+    }
+    /**
+     * Generate and encrypt a new session key for all devices
+     */
+    createSessionKey(devicePublicKeys) {
+        // Generate random session key
+        const sessionKey = crypto_1.cryptoService.generateSessionKey();
+        // Encrypt for each device
+        const encryptedKeys = devicePublicKeys.map((device) => {
+            const encrypted = crypto_1.cryptoService.encryptSessionKey(sessionKey, device.publicKey);
+            return {
+                deviceId: device.deviceId,
+                encryptedKey: encrypted.encryptedKey,
+                ephemeralPublicKey: encrypted.ephemeralPublicKey,
+            };
+        });
+        logger_1.logger.info(`[KeychainManager] Created session key for ${devicePublicKeys.length} devices`);
+        return { sessionKey, encryptedKeys };
+    }
+    /**
+     * Cache a session key
+     */
+    cacheSessionKey(sessionId, sessionKey) {
+        this.sessionKeyCache.set(sessionId, sessionKey);
+    }
+    /**
+     * Clear cached session key
+     */
+    clearSessionKey(sessionId) {
+        this.sessionKeyCache.delete(sessionId);
+    }
+    /**
+     * Clear all cached session keys
+     */
+    clearAllSessionKeys() {
+        this.sessionKeyCache.clear();
+    }
+    // MARK: - Registration Status
+    /**
+     * Get registration status
+     */
+    getIsRegistered() {
+        return this.isRegistered;
+    }
+    /**
+     * Set registration status
+     */
+    setIsRegistered(registered) {
+        this.isRegistered = registered;
+    }
+    // MARK: - Device Info
+    /**
+     * 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';
+    }
+    // MARK: - Full Reset
+    /**
+     * Clear all data (device identity + all tokens)
+     */
+    async clearAllData() {
+        await this.deleteDeviceIdentity();
+        await this.deleteTokens('development');
+        await this.deleteTokens('production');
+        this.sessionKeyCache.clear();
+        this.isRegistered = false;
+        logger_1.logger.info('[KeychainManager] Cleared all data');
+    }
+}
+exports.KeychainManager = KeychainManager;
+/**
+ * Export singleton instance
+ */
+exports.keychainManager = KeychainManager.getInstance();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keychain-manager.js","sourceRoot":"","sources":["../../src/keychain/keychain-manager.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// keychain-manager.ts\n// CodeVibe Core\n//\n// Manages device encryption keys and OAuth tokens using native keychain\n// Uses keytar for cross-platform keychain access:\n// - macOS: Keychain\n// - Linux: libsecret\n// - Windows: Credential Manager\n//\n\nimport * as os from 'os';\nimport { v4 as uuidv4 } from 'uuid';\nimport * as keytar from 'keytar';\nimport { DeviceIdentity, TokenData, EncryptedSessionKey } from '../types';\nimport { cryptoService } from '../crypto';\nimport { getConfig } from '../config';\nimport { logger } from '../logger';\n\n/**\n * Error class for keychain operations\n */\nexport class KeychainError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'KeychainError';\n  }\n}\n\n// Keychain account names\nconst DEVICE_IDENTITY_ACCOUNT = 'device-identity';\nconst TOKEN_ACCOUNT_PREFIX = 'tokens-'; // tokens-development, tokens-production\n\n/**\n * Manages device identity and OAuth tokens using native keychain\n */\nexport class KeychainManager {\n  private static instance: KeychainManager;\n  private deviceIdentity: DeviceIdentity | null = null;\n  private sessionKeyCache: Map<string, string> = new Map();\n  private isRegistered: boolean = false;\n  private _serviceName: string | null = null;\n\n  private constructor() {\n    // Service name is lazy-loaded to avoid calling getConfig() before config is initialized\n  }\n\n  /**\n   * Get the keychain service name (lazy-loaded from config)\n   */\n  private get serviceName(): string {\n    if (!this._serviceName) {\n      this._serviceName = getConfig().keychain.serviceName;\n    }\n    return this._serviceName;\n  }\n\n  static getInstance(): KeychainManager {\n    if (!KeychainManager.instance) {\n      KeychainManager.instance = new KeychainManager();\n    }\n    return KeychainManager.instance;\n  }\n\n  // MARK: - Device Identity Management\n\n  /**\n   * Get the device identity from keychain\n   */\n  async getDeviceIdentity(): Promise<DeviceIdentity | null> {\n    if (this.deviceIdentity) {\n      return this.deviceIdentity;\n    }\n\n    try {\n      const data = await keytar.getPassword(this.serviceName, DEVICE_IDENTITY_ACCOUNT);\n      if (!data) {\n        return null;\n      }\n\n      this.deviceIdentity = JSON.parse(data);\n      logger.info(`[KeychainManager] Loaded device identity: ${this.deviceIdentity!.deviceId}`);\n      return this.deviceIdentity;\n    } catch (error) {\n      logger.error(`[KeychainManager] Failed to load device identity: ${error}`);\n      return null;\n    }\n  }\n\n  /**\n   * Set the device identity in keychain\n   */\n  async setDeviceIdentity(identity: DeviceIdentity): Promise<void> {\n    try {\n      await keytar.setPassword(\n        this.serviceName,\n        DEVICE_IDENTITY_ACCOUNT,\n        JSON.stringify(identity)\n      );\n      this.deviceIdentity = identity;\n      logger.info(`[KeychainManager] Saved device identity: ${identity.deviceId}`);\n    } catch (error) {\n      logger.error(`[KeychainManager] Failed to save device identity: ${error}`);\n      throw new KeychainError(`Failed to save device identity: ${error}`);\n    }\n  }\n\n  /**\n   * Get or create device identity\n   */\n  async getOrCreateDeviceIdentity(): Promise<DeviceIdentity> {\n    let identity = await this.getDeviceIdentity();\n    if (identity) {\n      return identity;\n    }\n\n    // Generate new device identity\n    const keyPair = cryptoService.generateKeyPair();\n    identity = {\n      deviceId: uuidv4().toUpperCase(),\n      privateKey: keyPair.privateKey,\n      publicKey: keyPair.publicKey,\n      createdAt: new Date().toISOString(),\n    };\n\n    await this.setDeviceIdentity(identity);\n    logger.info(`[KeychainManager] Generated new device identity: ${identity.deviceId}`);\n    return identity;\n  }\n\n  /**\n   * Get device ID (creates identity if needed)\n   */\n  async getDeviceId(): Promise<string> {\n    const identity = await this.getOrCreateDeviceIdentity();\n    return identity.deviceId;\n  }\n\n  /**\n   * Get device public key (creates identity if needed)\n   */\n  async getDevicePublicKey(): Promise<string> {\n    const identity = await this.getOrCreateDeviceIdentity();\n    return identity.publicKey;\n  }\n\n  /**\n   * Get device private key (creates identity if needed)\n   */\n  async getDevicePrivateKey(): Promise<string> {\n    const identity = await this.getOrCreateDeviceIdentity();\n    return identity.privateKey;\n  }\n\n  /**\n   * Check if device identity exists\n   */\n  async hasDeviceIdentity(): Promise<boolean> {\n    const identity = await this.getDeviceIdentity();\n    return identity !== null;\n  }\n\n  /**\n   * Delete device identity (reset device)\n   */\n  async deleteDeviceIdentity(): Promise<void> {\n    try {\n      await keytar.deletePassword(this.serviceName, DEVICE_IDENTITY_ACCOUNT);\n      this.deviceIdentity = null;\n      this.sessionKeyCache.clear();\n      this.isRegistered = false;\n      logger.info('[KeychainManager] Deleted device identity');\n    } catch (error) {\n      logger.error(`[KeychainManager] Failed to delete device identity: ${error}`);\n      throw new KeychainError(`Failed to delete device identity: ${error}`);\n    }\n  }\n\n  // MARK: - Token Management\n\n  /**\n   * Get token account name for environment\n   */\n  private getTokenAccount(environment: string): string {\n    return `${TOKEN_ACCOUNT_PREFIX}${environment}`;\n  }\n\n  /**\n   * Get OAuth tokens for environment\n   */\n  async getTokens(environment: string = 'production'): Promise<TokenData | null> {\n    try {\n      const data = await keytar.getPassword(this.serviceName, this.getTokenAccount(environment));\n      if (!data) {\n        return null;\n      }\n\n      const tokens: TokenData = JSON.parse(data);\n      logger.debug(`[KeychainManager] Loaded tokens for ${environment}`);\n      return tokens;\n    } catch (error) {\n      logger.error(`[KeychainManager] Failed to load tokens: ${error}`);\n      return null;\n    }\n  }\n\n  /**\n   * Save OAuth tokens for environment\n   */\n  async setTokens(tokens: TokenData, environment: string = 'production'): Promise<void> {\n    try {\n      await keytar.setPassword(\n        this.serviceName,\n        this.getTokenAccount(environment),\n        JSON.stringify(tokens)\n      );\n      logger.info(`[KeychainManager] Saved tokens for ${environment}`, {\n        userId: tokens.userId,\n        email: tokens.email,\n      });\n    } catch (error) {\n      logger.error(`[KeychainManager] Failed to save tokens: ${error}`);\n      throw new KeychainError(`Failed to save tokens: ${error}`);\n    }\n  }\n\n  /**\n   * Delete OAuth tokens for environment\n   */\n  async deleteTokens(environment: string = 'production'): Promise<boolean> {\n    try {\n      const deleted = await keytar.deletePassword(this.serviceName, this.getTokenAccount(environment));\n      if (deleted) {\n        logger.info(`[KeychainManager] Deleted tokens for ${environment}`);\n      }\n      return deleted;\n    } catch (error) {\n      logger.error(`[KeychainManager] Failed to delete tokens: ${error}`);\n      return false;\n    }\n  }\n\n  /**\n   * Check if token is expired\n   */\n  isTokenExpired(tokens: TokenData): boolean {\n    const bufferMs = 5 * 60 * 1000; // 5 minutes buffer\n    return Date.now() >= (tokens.expiresAt - bufferMs);\n  }\n\n  // MARK: - Session Key Management\n\n  /**\n   * Get session key for a session, decrypting from encryptedKeys if needed\n   */\n  async getSessionKey(\n    sessionId: string,\n    encryptedKeys?: EncryptedSessionKey[]\n  ): Promise<string | null> {\n    // Check cache first\n    const cachedKey = this.sessionKeyCache.get(sessionId);\n    if (cachedKey) {\n      return cachedKey;\n    }\n\n    // Try to decrypt from encrypted keys\n    if (!encryptedKeys || encryptedKeys.length === 0) {\n      return null;\n    }\n\n    const deviceId = await this.getDeviceId();\n    const ourEncryptedKey = encryptedKeys.find((k) => k.deviceId === deviceId);\n    if (!ourEncryptedKey) {\n      logger.warn(`[KeychainManager] Device ${deviceId} not found in encryptedKeys`);\n      return null;\n    }\n\n    // Get our private key\n    const privateKey = await this.getDevicePrivateKey();\n\n    // Decrypt session key\n    const sessionKey = cryptoService.decryptSessionKey(ourEncryptedKey, privateKey);\n\n    // Cache for future use\n    this.sessionKeyCache.set(sessionId, sessionKey);\n    logger.info(`[KeychainManager] Decrypted and cached session key for ${sessionId}`);\n\n    return sessionKey;\n  }\n\n  /**\n   * Generate and encrypt a new session key for all devices\n   */\n  createSessionKey(\n    devicePublicKeys: Array<{ deviceId: string; publicKey: string }>\n  ): { sessionKey: string; encryptedKeys: EncryptedSessionKey[] } {\n    // Generate random session key\n    const sessionKey = cryptoService.generateSessionKey();\n\n    // Encrypt for each device\n    const encryptedKeys: EncryptedSessionKey[] = devicePublicKeys.map((device) => {\n      const encrypted = cryptoService.encryptSessionKey(\n        sessionKey,\n        device.publicKey\n      );\n\n      return {\n        deviceId: device.deviceId,\n        encryptedKey: encrypted.encryptedKey,\n        ephemeralPublicKey: encrypted.ephemeralPublicKey,\n      };\n    });\n\n    logger.info(`[KeychainManager] Created session key for ${devicePublicKeys.length} devices`);\n    return { sessionKey, encryptedKeys };\n  }\n\n  /**\n   * Cache a session key\n   */\n  cacheSessionKey(sessionId: string, sessionKey: string): void {\n    this.sessionKeyCache.set(sessionId, sessionKey);\n  }\n\n  /**\n   * Clear cached session key\n   */\n  clearSessionKey(sessionId: string): void {\n    this.sessionKeyCache.delete(sessionId);\n  }\n\n  /**\n   * Clear all cached session keys\n   */\n  clearAllSessionKeys(): void {\n    this.sessionKeyCache.clear();\n  }\n\n  // MARK: - Registration Status\n\n  /**\n   * Get registration status\n   */\n  getIsRegistered(): boolean {\n    return this.isRegistered;\n  }\n\n  /**\n   * Set registration status\n   */\n  setIsRegistered(registered: boolean): void {\n    this.isRegistered = registered;\n  }\n\n  // MARK: - Device Info\n\n  /**\n   * Get device name for registration\n   */\n  getDeviceName(): string {\n    return os.hostname() || 'CLI Client';\n  }\n\n  /**\n   * Get platform for registration\n   */\n  getDevicePlatform(): string {\n    const platform = os.platform();\n    if (platform === 'darwin') {\n      return 'MACOS';\n    } else if (platform === 'linux') {\n      return 'LINUX';\n    } else if (platform === 'win32') {\n      return 'WINDOWS';\n    }\n    return 'CLI';\n  }\n\n  // MARK: - Full Reset\n\n  /**\n   * Clear all data (device identity + all tokens)\n   */\n  async clearAllData(): Promise<void> {\n    await this.deleteDeviceIdentity();\n    await this.deleteTokens('development');\n    await this.deleteTokens('production');\n    this.sessionKeyCache.clear();\n    this.isRegistered = false;\n    logger.info('[KeychainManager] Cleared all data');\n  }\n}\n\n/**\n * Export singleton instance\n */\nexport const keychainManager = KeychainManager.getInstance();\n"]}

package/node_modules/@quantiya/codevibe-core/dist/logger/index.d.ts

@@ -0,0 +1 @@
+export { Logger, logger, createLogger } from './logger';

package/node_modules/@quantiya/codevibe-core/dist/logger/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = exports.logger = exports.Logger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return logger_1.createLogger; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbG9nZ2VyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQUF3RDtBQUEvQyxnR0FBQSxNQUFNLE9BQUE7QUFBRSxnR0FBQSxNQUFNLE9BQUE7QUFBRSxzR0FBQSxZQUFZLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBMb2dnZXIsIGxvZ2dlciwgY3JlYXRlTG9nZ2VyIH0gZnJvbSAnLi9sb2dnZXInO1xuIl19

package/node_modules/@quantiya/codevibe-core/dist/logger/logger.d.ts

@@ -0,0 +1,35 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerOptions {
+    name: string;
+    logFile?: string;
+    level?: LogLevel;
+    console?: boolean;
+}
+/**
+ * Simple logger for CodeVibe plugins
+ */
+export declare class Logger {
+    private name;
+    private logFile?;
+    private level;
+    private enableConsole;
+    constructor(options: LoggerOptions);
+    private ensureLogDir;
+    private shouldLog;
+    private formatMessage;
+    private log;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, data?: any): void;
+    setLevel(level: LogLevel): void;
+}
+/**
+ * Create a logger with custom options
+ */
+export declare function createLogger(options: LoggerOptions): Logger;
+/**
+ * Default shared logger instance
+ */
+export declare const logger: Logger;
+export {};