codehere 0.2.1 → 0.3.0-rc.1

package/dist/infrastructure/protocols/a2a-protocol.js

@@ -1,314 +0,0 @@
-/**
- * Infrastructure: Agent-to-Agent (A2A) Communication Protocol
- * Enables Codehere to communicate with other AI agents
- * Standard protocol for agent collaboration and delegation
- *
- * Based on research: A2A Protocol (Linux Foundation/Google)
- * - 3-layer architecture: Canonical Data Model, Abstract Operations, Protocol Bindings
- * - Protocol Buffer messages for data integrity
- * - Supports JSON-RPC, gRPC, HTTP/REST bindings
- * - Agentic AI Metadata for capability discovery
- * - Asynchronous tasks with webhooks
- * - Server-Sent Events (SSE) for streaming
- * - Agent Opacity (black box service economy)
- *
- * Vision: Codehere as "The Memory Agent" - other agents call Codehere for memory/context
- * Research: See docs/NOTEBOOKLM_RESEARCH_PROMPTS.md - Prompt #5
- */
-/**
- * A2A Protocol Handler
- * Handles agent-to-agent communication
- */
-export class A2AProtocol {
-    agentId;
-    agentName;
-    agents = new Map();
-    messageHandlers = new Map();
-    pendingRequests = new Map();
-    constructor(agentId, agentName) {
-        this.agentId = agentId;
-        this.agentName = agentName;
-        // Register self
-        this.registerAgent({
-            id: this.agentId,
-            name: this.agentName,
-            capabilities: ['memory_query', 'memory_store', 'code_search', 'code_explain', 'code_edit'],
-            local: true,
-        });
-    }
-    /**
-     * Register an agent
-     */
-    registerAgent(agent) {
-        this.agents.set(agent.id, agent);
-    }
-    /**
-     * Unregister an agent
-     */
-    unregisterAgent(agentId) {
-        this.agents.delete(agentId);
-    }
-    /**
-     * Register a message handler
-     */
-    registerHandler(action, handler) {
-        this.messageHandlers.set(action, handler);
-    }
-    /**
-     * Send a request to another agent
-     */
-    async sendRequest(to, action, payload, timeout = 30000) {
-        const agent = this.agents.get(to);
-        if (!agent) {
-            throw new Error(`Agent not found: ${to}`);
-        }
-        const messageId = this.generateMessageId();
-        const request = {
-            id: messageId,
-            from: this.agentId,
-            to,
-            type: 'request',
-            action,
-            payload,
-            timestamp: Date.now(),
-        };
-        // Create promise for response
-        return new Promise((resolve, reject) => {
-            // Set timeout
-            const timeoutHandle = setTimeout(() => {
-                this.pendingRequests.delete(messageId);
-                reject(new Error(`Request timeout: ${action} to ${to}`));
-            }, timeout);
-            // Store pending request
-            this.pendingRequests.set(messageId, {
-                resolve,
-                reject,
-                timeout: timeoutHandle,
-            });
-            // Send request
-            if (agent.local) {
-                // Local agent - handle directly
-                this.handleLocalRequest(request).catch(reject);
-            }
-            else if (agent.endpoint) {
-                // Remote agent - send via HTTP
-                this.sendHTTPRequest(agent.endpoint, request).catch(reject);
-            }
-            else {
-                clearTimeout(timeoutHandle);
-                this.pendingRequests.delete(messageId);
-                reject(new Error(`Agent has no endpoint: ${to}`));
-            }
-        });
-    }
-    /**
-     * Handle incoming message
-     */
-    async handleMessage(message) {
-        if (message.type === 'request') {
-            return await this.handleRequest(message);
-        }
-        else if (message.type === 'response') {
-            return await this.handleResponse(message);
-        }
-        else if (message.type === 'notification') {
-            return await this.handleNotification(message);
-        }
-    }
-    /**
-     * Handle incoming request
-     */
-    async handleRequest(request) {
-        const handler = this.messageHandlers.get(request.action);
-        if (!handler) {
-            return {
-                id: this.generateMessageId(),
-                from: this.agentId,
-                to: request.from,
-                type: 'response',
-                action: request.action,
-                payload: {},
-                timestamp: Date.now(),
-                correlationId: request.id,
-                success: false,
-                error: `Unknown action: ${request.action}`,
-            };
-        }
-        try {
-            const response = await handler(request);
-            response.correlationId = request.id;
-            return response;
-        }
-        catch (error) {
-            return {
-                id: this.generateMessageId(),
-                from: this.agentId,
-                to: request.from,
-                type: 'response',
-                action: request.action,
-                payload: {},
-                timestamp: Date.now(),
-                correlationId: request.id,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Handle incoming response
-     */
-    async handleResponse(response) {
-        if (response.correlationId) {
-            const pending = this.pendingRequests.get(response.correlationId);
-            if (pending) {
-                clearTimeout(pending.timeout);
-                this.pendingRequests.delete(response.correlationId);
-                if (response.success) {
-                    pending.resolve(response);
-                }
-                else {
-                    pending.reject(new Error(response.error || 'Request failed'));
-                }
-            }
-        }
-    }
-    /**
-     * Handle incoming notification
-     */
-    async handleNotification(notification) {
-        // Handle notifications (e.g., agent discovery, status updates)
-        // Can be extended for specific notification types
-    }
-    /**
-     * Handle local request (same process)
-     */
-    async handleLocalRequest(request) {
-        const response = await this.handleRequest(request);
-        // Send response back
-        await this.handleMessage(response);
-    }
-    /**
-     * Send HTTP request to remote agent
-     */
-    async sendHTTPRequest(endpoint, request) {
-        // TODO: Implement HTTP transport for remote agents
-        // For now, local-only
-        throw new Error('HTTP transport not yet implemented');
-    }
-    /**
-     * Generate unique message ID
-     */
-    generateMessageId() {
-        return `${this.agentId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    /**
-     * Get registered agents
-     */
-    getAgents() {
-        return Array.from(this.agents.values());
-    }
-    /**
-     * Discover agents (local discovery for now)
-     */
-    discoverAgents() {
-        // For now, return registered agents
-        // In future, can implement mDNS, service registry, etc.
-        return this.getAgents();
-    }
-}
-/**
- * Codehere A2A Agent Interface
- * Exposes Codehere capabilities to other agents
- */
-export class CodehereA2AAgent {
-    protocol;
-    container;
-    constructor(container) {
-        this.container = container;
-        this.protocol = new A2AProtocol('codehere', 'Codehere');
-        // Register handlers
-        this.registerHandlers();
-    }
-    /**
-     * Register A2A message handlers
-     */
-    registerHandlers() {
-        // Memory query handler
-        this.protocol.registerHandler('memory_query', async (request) => {
-            const memoryStream = this.container.memoryStreamService;
-            const memories = await memoryStream.retrieve(request.payload.query, request.payload.limit || 10);
-            return {
-                id: this.protocol['generateMessageId'](),
-                from: 'codehere',
-                to: request.from,
-                type: 'response',
-                action: 'memory_query',
-                payload: {
-                    memories: memories.map((m) => ({
-                        type: m.type,
-                        description: m.description,
-                        timestamp: m.timestamp,
-                        importance: m.importance,
-                    })),
-                },
-                timestamp: Date.now(),
-                correlationId: request.id,
-                success: true,
-            };
-        });
-        // Code search handler
-        this.protocol.registerHandler('code_search', async (request) => {
-            const useCase = this.container.askQuestionUseCase;
-            const result = await useCase.execute({
-                query: request.payload.query,
-                maxResults: request.payload.maxResults || 10,
-            });
-            return {
-                id: this.protocol['generateMessageId'](),
-                from: 'codehere',
-                to: request.from,
-                type: 'response',
-                action: 'code_search',
-                payload: {
-                    chunks: result.chunks.map((chunk) => ({
-                        filepath: chunk.filepath,
-                        content: chunk.content.substring(0, 500),
-                        score: chunk.score,
-                    })),
-                },
-                timestamp: Date.now(),
-                correlationId: request.id,
-                success: true,
-            };
-        });
-        // Memory store handler
-        this.protocol.registerHandler('memory_store', async (request) => {
-            const memoryStream = this.container.memoryStreamService;
-            await memoryStream.recordObservation(request.payload.description, request.payload.metadata || {});
-            return {
-                id: this.protocol['generateMessageId'](),
-                from: 'codehere',
-                to: request.from,
-                type: 'response',
-                action: 'memory_store',
-                payload: {},
-                timestamp: Date.now(),
-                correlationId: request.id,
-                success: true,
-            };
-        });
-    }
-    /**
-     * Get A2A protocol instance
-     */
-    getProtocol() {
-        return this.protocol;
-    }
-    /**
-     * Send request to another agent
-     */
-    async sendRequest(to, action, payload) {
-        return await this.protocol.sendRequest(to, action, payload);
-    }
-}
-//# sourceMappingURL=a2a-protocol.js.map

package/dist/infrastructure/protocols/mcp-oauth.js

@@ -1,184 +0,0 @@
-/**
- * Infrastructure: MCP OAuth 2.1 Security Implementation
- * Implements OAuth 2.1 security for MCP servers
- *
- * Based on research findings:
- * - OAuth 2.1 with Dynamic Client Registration
- * - /.well-known/oauth-protected-resource endpoint
- * - M2M tokens for agent-to-agent communication
- * - Scoped permissions (least privilege)
- * - T-BAC (Task-Based Access Control) ready
- */
-/**
- * OAuth 2.1 Provider for MCP Server
- * Implements security as Resource Server
- */
-export class MCPOAuthProvider {
-    scopes = new Map();
-    authorizationServer;
-    constructor(authorizationServer) {
-        this.authorizationServer = authorizationServer;
-        this.initializeDefaultScopes();
-    }
-    /**
-     * Get OAuth-protected resource metadata
-     * Must implement /.well-known/oauth-protected-resource endpoint
-     */
-    getMetadata() {
-        return {
-            issuer: this.authorizationServer || 'codehere',
-            authorization_endpoint: `${this.authorizationServer || 'https://auth.codehere.io'}/oauth/authorize`,
-            token_endpoint: `${this.authorizationServer || 'https://auth.codehere.io'}/oauth/token`,
-            registration_endpoint: `${this.authorizationServer || 'https://auth.codehere.io'}/oauth/register`,
-            introspection_endpoint: `${this.authorizationServer || 'https://auth.codehere.io'}/oauth/introspect`,
-            revocation_endpoint: `${this.authorizationServer || 'https://auth.codehere.io'}/oauth/revoke`,
-            scopes_supported: Array.from(this.scopes.keys()),
-            response_types_supported: ['code'],
-            grant_types_supported: [
-                'authorization_code',
-                'client_credentials', // For M2M tokens
-                'refresh_token',
-            ],
-        };
-    }
-    /**
-     * Validate OAuth token and check permissions
-     * Resource Server validates tokens from Authorization Server
-     */
-    async validateToken(token, requiredScope) {
-        // TODO: Implement actual token validation with Authorization Server
-        // For now, return mock validation
-        // In production, call introspection endpoint or validate JWT
-        // Mock: Check if token exists and has required scope
-        if (!token || token === 'invalid') {
-            return { valid: false, error: 'Invalid token' };
-        }
-        // Extract scopes from token (in production, decode JWT or introspect)
-        const scopes = this.extractScopesFromToken(token);
-        if (requiredScope && !scopes.includes(requiredScope)) {
-            return {
-                valid: false,
-                error: `Missing required scope: ${requiredScope}`,
-                scopes,
-            };
-        }
-        return { valid: true, scopes };
-    }
-    /**
-     * Check if token has required permission
-     * Supports T-BAC (Task-Based Access Control)
-     */
-    hasPermission(token, task, tool) {
-        // T-BAC: Check permission for specific task/tool combination
-        // More granular than role-based access
-        return this.validateToken(token).then(result => {
-            if (!result.valid || !result.scopes) {
-                return false;
-            }
-            // Check if scope allows this task/tool combination
-            for (const scopeName of result.scopes) {
-                const scope = this.scopes.get(scopeName);
-                if (scope && scope.permissions.includes(`${task}:${tool || '*'}`)) {
-                    return true;
-                }
-            }
-            return false;
-        });
-    }
-    /**
-     * Initialize default OAuth scopes for MCP tools
-     */
-    initializeDefaultScopes() {
-        // Scope: codehere:ask - Query codebase
-        this.scopes.set('codehere:ask', {
-            name: 'codehere:ask',
-            description: 'Ask questions about codebase using semantic search',
-            permissions: ['query:codebase'],
-        });
-        // Scope: codehere:explain - Explain code files
-        this.scopes.set('codehere:explain', {
-            name: 'codehere:explain',
-            description: 'Get detailed explanations of code files',
-            permissions: ['read:code', 'explain:code'],
-        });
-        // Scope: codehere:edit - Edit files
-        this.scopes.set('codehere:edit', {
-            name: 'codehere:edit',
-            description: 'Edit files with AI-generated changes',
-            permissions: ['write:code', 'edit:code'],
-        });
-        // Scope: codehere:memory:read - Read memory
-        this.scopes.set('codehere:memory:read', {
-            name: 'codehere:memory:read',
-            description: 'Query persistent episodic memory',
-            permissions: ['read:memory'],
-        });
-        // Scope: codehere:memory:write - Write memory
-        this.scopes.set('codehere:memory:write', {
-            name: 'codehere:memory:write',
-            description: 'Store information in persistent memory',
-            permissions: ['write:memory'],
-        });
-    }
-    /**
-     * Extract scopes from token (mock implementation)
-     * In production: Decode JWT or call introspection endpoint
-     */
-    extractScopesFromToken(token) {
-        // Mock: For now, return all scopes if token is valid
-        // In production, decode JWT claims or introspect token
-        if (token.startsWith('codehere_')) {
-            return Array.from(this.scopes.keys());
-        }
-        return [];
-    }
-}
-/**
- * OAuth-protected MCP Server
- * Wraps MCP server with OAuth 2.1 security
- */
-export class OAuthProtectedMCPServer {
-    mcpServer;
-    oauthProvider;
-    constructor(mcpServer, oauthProvider) {
-        this.mcpServer = mcpServer;
-        this.oauthProvider = oauthProvider;
-    }
-    /**
-     * Get OAuth metadata endpoint
-     * Implements /.well-known/oauth-protected-resource
-     */
-    getOAuthMetadata() {
-        return this.oauthProvider.getMetadata();
-    }
-    /**
-     * Call tool with OAuth validation
-     */
-    async callToolWithAuth(token, name, args) {
-        // Determine required scope based on tool
-        const scopeMap = {
-            'codehere_ask': 'codehere:ask',
-            'codehere_explain': 'codehere:explain',
-            'codehere_edit': 'codehere:edit',
-            'codehere_search': 'codehere:ask',
-            'codehere_memory_query': 'codehere:memory:read',
-        };
-        const requiredScope = scopeMap[name];
-        // Validate token and scope
-        const validation = await this.oauthProvider.validateToken(token, requiredScope);
-        if (!validation.valid) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Authorization failed: ${validation.error}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        // Call tool if authorized
-        return await this.mcpServer.callTool(name, args);
-    }
-}
-//# sourceMappingURL=mcp-oauth.js.map