polydev-ai 1.2.3 → 1.2.5

package/lib/zeroKnowledgeEncryption.js

@@ -0,0 +1,289 @@
+"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

@@ -0,0 +1,165 @@
+# 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
+{
+  "mcpServers": {
+    "polydev": {
+      "command": "npx",
+      "args": ["polydev-ai"],
+      "env": {
+        "POLYDEV_USER_TOKEN": "pd_your_token_here"
+      }
+    }
+  }
+}
+```
+
+## 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/manifest.json

@@ -198,7 +198,7 @@
       ]
     },
     {
-      "name": "polydev.force_cli_detection",
+      "name": "force_cli_detection",
       "description": "Force detection and status update for CLI tools (Claude Code, Codex CLI, Gemini CLI). Updates local cache and reports status to MCP server via Supabase.",
       "inputSchema": {
         "type": "object",
@@ -290,7 +290,7 @@
       ]
     },
     {
-      "name": "polydev.get_cli_status",
+      "name": "get_cli_status",
       "description": "Get current CLI status with caching support. Returns cached results if available and fresh, otherwise performs new detection.",
       "inputSchema": {
         "type": "object",
@@ -347,7 +347,7 @@
       }
     },
     {
-      "name": "polydev.send_cli_prompt",
+      "name": "send_cli_prompt",
       "description": "Send a prompt to a CLI provider and get response. Supports both stdin and argument modes for maximum compatibility.",
       "inputSchema": {
         "type": "object",
@@ -443,7 +443,7 @@
       ]
     },
     {
-      "name": "polydev.detect_memory_sources",
+      "name": "detect_memory_sources",
       "description": "Detect all available memory sources across CLI tools (Claude Code, Cline, Codex, Cursor, Continue, Aider). Returns file paths for global memory, project memory, and recent conversations.",
       "inputSchema": {
         "type": "object",
@@ -503,7 +503,7 @@
       }
     },
     {
-      "name": "polydev.extract_memory", 
+      "name": "extract_memory", 
       "description": "Extract and optionally encrypt memory content from detected CLI tool sources. Provides TF-IDF relevance scoring and content analysis.",
       "inputSchema": {
         "type": "object",
@@ -550,7 +550,7 @@
       }
     },
     {
-      "name": "polydev.get_recent_conversations",
+      "name": "get_recent_conversations",
       "description": "Get recent conversations from CLI tools with TF-IDF relevance scoring against query context. Supports encrypted storage and retrieval.",
       "inputSchema": {
         "type": "object",
@@ -590,7 +590,7 @@
       }
     },
     {
-      "name": "polydev.get_memory_context",
+      "name": "get_memory_context",
       "description": "Get formatted memory and conversation context for injection into prompts. Automatically handles decryption and relevance scoring.",
       "inputSchema": {
         "type": "object",
@@ -631,7 +631,7 @@
       }
     },
     {
-      "name": "polydev.manage_memory_preferences", 
+      "name": "manage_memory_preferences", 
       "description": "Configure memory extraction and privacy preferences. Control which CLI tools and memory types are enabled, encryption settings, and context injection behavior.",
       "inputSchema": {
         "type": "object",

package/mcp/package.json

@@ -1,10 +1,10 @@
 {
-  "name": "polydev-perspectives-mcp",
+  "name": "polydev-ai",
   "version": "1.0.0",
   "description": "Get diverse AI perspectives from multiple LLMs via MCP - supports Cline, Claude Code, and other MCP clients",
   "main": "stdio-wrapper.js",
   "bin": {
-    "polydev-mcp": "./stdio-wrapper.js"
+    "polydev-ai": "./stdio-wrapper.js"
   },
   "scripts": {
     "start": "node server.js",

package/mcp/server.js

@@ -1,9 +1,32 @@
 #!/usr/bin/env node
 
+// Register ts-node for TypeScript support
+try {
+  require('ts-node/register');
+} catch (e) {
+  // ts-node not available, proceed without it
+}
+
 const fs = require('fs');
 const path = require('path');
 const CLIManager = require('../lib/cliManager').default;
-const UniversalMemoryExtractor = require('../src/lib/universalMemoryExtractor').UniversalMemoryExtractor;
+
+let UniversalMemoryExtractor;
+try {
+  UniversalMemoryExtractor = require('../src/lib/universalMemoryExtractor').UniversalMemoryExtractor;
+} catch (e) {
+  // Fallback if TypeScript module is not available
+  console.warn('UniversalMemoryExtractor not available, memory features will be disabled');
+  UniversalMemoryExtractor = class {
+    async detectMemorySources() { return []; }
+    async extractMemory() { return {}; }
+    async getRecentConversations() { return []; }
+    async getRelevantContext() { return ''; }
+    async getPreferences() { return {}; }
+    async updatePreferences() { return {}; }
+    async resetPreferences() { return {}; }
+  };
+}
 
 class MCPServer {
   constructor() {
@@ -126,35 +149,35 @@ class MCPServer {
           result = await this.callPerspectivesAPI(args);
           break;
         
-        case 'polydev.force_cli_detection':
+        case 'force_cli_detection':
           result = await this.forceCliDetection(args);
           break;
         
-        case 'polydev.get_cli_status':
+        case 'get_cli_status':
           result = await this.getCliStatus(args);
           break;
         
-        case 'polydev.send_cli_prompt':
+        case 'send_cli_prompt':
           result = await this.sendCliPrompt(args);
           break;
         
-        case 'polydev.detect_memory_sources':
+        case 'detect_memory_sources':
           result = await this.detectMemorySources(args);
           break;
         
-        case 'polydev.extract_memory':
+        case 'extract_memory':
           result = await this.extractMemory(args);
           break;
         
-        case 'polydev.get_recent_conversations':
+        case 'get_recent_conversations':
           result = await this.getRecentConversations(args);
           break;
         
-        case 'polydev.get_memory_context':
+        case 'get_memory_context':
           result = await this.getMemoryContext(args);
           break;
         
-        case 'polydev.manage_memory_preferences':
+        case 'manage_memory_preferences':
           result = await this.manageMemoryPreferences(args);
           break;
         
@@ -298,20 +321,20 @@ class MCPServer {
       case 'get_perspectives':
         return this.formatPerspectivesResponse(result);
       
-      case 'polydev.force_cli_detection':
+      case 'force_cli_detection':
         return this.formatCliDetectionResponse(result);
-      
-      case 'polydev.get_cli_status':
+
+      case 'get_cli_status':
         return this.formatCliStatusResponse(result);
-      
-      case 'polydev.send_cli_prompt':
+
+      case 'send_cli_prompt':
         return this.formatCliPromptResponse(result);
-      
-      case 'polydev.detect_memory_sources':
-      case 'polydev.extract_memory':
-      case 'polydev.get_recent_conversations':
-      case 'polydev.get_memory_context':
-      case 'polydev.manage_memory_preferences':
+
+      case 'detect_memory_sources':
+      case 'extract_memory':
+      case 'get_recent_conversations':
+      case 'get_memory_context':
+      case 'manage_memory_preferences':
         return this.formatMemoryResponse(result);
       
       default: