polydev-ai 1.4.0 → 1.4.2

package/lib/zeroKnowledgeEncryption.js

@@ -1,289 +0,0 @@
-"use strict";
-/**
- * Zero-Knowledge Client-Side Encryption System
- * All encryption keys never leave the user's browser
- * Enterprise-grade AES-256-GCM encryption with automatic key rotation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.zkEncryption = exports.ZeroKnowledgeEncryption = void 0;
-class ZeroKnowledgeEncryption {
-    constructor() {
-        this.db = null;
-        this.activeKey = null;
-    }
-    /**
-     * Initialize the encryption system
-     */
-    async initialize() {
-        await this.initializeIndexedDB();
-        await this.loadOrCreateActiveKey();
-    }
-    /**
-     * Initialize IndexedDB for local key storage
-     */
-    async initializeIndexedDB() {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(ZeroKnowledgeEncryption.DB_NAME, ZeroKnowledgeEncryption.DB_VERSION);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => {
-                this.db = request.result;
-                resolve();
-            };
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                // Store for encryption keys (never synchronized)
-                if (!db.objectStoreNames.contains('keys')) {
-                    const keyStore = db.createObjectStore('keys', { keyPath: 'keyId' });
-                    keyStore.createIndex('created', 'created', { unique: false });
-                }
-                // Cache for encrypted data
-                if (!db.objectStoreNames.contains('cache')) {
-                    const cacheStore = db.createObjectStore('cache', { keyPath: 'id' });
-                    cacheStore.createIndex('expires', 'expires', { unique: false });
-                }
-            };
-        });
-    }
-    /**
-     * Generate new AES-256-GCM encryption key
-     */
-    async generateKey() {
-        const keyId = this.generateKeyId();
-        const key = await window.crypto.subtle.generateKey({
-            name: ZeroKnowledgeEncryption.ALGORITHM,
-            length: ZeroKnowledgeEncryption.KEY_LENGTH,
-        }, true, // extractable for storage
-        ['encrypt', 'decrypt']);
-        const now = new Date();
-        const rotationDue = new Date(now.getTime() + (ZeroKnowledgeEncryption.KEY_ROTATION_DAYS * 24 * 60 * 60 * 1000));
-        return {
-            keyId,
-            key,
-            created: now,
-            rotationDue
-        };
-    }
-    /**
-     * Load active key or create new one
-     */
-    async loadOrCreateActiveKey() {
-        if (!this.db)
-            throw new Error('Database not initialized');
-        const transaction = this.db.transaction(['keys'], 'readonly');
-        const store = transaction.objectStore('keys');
-        // Get the most recent key
-        const index = store.index('created');
-        const request = index.openCursor(null, 'prev');
-        return new Promise((resolve) => {
-            request.onsuccess = async (event) => {
-                const cursor = event.target.result;
-                if (cursor) {
-                    const keyData = cursor.value;
-                    // Check if key needs rotation
-                    if (new Date() > new Date(keyData.rotationDue)) {
-                        console.log('[ZK Encryption] Key rotation needed, generating new key');
-                        await this.createAndStoreKey();
-                    }
-                    else {
-                        // Import existing key
-                        const keyBuffer = new Uint8Array(keyData.keyBuffer);
-                        this.activeKey = {
-                            keyId: keyData.keyId,
-                            key: await window.crypto.subtle.importKey('raw', keyBuffer, { name: ZeroKnowledgeEncryption.ALGORITHM }, true, ['encrypt', 'decrypt']),
-                            created: new Date(keyData.created),
-                            rotationDue: new Date(keyData.rotationDue)
-                        };
-                    }
-                }
-                else {
-                    // No keys exist, create first one
-                    await this.createAndStoreKey();
-                }
-                resolve();
-            };
-        });
-    }
-    /**
-     * Create and store new key
-     */
-    async createAndStoreKey() {
-        this.activeKey = await this.generateKey();
-        await this.storeKey(this.activeKey);
-    }
-    /**
-     * Store key in IndexedDB
-     */
-    async storeKey(userKey) {
-        if (!this.db)
-            throw new Error('Database not initialized');
-        const keyBuffer = await window.crypto.subtle.exportKey('raw', userKey.key);
-        const transaction = this.db.transaction(['keys'], 'readwrite');
-        const store = transaction.objectStore('keys');
-        await store.put({
-            keyId: userKey.keyId,
-            keyBuffer: Array.from(new Uint8Array(keyBuffer)),
-            created: userKey.created.toISOString(),
-            rotationDue: userKey.rotationDue.toISOString()
-        });
-    }
-    /**
-     * Encrypt sensitive data
-     */
-    async encrypt(plaintext) {
-        if (!this.activeKey)
-            throw new Error('Encryption key not available');
-        const encoder = new TextEncoder();
-        const data = encoder.encode(plaintext);
-        const iv = window.crypto.getRandomValues(new Uint8Array(ZeroKnowledgeEncryption.IV_LENGTH));
-        const encrypted = await window.crypto.subtle.encrypt({
-            name: ZeroKnowledgeEncryption.ALGORITHM,
-            iv: iv,
-        }, this.activeKey.key, data);
-        const encryptedArray = new Uint8Array(encrypted);
-        const ciphertext = encryptedArray.slice(0, -ZeroKnowledgeEncryption.AUTH_TAG_LENGTH);
-        const authTag = encryptedArray.slice(-ZeroKnowledgeEncryption.AUTH_TAG_LENGTH);
-        return {
-            ciphertext: this.arrayBufferToBase64(ciphertext.buffer),
-            iv: this.arrayBufferToBase64(iv.buffer),
-            authTag: this.arrayBufferToBase64(authTag.buffer),
-            keyId: this.activeKey.keyId,
-            version: 1
-        };
-    }
-    /**
-     * Decrypt sensitive data
-     */
-    async decrypt(encryptedData) {
-        const key = await this.getKeyById(encryptedData.keyId);
-        if (!key)
-            throw new Error(`Encryption key ${encryptedData.keyId} not found`);
-        const ciphertext = this.base64ToArrayBuffer(encryptedData.ciphertext);
-        const iv = this.base64ToArrayBuffer(encryptedData.iv);
-        const authTag = this.base64ToArrayBuffer(encryptedData.authTag);
-        // Combine ciphertext and auth tag for Web Crypto API
-        const combined = new Uint8Array(ciphertext.byteLength + authTag.byteLength);
-        combined.set(new Uint8Array(ciphertext));
-        combined.set(new Uint8Array(authTag), ciphertext.byteLength);
-        const decrypted = await window.crypto.subtle.decrypt({
-            name: ZeroKnowledgeEncryption.ALGORITHM,
-            iv: new Uint8Array(iv),
-        }, key, combined);
-        const decoder = new TextDecoder();
-        return decoder.decode(decrypted);
-    }
-    /**
-     * Get encryption key by ID
-     */
-    async getKeyById(keyId) {
-        if (!this.db)
-            return null;
-        const transaction = this.db.transaction(['keys'], 'readonly');
-        const store = transaction.objectStore('keys');
-        const request = store.get(keyId);
-        return new Promise((resolve) => {
-            request.onsuccess = async () => {
-                if (request.result) {
-                    const keyBuffer = new Uint8Array(request.result.keyBuffer);
-                    const key = await window.crypto.subtle.importKey('raw', keyBuffer, { name: ZeroKnowledgeEncryption.ALGORITHM }, true, ['encrypt', 'decrypt']);
-                    resolve(key);
-                }
-                else {
-                    resolve(null);
-                }
-            };
-            request.onerror = () => resolve(null);
-        });
-    }
-    /**
-     * Create SHA-256 hash for content deduplication
-     */
-    async createContentHash(content) {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(content);
-        const hashBuffer = await window.crypto.subtle.digest('SHA-256', data);
-        return this.arrayBufferToHex(hashBuffer);
-    }
-    /**
-     * Check if key rotation is needed
-     */
-    isRotationDue() {
-        return this.activeKey ? new Date() > this.activeKey.rotationDue : true;
-    }
-    /**
-     * Force key rotation
-     */
-    async rotateKeys() {
-        await this.createAndStoreKey();
-        console.log('[ZK Encryption] Key rotation completed');
-    }
-    /**
-     * Generate unique key ID
-     */
-    generateKeyId() {
-        const timestamp = Date.now().toString(36);
-        const random = Math.random().toString(36).substr(2, 9);
-        return `zk_${timestamp}_${random}`;
-    }
-    /**
-     * Utility: ArrayBuffer to Base64
-     */
-    arrayBufferToBase64(buffer) {
-        const bytes = new Uint8Array(buffer);
-        let binary = '';
-        for (let i = 0; i < bytes.byteLength; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    /**
-     * Utility: Base64 to ArrayBuffer
-     */
-    base64ToArrayBuffer(base64) {
-        const binary = atob(base64);
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i++) {
-            bytes[i] = binary.charCodeAt(i);
-        }
-        return bytes.buffer;
-    }
-    /**
-     * Utility: ArrayBuffer to Hex
-     */
-    arrayBufferToHex(buffer) {
-        const bytes = new Uint8Array(buffer);
-        return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
-    }
-    /**
-     * Get encryption status for dashboard
-     */
-    getEncryptionStatus() {
-        return {
-            keyId: this.activeKey?.keyId || null,
-            created: this.activeKey?.created || null,
-            rotationDue: this.activeKey?.rotationDue || null,
-            rotationNeeded: this.isRotationDue()
-        };
-    }
-    /**
-     * Clear all keys (for user logout/reset)
-     */
-    async clearAllKeys() {
-        if (!this.db)
-            return;
-        const transaction = this.db.transaction(['keys', 'cache'], 'readwrite');
-        await transaction.objectStore('keys').clear();
-        await transaction.objectStore('cache').clear();
-        this.activeKey = null;
-        console.log('[ZK Encryption] All keys cleared');
-    }
-}
-exports.ZeroKnowledgeEncryption = ZeroKnowledgeEncryption;
-ZeroKnowledgeEncryption.ALGORITHM = 'AES-GCM';
-ZeroKnowledgeEncryption.KEY_LENGTH = 256;
-ZeroKnowledgeEncryption.IV_LENGTH = 12;
-ZeroKnowledgeEncryption.AUTH_TAG_LENGTH = 16;
-ZeroKnowledgeEncryption.KEY_ROTATION_DAYS = 30;
-ZeroKnowledgeEncryption.DB_NAME = 'PolydevZKMemory';
-ZeroKnowledgeEncryption.DB_VERSION = 1;
-// Export singleton instance
-exports.zkEncryption = new ZeroKnowledgeEncryption();

package/mcp/README.md

@@ -1,160 +0,0 @@
-# Polydev AI MCP Server
-
-Get diverse AI perspectives from multiple LLMs via Model Context Protocol (MCP). Supports Cline, Claude Code, and other MCP clients with local CLI detection and remote AI perspectives.
-
-## Features
-
-- 🤖 **Multi-Model AI Perspectives**: Get responses from GPT-4, Claude, Gemini, and more
-- 🔧 **Local CLI Detection**: Automatically detect and use Claude Code, Codex CLI, Gemini CLI
-- ⚡ **Smart Caching**: Intelligent refresh intervals based on CLI status
-- 🔄 **Fallback Support**: Local CLI + remote perspectives for comprehensive responses
-- 🔐 **Secure**: Token-based authentication with your Polydev account
-
-## Installation
-
-### For Claude Code Users
-
-```bash
-# Install globally
-npm install -g polydev-ai
-
-# Or use directly with npx
-npx polydev-ai
-```
-
-### For Cline Users
-
-Add to your MCP settings (`.cline/mcp_servers.json`):
-
-```json
-{
-  "mcpServers": {
-    "polydev": {
-      "command": "npx",
-      "args": ["polydev-ai"],
-      "env": {
-        "POLYDEV_USER_TOKEN": "your_token_here"
-      }
-    }
-  }
-}
-```
-
-## Configuration
-
-### Get Your Token
-
-1. Sign up at [polydev.ai](https://polydev.ai)
-2. Go to your dashboard and copy your MCP token
-3. Set the environment variable:
-
-```bash
-export POLYDEV_USER_TOKEN="pd_your_token_here"
-```
-
-### Claude Code Integration
-
-Add to your Claude Code MCP configuration:
-
-```json
- "polydev": {
-          "disabled": false,
-          "timeout": 120,
-          "type": "http",
-          "url": "https://www.polydev.ai/api/mcp"
-        },
-```
-
-## Available Tools
-
-- `get_perspectives` - Get AI responses from multiple models
-- `force_cli_detection` - Force detection of local CLI tools
-- `get_cli_status` - Check status of CLI tools (Claude Code, Codex, Gemini)
-- `send_cli_prompt` - Send prompts to local CLI with perspectives fallback
-
-## Usage Examples
-
-### Get Multi-Model Perspectives
-
-```typescript
-// Use the get_perspectives tool
-{
-  "prompt": "How do I optimize React performance?",
-  "models": ["gpt-4", "claude-3-sonnet", "gemini-pro"]
-}
-```
-
-### Check CLI Status
-
-```typescript
-// Check all CLI tools
-await get_cli_status({})
-
-// Check specific tool
-await get_cli_status({ provider_id: "claude_code" })
-```
-
-### Send CLI Prompt with Fallback
-
-```typescript
-await send_cli_prompt({
-  provider_id: "claude_code",
-  prompt: "Write a Python function to parse JSON",
-  mode: "args"
-})
-```
-
-## Supported CLI Tools
-
-- **Claude Code** (`claude`) - Anthropic's official CLI
-- **Codex CLI** (`codex`) - OpenAI's code CLI
-- **Gemini CLI** (`gemini`) - Google's Gemini CLI
-
-## Smart Refresh System
-
-The MCP server automatically detects CLI status changes:
-
-- **Unavailable CLIs**: Check every 2 minutes
-- **Unauthenticated CLIs**: Check every 3 minutes  
-- **Working CLIs**: Check every 10 minutes
-- **Fallback detection**: Check every 5 minutes
-
-## Environment Variables
-
-- `POLYDEV_USER_TOKEN` - Your Polydev authentication token (required)
-- `POLYDEV_CLI_DEBUG` - Enable CLI debugging output
-- `CLAUDE_CODE_PATH` - Custom path to Claude Code CLI
-- `CODEX_CLI_PATH` - Custom path to Codex CLI
-- `GEMINI_CLI_PATH` - Custom path to Gemini CLI
-
-## Troubleshooting
-
-### CLI Not Detected
-
-1. Ensure the CLI is installed and in your PATH
-2. Check authentication: `claude auth status` / `codex login status`
-3. Enable debugging: `export POLYDEV_CLI_DEBUG=1`
-
-### Token Issues
-
-1. Verify your token at [polydev.ai/dashboard](https://polydev.ai/dashboard)
-2. Ensure the token starts with `pd_`
-3. Check environment variable is set correctly
-
-### Permission Errors
-
-```bash
-# Fix npm permissions
-npm config set prefix '~/.npm-global'
-export PATH=~/.npm-global/bin:$PATH
-```
-
-## Support
-
-- 📧 Email: [support@polydev.ai](mailto:support@polydev.ai)
-- 📖 Docs: [polydev.ai/docs](https://polydev.ai/docs)
-- 🐛 Issues: [GitHub Issues](https://github.com/backspacevenkat/polydev-website/issues)
-
-## License
-
-MIT License - see LICENSE file for details.

package/mcp/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "polydev-ai",
-  "version": "1.2.6",
-  "description": "Get diverse AI perspectives from multiple LLMs via MCP - supports Cline, Claude Code, and other MCP clients",
-  "main": "stdio-wrapper.js",
-  "bin": {
-    "polydev-ai": "./stdio-wrapper.js"
-  },
-  "scripts": {
-    "start": "node server.js",
-    "test": "node server.js --help"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "ai",
-    "llm",
-    "perspectives",
-    "multi-model",
-    "cline",
-    "claude",
-    "openai",
-    "anthropic",
-    "gemini",
-    "polydev"
-  ],
-  "author": "Polydev AI <support@polydev.ai>",
-  "license": "MIT",
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "files": [
-    "stdio-wrapper.js",
-    "manifest.json",
-    "README.md"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/backspacevenkat/polydev-website.git",
-    "directory": "mcp"
-  },
-  "homepage": "https://polydev.ai/docs/mcp-integration",
-  "bugs": {
-    "url": "https://github.com/backspacevenkat/polydev-website/issues"
-  }
-}