@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.2

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

@@ -0,0 +1,118 @@
+import { EncryptedSessionKey, KeyPair } from '../types';
+/**
+ * Error class for cryptographic operations
+ */
+export declare class CryptoError extends Error {
+    constructor(message: string);
+}
+/**
+ * Current encryption version for future algorithm upgrades
+ */
+export declare const ENCRYPTION_VERSION = 1;
+/**
+ * Service for end-to-end encryption operations
+ */
+export declare class CryptoService {
+    private static instance;
+    private constructor();
+    static getInstance(): CryptoService;
+    /**
+     * Generate a new ECDH P-256 key pair
+     * @returns Object with privateKey (base64), publicKey (base64 raw)
+     */
+    generateKeyPair(): KeyPair;
+    /**
+     * Generate a random 256-bit session key
+     * @returns Base64-encoded session key
+     */
+    generateSessionKey(): string;
+    /**
+     * Derive a shared secret using ECDH and HKDF
+     * @param privateKeyBase64 Our private key (base64)
+     * @param publicKeyBase64 Other party's public key (base64)
+     * @returns 256-bit derived key as Buffer
+     */
+    deriveSharedKey(privateKeyBase64: string, publicKeyBase64: string): Buffer;
+    /**
+     * Encrypt a session key for a target device using ECDH
+     * @param sessionKeyBase64 The session key to encrypt (base64)
+     * @param targetPublicKeyBase64 Target device's public key (base64)
+     * @returns EncryptedSessionKey containing encrypted key and ephemeral public key
+     */
+    encryptSessionKey(sessionKeyBase64: string, targetPublicKeyBase64: string): Omit<EncryptedSessionKey, 'deviceId'>;
+    /**
+     * Decrypt a session key using our private key
+     * @param encryptedSessionKey The encrypted session key data
+     * @param privateKeyBase64 Our device's private key (base64)
+     * @returns Decrypted session key (base64)
+     */
+    decryptSessionKey(encryptedSessionKey: EncryptedSessionKey, privateKeyBase64: string): string;
+    /**
+     * Encrypt content using AES-256-GCM
+     * @param content String content to encrypt
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Base64-encoded ciphertext (nonce + ciphertext + tag)
+     */
+    encryptContent(content: string, sessionKeyBase64: string): string;
+    /**
+     * Decrypt content using AES-256-GCM
+     * @param encryptedContent Base64-encoded ciphertext
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Decrypted string content
+     */
+    decryptContent(encryptedContent: string, sessionKeyBase64: string): string;
+    /**
+     * Encrypt JSON-serializable metadata
+     * @param metadata Object to encrypt
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Base64-encoded encrypted JSON
+     */
+    encryptMetadata(metadata: Record<string, any>, sessionKeyBase64: string): string;
+    /**
+     * Decrypt encrypted metadata
+     * @param encryptedMetadata Base64-encoded encrypted JSON
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Decrypted object
+     */
+    decryptMetadata(encryptedMetadata: string, sessionKeyBase64: string): Record<string, any>;
+    /**
+     * Encrypt binary data using AES-256-GCM
+     * @param data Binary data to encrypt (Buffer)
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Encrypted data (Buffer containing nonce + ciphertext + tag)
+     */
+    encryptData(data: Buffer, sessionKeyBase64: string): Buffer;
+    /**
+     * Decrypt binary data using AES-256-GCM
+     * @param encryptedData Encrypted data (Buffer containing nonce + ciphertext + tag)
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Decrypted binary data (Buffer)
+     */
+    decryptData(encryptedData: Buffer, sessionKeyBase64: string): Buffer;
+    /**
+     * Encrypt data using AES-256-GCM
+     * @param data Data to encrypt
+     * @param key Symmetric key (32 bytes)
+     * @returns Combined nonce + ciphertext + tag
+     */
+    private encrypt;
+    /**
+     * Decrypt data using AES-256-GCM
+     * @param data Combined nonce + ciphertext + tag
+     * @param key Symmetric key (32 bytes)
+     * @returns Decrypted data
+     */
+    private decrypt;
+    /**
+     * Serialize a private key for storage
+     */
+    serializePrivateKey(privateKeyBase64: string): string;
+    /**
+     * Deserialize a private key from storage
+     */
+    deserializePrivateKey(base64: string): string;
+}
+/**
+ * Export singleton instance
+ */
+export declare const cryptoService: CryptoService;

package/node_modules/@quantiya/codevibe-core/dist/crypto/crypto-service.js

@@ -0,0 +1,284 @@
+"use strict";
+//
+// crypto-service.ts
+// CodeVibe Core
+//
+// End-to-end encryption service using ECDH P-256 and AES-256-GCM
+//
+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.cryptoService = exports.CryptoService = exports.ENCRYPTION_VERSION = exports.CryptoError = void 0;
+const crypto = __importStar(require("crypto"));
+/**
+ * Error class for cryptographic operations
+ */
+class CryptoError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CryptoError';
+    }
+}
+exports.CryptoError = CryptoError;
+/**
+ * Current encryption version for future algorithm upgrades
+ */
+exports.ENCRYPTION_VERSION = 1;
+/**
+ * HKDF info string for key derivation
+ */
+const HKDF_INFO = 'CodeVibe E2E v1';
+/**
+ * Service for end-to-end encryption operations
+ */
+class CryptoService {
+    constructor() { }
+    static getInstance() {
+        if (!CryptoService.instance) {
+            CryptoService.instance = new CryptoService();
+        }
+        return CryptoService.instance;
+    }
+    // MARK: - Key Generation
+    /**
+     * Generate a new ECDH P-256 key pair
+     * @returns Object with privateKey (base64), publicKey (base64 raw)
+     */
+    generateKeyPair() {
+        const ecdh = crypto.createECDH('prime256v1');
+        ecdh.generateKeys();
+        // Get raw public key (uncompressed format without 0x04 prefix for compatibility)
+        const publicKeyRaw = ecdh.getPublicKey();
+        const publicKeyBase64 = publicKeyRaw.subarray(1).toString('base64'); // Skip 0x04 prefix
+        // Get private key as raw bytes
+        const privateKeyRaw = ecdh.getPrivateKey();
+        const privateKeyBase64 = privateKeyRaw.toString('base64');
+        return {
+            privateKey: privateKeyBase64,
+            publicKey: publicKeyBase64,
+        };
+    }
+    /**
+     * Generate a random 256-bit session key
+     * @returns Base64-encoded session key
+     */
+    generateSessionKey() {
+        const keyData = crypto.randomBytes(32); // 256 bits
+        return keyData.toString('base64');
+    }
+    // MARK: - Key Derivation
+    /**
+     * Derive a shared secret using ECDH and HKDF
+     * @param privateKeyBase64 Our private key (base64)
+     * @param publicKeyBase64 Other party's public key (base64)
+     * @returns 256-bit derived key as Buffer
+     */
+    deriveSharedKey(privateKeyBase64, publicKeyBase64) {
+        try {
+            const ecdh = crypto.createECDH('prime256v1');
+            const privateKeyRaw = Buffer.from(privateKeyBase64, 'base64');
+            ecdh.setPrivateKey(privateKeyRaw);
+            // Add 0x04 prefix for uncompressed public key format
+            const publicKeyRaw = Buffer.concat([
+                Buffer.from([0x04]),
+                Buffer.from(publicKeyBase64, 'base64'),
+            ]);
+            const sharedSecret = ecdh.computeSecret(publicKeyRaw);
+            // Derive key using HKDF-SHA256
+            const derivedKey = crypto.hkdfSync('sha256', sharedSecret, Buffer.alloc(0), // Empty salt
+            Buffer.from(HKDF_INFO, 'utf8'), 32 // 256 bits
+            );
+            return Buffer.from(derivedKey);
+        }
+        catch (error) {
+            throw new CryptoError(`Failed to derive shared key: ${error}`);
+        }
+    }
+    // MARK: - Session Key Encryption
+    /**
+     * Encrypt a session key for a target device using ECDH
+     * @param sessionKeyBase64 The session key to encrypt (base64)
+     * @param targetPublicKeyBase64 Target device's public key (base64)
+     * @returns EncryptedSessionKey containing encrypted key and ephemeral public key
+     */
+    encryptSessionKey(sessionKeyBase64, targetPublicKeyBase64) {
+        // Generate ephemeral key pair for this encryption
+        const ephemeralKeyPair = this.generateKeyPair();
+        // Derive shared key using ephemeral private + target public
+        const sharedKey = this.deriveSharedKey(ephemeralKeyPair.privateKey, targetPublicKeyBase64);
+        // Encrypt session key with derived key
+        const sessionKeyData = Buffer.from(sessionKeyBase64, 'base64');
+        const encryptedData = this.encrypt(sessionKeyData, sharedKey);
+        return {
+            encryptedKey: encryptedData.toString('base64'),
+            ephemeralPublicKey: ephemeralKeyPair.publicKey,
+        };
+    }
+    /**
+     * Decrypt a session key using our private key
+     * @param encryptedSessionKey The encrypted session key data
+     * @param privateKeyBase64 Our device's private key (base64)
+     * @returns Decrypted session key (base64)
+     */
+    decryptSessionKey(encryptedSessionKey, privateKeyBase64) {
+        // Derive shared key using our private + ephemeral public
+        const sharedKey = this.deriveSharedKey(privateKeyBase64, encryptedSessionKey.ephemeralPublicKey);
+        // Decrypt session key
+        const encryptedData = Buffer.from(encryptedSessionKey.encryptedKey, 'base64');
+        const decryptedData = this.decrypt(encryptedData, sharedKey);
+        return decryptedData.toString('base64');
+    }
+    // MARK: - Content Encryption/Decryption
+    /**
+     * Encrypt content using AES-256-GCM
+     * @param content String content to encrypt
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Base64-encoded ciphertext (nonce + ciphertext + tag)
+     */
+    encryptContent(content, sessionKeyBase64) {
+        const sessionKey = Buffer.from(sessionKeyBase64, 'base64');
+        const contentData = Buffer.from(content, 'utf8');
+        const encryptedData = this.encrypt(contentData, sessionKey);
+        return encryptedData.toString('base64');
+    }
+    /**
+     * Decrypt content using AES-256-GCM
+     * @param encryptedContent Base64-encoded ciphertext
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Decrypted string content
+     */
+    decryptContent(encryptedContent, sessionKeyBase64) {
+        const sessionKey = Buffer.from(sessionKeyBase64, 'base64');
+        const encryptedData = Buffer.from(encryptedContent, 'base64');
+        const decryptedData = this.decrypt(encryptedData, sessionKey);
+        return decryptedData.toString('utf8');
+    }
+    /**
+     * Encrypt JSON-serializable metadata
+     * @param metadata Object to encrypt
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Base64-encoded encrypted JSON
+     */
+    encryptMetadata(metadata, sessionKeyBase64) {
+        const jsonString = JSON.stringify(metadata);
+        return this.encryptContent(jsonString, sessionKeyBase64);
+    }
+    /**
+     * Decrypt encrypted metadata
+     * @param encryptedMetadata Base64-encoded encrypted JSON
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Decrypted object
+     */
+    decryptMetadata(encryptedMetadata, sessionKeyBase64) {
+        const jsonString = this.decryptContent(encryptedMetadata, sessionKeyBase64);
+        return JSON.parse(jsonString);
+    }
+    // MARK: - Binary Data Encryption (for attachments)
+    /**
+     * Encrypt binary data using AES-256-GCM
+     * @param data Binary data to encrypt (Buffer)
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Encrypted data (Buffer containing nonce + ciphertext + tag)
+     */
+    encryptData(data, sessionKeyBase64) {
+        const sessionKey = Buffer.from(sessionKeyBase64, 'base64');
+        return this.encrypt(data, sessionKey);
+    }
+    /**
+     * Decrypt binary data using AES-256-GCM
+     * @param encryptedData Encrypted data (Buffer containing nonce + ciphertext + tag)
+     * @param sessionKeyBase64 Session key (base64)
+     * @returns Decrypted binary data (Buffer)
+     */
+    decryptData(encryptedData, sessionKeyBase64) {
+        const sessionKey = Buffer.from(sessionKeyBase64, 'base64');
+        return this.decrypt(encryptedData, sessionKey);
+    }
+    // MARK: - Low-level Encryption
+    /**
+     * Encrypt data using AES-256-GCM
+     * @param data Data to encrypt
+     * @param key Symmetric key (32 bytes)
+     * @returns Combined nonce + ciphertext + tag
+     */
+    encrypt(data, key) {
+        // Generate random 12-byte nonce (IV)
+        const nonce = crypto.randomBytes(12);
+        const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce);
+        const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        // Combine: nonce (12 bytes) + ciphertext + tag (16 bytes)
+        return Buffer.concat([nonce, ciphertext, tag]);
+    }
+    /**
+     * Decrypt data using AES-256-GCM
+     * @param data Combined nonce + ciphertext + tag
+     * @param key Symmetric key (32 bytes)
+     * @returns Decrypted data
+     */
+    decrypt(data, key) {
+        // Extract: nonce (12 bytes) + ciphertext + tag (16 bytes)
+        const nonce = data.subarray(0, 12);
+        const tag = data.subarray(data.length - 16);
+        const ciphertext = data.subarray(12, data.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+        decipher.setAuthTag(tag);
+        try {
+            const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+            return decrypted;
+        }
+        catch (error) {
+            throw new CryptoError('Decryption failed: Invalid ciphertext or authentication tag');
+        }
+    }
+    // MARK: - Key Serialization
+    /**
+     * Serialize a private key for storage
+     */
+    serializePrivateKey(privateKeyBase64) {
+        return privateKeyBase64;
+    }
+    /**
+     * Deserialize a private key from storage
+     */
+    deserializePrivateKey(base64) {
+        return base64;
+    }
+}
+exports.CryptoService = CryptoService;
+/**
+ * Export singleton instance
+ */
+exports.cryptoService = CryptoService.getInstance();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto-service.js","sourceRoot":"","sources":["../../src/crypto/crypto-service.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// crypto-service.ts\n// CodeVibe Core\n//\n// End-to-end encryption service using ECDH P-256 and AES-256-GCM\n//\n\nimport * as crypto from 'crypto';\nimport { EncryptedSessionKey, KeyPair } from '../types';\n\n/**\n * Error class for cryptographic operations\n */\nexport class CryptoError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'CryptoError';\n  }\n}\n\n/**\n * Current encryption version for future algorithm upgrades\n */\nexport const ENCRYPTION_VERSION = 1;\n\n/**\n * HKDF info string for key derivation\n */\nconst HKDF_INFO = 'CodeVibe E2E v1';\n\n/**\n * Service for end-to-end encryption operations\n */\nexport class CryptoService {\n  private static instance: CryptoService;\n\n  private constructor() {}\n\n  static getInstance(): CryptoService {\n    if (!CryptoService.instance) {\n      CryptoService.instance = new CryptoService();\n    }\n    return CryptoService.instance;\n  }\n\n  // MARK: - Key Generation\n\n  /**\n   * Generate a new ECDH P-256 key pair\n   * @returns Object with privateKey (base64), publicKey (base64 raw)\n   */\n  generateKeyPair(): KeyPair {\n    const ecdh = crypto.createECDH('prime256v1');\n    ecdh.generateKeys();\n\n    // Get raw public key (uncompressed format without 0x04 prefix for compatibility)\n    const publicKeyRaw = ecdh.getPublicKey();\n    const publicKeyBase64 = publicKeyRaw.subarray(1).toString('base64'); // Skip 0x04 prefix\n\n    // Get private key as raw bytes\n    const privateKeyRaw = ecdh.getPrivateKey();\n    const privateKeyBase64 = privateKeyRaw.toString('base64');\n\n    return {\n      privateKey: privateKeyBase64,\n      publicKey: publicKeyBase64,\n    };\n  }\n\n  /**\n   * Generate a random 256-bit session key\n   * @returns Base64-encoded session key\n   */\n  generateSessionKey(): string {\n    const keyData = crypto.randomBytes(32); // 256 bits\n    return keyData.toString('base64');\n  }\n\n  // MARK: - Key Derivation\n\n  /**\n   * Derive a shared secret using ECDH and HKDF\n   * @param privateKeyBase64 Our private key (base64)\n   * @param publicKeyBase64 Other party's public key (base64)\n   * @returns 256-bit derived key as Buffer\n   */\n  deriveSharedKey(privateKeyBase64: string, publicKeyBase64: string): Buffer {\n    try {\n      const ecdh = crypto.createECDH('prime256v1');\n      const privateKeyRaw = Buffer.from(privateKeyBase64, 'base64');\n      ecdh.setPrivateKey(privateKeyRaw);\n\n      // Add 0x04 prefix for uncompressed public key format\n      const publicKeyRaw = Buffer.concat([\n        Buffer.from([0x04]),\n        Buffer.from(publicKeyBase64, 'base64'),\n      ]);\n\n      const sharedSecret = ecdh.computeSecret(publicKeyRaw);\n\n      // Derive key using HKDF-SHA256\n      const derivedKey = crypto.hkdfSync(\n        'sha256',\n        sharedSecret,\n        Buffer.alloc(0), // Empty salt\n        Buffer.from(HKDF_INFO, 'utf8'),\n        32 // 256 bits\n      );\n\n      return Buffer.from(derivedKey);\n    } catch (error) {\n      throw new CryptoError(`Failed to derive shared key: ${error}`);\n    }\n  }\n\n  // MARK: - Session Key Encryption\n\n  /**\n   * Encrypt a session key for a target device using ECDH\n   * @param sessionKeyBase64 The session key to encrypt (base64)\n   * @param targetPublicKeyBase64 Target device's public key (base64)\n   * @returns EncryptedSessionKey containing encrypted key and ephemeral public key\n   */\n  encryptSessionKey(\n    sessionKeyBase64: string,\n    targetPublicKeyBase64: string\n  ): Omit<EncryptedSessionKey, 'deviceId'> {\n    // Generate ephemeral key pair for this encryption\n    const ephemeralKeyPair = this.generateKeyPair();\n\n    // Derive shared key using ephemeral private + target public\n    const sharedKey = this.deriveSharedKey(\n      ephemeralKeyPair.privateKey,\n      targetPublicKeyBase64\n    );\n\n    // Encrypt session key with derived key\n    const sessionKeyData = Buffer.from(sessionKeyBase64, 'base64');\n    const encryptedData = this.encrypt(sessionKeyData, sharedKey);\n\n    return {\n      encryptedKey: encryptedData.toString('base64'),\n      ephemeralPublicKey: ephemeralKeyPair.publicKey,\n    };\n  }\n\n  /**\n   * Decrypt a session key using our private key\n   * @param encryptedSessionKey The encrypted session key data\n   * @param privateKeyBase64 Our device's private key (base64)\n   * @returns Decrypted session key (base64)\n   */\n  decryptSessionKey(\n    encryptedSessionKey: EncryptedSessionKey,\n    privateKeyBase64: string\n  ): string {\n    // Derive shared key using our private + ephemeral public\n    const sharedKey = this.deriveSharedKey(\n      privateKeyBase64,\n      encryptedSessionKey.ephemeralPublicKey\n    );\n\n    // Decrypt session key\n    const encryptedData = Buffer.from(encryptedSessionKey.encryptedKey, 'base64');\n    const decryptedData = this.decrypt(encryptedData, sharedKey);\n\n    return decryptedData.toString('base64');\n  }\n\n  // MARK: - Content Encryption/Decryption\n\n  /**\n   * Encrypt content using AES-256-GCM\n   * @param content String content to encrypt\n   * @param sessionKeyBase64 Session key (base64)\n   * @returns Base64-encoded ciphertext (nonce + ciphertext + tag)\n   */\n  encryptContent(content: string, sessionKeyBase64: string): string {\n    const sessionKey = Buffer.from(sessionKeyBase64, 'base64');\n    const contentData = Buffer.from(content, 'utf8');\n    const encryptedData = this.encrypt(contentData, sessionKey);\n    return encryptedData.toString('base64');\n  }\n\n  /**\n   * Decrypt content using AES-256-GCM\n   * @param encryptedContent Base64-encoded ciphertext\n   * @param sessionKeyBase64 Session key (base64)\n   * @returns Decrypted string content\n   */\n  decryptContent(encryptedContent: string, sessionKeyBase64: string): string {\n    const sessionKey = Buffer.from(sessionKeyBase64, 'base64');\n    const encryptedData = Buffer.from(encryptedContent, 'base64');\n    const decryptedData = this.decrypt(encryptedData, sessionKey);\n    return decryptedData.toString('utf8');\n  }\n\n  /**\n   * Encrypt JSON-serializable metadata\n   * @param metadata Object to encrypt\n   * @param sessionKeyBase64 Session key (base64)\n   * @returns Base64-encoded encrypted JSON\n   */\n  encryptMetadata(\n    metadata: Record<string, any>,\n    sessionKeyBase64: string\n  ): string {\n    const jsonString = JSON.stringify(metadata);\n    return this.encryptContent(jsonString, sessionKeyBase64);\n  }\n\n  /**\n   * Decrypt encrypted metadata\n   * @param encryptedMetadata Base64-encoded encrypted JSON\n   * @param sessionKeyBase64 Session key (base64)\n   * @returns Decrypted object\n   */\n  decryptMetadata(\n    encryptedMetadata: string,\n    sessionKeyBase64: string\n  ): Record<string, any> {\n    const jsonString = this.decryptContent(encryptedMetadata, sessionKeyBase64);\n    return JSON.parse(jsonString);\n  }\n\n  // MARK: - Binary Data Encryption (for attachments)\n\n  /**\n   * Encrypt binary data using AES-256-GCM\n   * @param data Binary data to encrypt (Buffer)\n   * @param sessionKeyBase64 Session key (base64)\n   * @returns Encrypted data (Buffer containing nonce + ciphertext + tag)\n   */\n  encryptData(data: Buffer, sessionKeyBase64: string): Buffer {\n    const sessionKey = Buffer.from(sessionKeyBase64, 'base64');\n    return this.encrypt(data, sessionKey);\n  }\n\n  /**\n   * Decrypt binary data using AES-256-GCM\n   * @param encryptedData Encrypted data (Buffer containing nonce + ciphertext + tag)\n   * @param sessionKeyBase64 Session key (base64)\n   * @returns Decrypted binary data (Buffer)\n   */\n  decryptData(encryptedData: Buffer, sessionKeyBase64: string): Buffer {\n    const sessionKey = Buffer.from(sessionKeyBase64, 'base64');\n    return this.decrypt(encryptedData, sessionKey);\n  }\n\n  // MARK: - Low-level Encryption\n\n  /**\n   * Encrypt data using AES-256-GCM\n   * @param data Data to encrypt\n   * @param key Symmetric key (32 bytes)\n   * @returns Combined nonce + ciphertext + tag\n   */\n  private encrypt(data: Buffer, key: Buffer): Buffer {\n    // Generate random 12-byte nonce (IV)\n    const nonce = crypto.randomBytes(12);\n\n    const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce);\n    const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);\n    const tag = cipher.getAuthTag();\n\n    // Combine: nonce (12 bytes) + ciphertext + tag (16 bytes)\n    return Buffer.concat([nonce, ciphertext, tag]);\n  }\n\n  /**\n   * Decrypt data using AES-256-GCM\n   * @param data Combined nonce + ciphertext + tag\n   * @param key Symmetric key (32 bytes)\n   * @returns Decrypted data\n   */\n  private decrypt(data: Buffer, key: Buffer): Buffer {\n    // Extract: nonce (12 bytes) + ciphertext + tag (16 bytes)\n    const nonce = data.subarray(0, 12);\n    const tag = data.subarray(data.length - 16);\n    const ciphertext = data.subarray(12, data.length - 16);\n\n    const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce);\n    decipher.setAuthTag(tag);\n\n    try {\n      const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);\n      return decrypted;\n    } catch (error) {\n      throw new CryptoError('Decryption failed: Invalid ciphertext or authentication tag');\n    }\n  }\n\n  // MARK: - Key Serialization\n\n  /**\n   * Serialize a private key for storage\n   */\n  serializePrivateKey(privateKeyBase64: string): string {\n    return privateKeyBase64;\n  }\n\n  /**\n   * Deserialize a private key from storage\n   */\n  deserializePrivateKey(base64: string): string {\n    return base64;\n  }\n}\n\n/**\n * Export singleton instance\n */\nexport const cryptoService = CryptoService.getInstance();\n"]}

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

@@ -0,0 +1 @@
+export { CryptoService, cryptoService, CryptoError, ENCRYPTION_VERSION } from './crypto-service';

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENCRYPTION_VERSION = exports.CryptoError = exports.cryptoService = exports.CryptoService = void 0;
+var crypto_service_1 = require("./crypto-service");
+Object.defineProperty(exports, "CryptoService", { enumerable: true, get: function () { return crypto_service_1.CryptoService; } });
+Object.defineProperty(exports, "cryptoService", { enumerable: true, get: function () { return crypto_service_1.cryptoService; } });
+Object.defineProperty(exports, "CryptoError", { enumerable: true, get: function () { return crypto_service_1.CryptoError; } });
+Object.defineProperty(exports, "ENCRYPTION_VERSION", { enumerable: true, get: function () { return crypto_service_1.ENCRYPTION_VERSION; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY3J5cHRvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1EQUFpRztBQUF4RiwrR0FBQSxhQUFhLE9BQUE7QUFBRSwrR0FBQSxhQUFhLE9BQUE7QUFBRSw2R0FBQSxXQUFXLE9BQUE7QUFBRSxvSEFBQSxrQkFBa0IsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IENyeXB0b1NlcnZpY2UsIGNyeXB0b1NlcnZpY2UsIENyeXB0b0Vycm9yLCBFTkNSWVBUSU9OX1ZFUlNJT04gfSBmcm9tICcuL2NyeXB0by1zZXJ2aWNlJztcbiJdfQ==

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

@@ -0,0 +1,14 @@
+export { KeychainManager, keychainManager, KeychainError } from './keychain';
+export { CryptoService, cryptoService, CryptoError, ENCRYPTION_VERSION } from './crypto';
+export { AppSyncClient, DownloadUrlResponse } from './appsync';
+export { queries, mutations, subscriptions } from './appsync';
+export { AuthService, authService } from './auth';
+export { runAuthCli } from './auth';
+export { loadConfig, getConfig, getEnvironment } from './config';
+export type { Config, Environment } from './config';
+export { Logger, logger, createLogger } from './logger';
+export { parseInteractivePrompt, normalizeSnapshot, } from './prompt-parser';
+export type { ParsedInteractivePrompt, PromptKind, InteractivePromptOption, } from './prompt-parser';
+export { resumeOrCreateSession, prepareSessionEncryption } from './session';
+export type { ResumeOrCreateSessionInput, ResumeOrCreateSessionResult } from './session';
+export * from './types';

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

@@ -0,0 +1,68 @@
+"use strict";
+//
+// index.ts
+// @quantiya/codevibe-core
+//
+// Core library for CodeVibe plugins
+//
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSessionEncryption = exports.resumeOrCreateSession = exports.normalizeSnapshot = exports.parseInteractivePrompt = exports.createLogger = exports.logger = exports.Logger = exports.getEnvironment = exports.getConfig = exports.loadConfig = exports.runAuthCli = exports.authService = exports.AuthService = exports.subscriptions = exports.mutations = exports.queries = exports.AppSyncClient = exports.ENCRYPTION_VERSION = exports.CryptoError = exports.cryptoService = exports.CryptoService = exports.KeychainError = exports.keychainManager = exports.KeychainManager = void 0;
+// Keychain
+var keychain_1 = require("./keychain");
+Object.defineProperty(exports, "KeychainManager", { enumerable: true, get: function () { return keychain_1.KeychainManager; } });
+Object.defineProperty(exports, "keychainManager", { enumerable: true, get: function () { return keychain_1.keychainManager; } });
+Object.defineProperty(exports, "KeychainError", { enumerable: true, get: function () { return keychain_1.KeychainError; } });
+// Crypto
+var crypto_1 = require("./crypto");
+Object.defineProperty(exports, "CryptoService", { enumerable: true, get: function () { return crypto_1.CryptoService; } });
+Object.defineProperty(exports, "cryptoService", { enumerable: true, get: function () { return crypto_1.cryptoService; } });
+Object.defineProperty(exports, "CryptoError", { enumerable: true, get: function () { return crypto_1.CryptoError; } });
+Object.defineProperty(exports, "ENCRYPTION_VERSION", { enumerable: true, get: function () { return crypto_1.ENCRYPTION_VERSION; } });
+// AppSync
+var appsync_1 = require("./appsync");
+Object.defineProperty(exports, "AppSyncClient", { enumerable: true, get: function () { return appsync_1.AppSyncClient; } });
+var appsync_2 = require("./appsync");
+Object.defineProperty(exports, "queries", { enumerable: true, get: function () { return appsync_2.queries; } });
+Object.defineProperty(exports, "mutations", { enumerable: true, get: function () { return appsync_2.mutations; } });
+Object.defineProperty(exports, "subscriptions", { enumerable: true, get: function () { return appsync_2.subscriptions; } });
+// Auth
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "AuthService", { enumerable: true, get: function () { return auth_1.AuthService; } });
+Object.defineProperty(exports, "authService", { enumerable: true, get: function () { return auth_1.authService; } });
+var auth_2 = require("./auth");
+Object.defineProperty(exports, "runAuthCli", { enumerable: true, get: function () { return auth_2.runAuthCli; } });
+// Config
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
+Object.defineProperty(exports, "getEnvironment", { enumerable: true, get: function () { return config_1.getEnvironment; } });
+// Logger
+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; } });
+// Prompt Parser
+var prompt_parser_1 = require("./prompt-parser");
+Object.defineProperty(exports, "parseInteractivePrompt", { enumerable: true, get: function () { return prompt_parser_1.parseInteractivePrompt; } });
+Object.defineProperty(exports, "normalizeSnapshot", { enumerable: true, get: function () { return prompt_parser_1.normalizeSnapshot; } });
+// Session
+var session_1 = require("./session");
+Object.defineProperty(exports, "resumeOrCreateSession", { enumerable: true, get: function () { return session_1.resumeOrCreateSession; } });
+Object.defineProperty(exports, "prepareSessionEncryption", { enumerable: true, get: function () { return session_1.prepareSessionEncryption; } });
+// Types
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+export { KeychainManager, keychainManager, KeychainError } from './keychain-manager';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeychainError = exports.keychainManager = exports.KeychainManager = void 0;
+var keychain_manager_1 = require("./keychain-manager");
+Object.defineProperty(exports, "KeychainManager", { enumerable: true, get: function () { return keychain_manager_1.KeychainManager; } });
+Object.defineProperty(exports, "keychainManager", { enumerable: true, get: function () { return keychain_manager_1.keychainManager; } });
+Object.defineProperty(exports, "KeychainError", { enumerable: true, get: function () { return keychain_manager_1.KeychainError; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMva2V5Y2hhaW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdURBQXFGO0FBQTVFLG1IQUFBLGVBQWUsT0FBQTtBQUFFLG1IQUFBLGVBQWUsT0FBQTtBQUFFLGlIQUFBLGFBQWEsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEtleWNoYWluTWFuYWdlciwga2V5Y2hhaW5NYW5hZ2VyLCBLZXljaGFpbkVycm9yIH0gZnJvbSAnLi9rZXljaGFpbi1tYW5hZ2VyJztcbiJdfQ==