opc-agent 2.0.0 → 2.0.2

package/dist/protocols/mcp/server.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPServer = void 0;
+const http_1 = require("http");
+const readline_1 = require("readline");
+const types_1 = require("./types");
+class MCPServer {
+    config;
+    tools = new Map();
+    resources = new Map();
+    prompts = new Map();
+    sseClients = new Set();
+    httpServer = null;
+    constructor(config) {
+        this.config = config;
+        for (const t of config.tools ?? [])
+            this.addTool(t);
+        for (const r of config.resources ?? [])
+            this.addResource(r);
+        for (const p of config.prompts ?? [])
+            this.addPrompt(p);
+    }
+    addTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    removeTool(name) {
+        this.tools.delete(name);
+    }
+    addResource(resource) {
+        this.resources.set(resource.uri, resource);
+    }
+    removeResource(uri) {
+        this.resources.delete(uri);
+    }
+    addPrompt(prompt) {
+        this.prompts.set(prompt.name, prompt);
+    }
+    getToolCount() { return this.tools.size; }
+    getResourceCount() { return this.resources.size; }
+    getPromptCount() { return this.prompts.size; }
+    getConnectedClients() { return this.sseClients.size; }
+    /** Serve over stdio — one JSON-RPC message per line */
+    async serveStdio() {
+        const rl = (0, readline_1.createInterface)({ input: process.stdin, terminal: false });
+        rl.on('line', async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            try {
+                const msg = JSON.parse(trimmed);
+                const response = await this.handleMessage(msg);
+                if (response) {
+                    process.stdout.write(JSON.stringify(response) + '\n');
+                }
+            }
+            catch {
+                const err = {
+                    jsonrpc: '2.0', id: null,
+                    error: types_1.MCP_ERRORS.PARSE_ERROR,
+                };
+                process.stdout.write(JSON.stringify(err) + '\n');
+            }
+        });
+    }
+    /** Serve over HTTP + SSE */
+    async serveHTTP(port) {
+        this.httpServer = (0, http_1.createServer)((req, res) => this.handleHTTP(req, res));
+        return new Promise((resolve) => {
+            this.httpServer.listen(port, () => resolve());
+        });
+    }
+    /** Mount on existing HTTP server at a path prefix */
+    mount(server, path = '/mcp') {
+        const orig = server.listeners('request')[0];
+        server.removeAllListeners('request');
+        server.on('request', (req, res) => {
+            if (req.url?.startsWith(path)) {
+                // Rewrite URL to strip prefix
+                req.url = req.url.slice(path.length) || '/';
+                this.handleHTTP(req, res);
+            }
+            else if (orig) {
+                orig(req, res);
+            }
+        });
+    }
+    stop() {
+        this.httpServer?.close();
+        for (const client of this.sseClients) {
+            client.end();
+        }
+        this.sseClients.clear();
+    }
+    handleHTTP(req, res) {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        if (url.pathname === '/sse' && req.method === 'GET') {
+            // SSE endpoint
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+            });
+            this.sseClients.add(res);
+            // Send endpoint info
+            res.write(`data: ${JSON.stringify({ type: 'endpoint', url: '/message' })}\n\n`);
+            req.on('close', () => this.sseClients.delete(res));
+            return;
+        }
+        if (url.pathname === '/message' && req.method === 'POST') {
+            let body = '';
+            req.on('data', (chunk) => { body += chunk; });
+            req.on('end', async () => {
+                try {
+                    const msg = JSON.parse(body);
+                    const response = await this.handleMessage(msg);
+                    if (response) {
+                        // Send via SSE to all clients
+                        for (const client of this.sseClients) {
+                            client.write(`data: ${JSON.stringify(response)}\n\n`);
+                        }
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(response));
+                    }
+                    else {
+                        res.writeHead(202);
+                        res.end();
+                    }
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: types_1.MCP_ERRORS.PARSE_ERROR }));
+                }
+            });
+            return;
+        }
+        res.writeHead(404);
+        res.end('Not Found');
+    }
+    async handleMessage(msg) {
+        // Notifications (no id) don't get responses
+        if (msg.id === undefined)
+            return null;
+        const id = msg.id;
+        try {
+            switch (msg.method) {
+                case 'initialize':
+                    return this.rpcResult(id, {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {
+                            tools: this.tools.size > 0 ? { listChanged: true } : undefined,
+                            resources: this.resources.size > 0 ? { subscribe: false, listChanged: true } : undefined,
+                            prompts: this.prompts.size > 0 ? { listChanged: true } : undefined,
+                        },
+                        serverInfo: { name: this.config.name, version: this.config.version },
+                    });
+                case 'tools/list':
+                    return this.rpcResult(id, {
+                        tools: Array.from(this.tools.values()).map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: t.inputSchema,
+                        })),
+                    });
+                case 'tools/call': {
+                    const { name, arguments: args } = msg.params ?? {};
+                    const tool = this.tools.get(name);
+                    if (!tool)
+                        return this.rpcError(id, types_1.MCP_ERRORS.TOOL_NOT_FOUND);
+                    // Validate required fields
+                    const schema = tool.inputSchema;
+                    if (schema?.required && Array.isArray(schema.required)) {
+                        for (const field of schema.required) {
+                            if (args?.[field] === undefined) {
+                                return this.rpcError(id, { code: -32602, message: `Missing required parameter: ${field}` });
+                            }
+                        }
+                    }
+                    try {
+                        const result = await tool.handler(args ?? {});
+                        return this.rpcResult(id, {
+                            content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }],
+                        });
+                    }
+                    catch (err) {
+                        return this.rpcResult(id, {
+                            content: [{ type: 'text', text: err.message || 'Tool execution failed' }],
+                            isError: true,
+                        });
+                    }
+                }
+                case 'resources/list':
+                    return this.rpcResult(id, {
+                        resources: Array.from(this.resources.values()).map(r => ({
+                            uri: r.uri, name: r.name, description: r.description, mimeType: r.mimeType,
+                        })),
+                    });
+                case 'resources/read': {
+                    const { uri } = msg.params ?? {};
+                    const resource = this.resources.get(uri);
+                    if (!resource)
+                        return this.rpcError(id, types_1.MCP_ERRORS.RESOURCE_NOT_FOUND);
+                    const content = await resource.handler();
+                    return this.rpcResult(id, {
+                        contents: [{ uri, mimeType: resource.mimeType || 'text/plain', text: content }],
+                    });
+                }
+                case 'prompts/list':
+                    return this.rpcResult(id, {
+                        prompts: Array.from(this.prompts.values()).map(p => ({
+                            name: p.name, description: p.description,
+                            arguments: p.arguments,
+                        })),
+                    });
+                case 'prompts/get': {
+                    const { name, arguments: promptArgs } = msg.params ?? {};
+                    const prompt = this.prompts.get(name);
+                    if (!prompt)
+                        return this.rpcError(id, types_1.MCP_ERRORS.PROMPT_NOT_FOUND);
+                    const messages = prompt.handler
+                        ? await prompt.handler(promptArgs ?? {})
+                        : [{ role: 'user', content: { type: 'text', text: prompt.description || '' } }];
+                    return this.rpcResult(id, { description: prompt.description, messages });
+                }
+                default:
+                    return this.rpcError(id, types_1.MCP_ERRORS.METHOD_NOT_FOUND);
+            }
+        }
+        catch (err) {
+            return this.rpcError(id, { ...types_1.MCP_ERRORS.INTERNAL_ERROR, data: err.message });
+        }
+    }
+    rpcResult(id, result) {
+        return { jsonrpc: '2.0', id, result };
+    }
+    rpcError(id, error) {
+        return { jsonrpc: '2.0', id, error };
+    }
+}
+exports.MCPServer = MCPServer;
+//# sourceMappingURL=server.js.map

package/dist/protocols/mcp/types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * MCP Server types — JSON-RPC 2.0 based Model Context Protocol
+ */
+export interface MCPServerConfig {
+    name: string;
+    version: string;
+    tools?: MCPServerToolDefinition[];
+    resources?: MCPResourceDefinition[];
+    prompts?: MCPPromptDefinition[];
+}
+export interface MCPServerToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+    handler: (args: any) => Promise<any>;
+}
+export interface MCPResourceDefinition {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    handler: () => Promise<string>;
+}
+export interface MCPPromptDefinition {
+    name: string;
+    description?: string;
+    arguments?: MCPPromptArgument[];
+    handler?: (args: Record<string, string>) => Promise<MCPPromptMessage[]>;
+}
+export interface MCPPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+export interface MCPPromptMessage {
+    role: 'user' | 'assistant';
+    content: {
+        type: 'text';
+        text: string;
+    };
+}
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: number | string;
+    method: string;
+    params?: any;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+export declare const MCP_ERRORS: {
+    readonly PARSE_ERROR: {
+        readonly code: -32700;
+        readonly message: "Parse error";
+    };
+    readonly INVALID_REQUEST: {
+        readonly code: -32600;
+        readonly message: "Invalid Request";
+    };
+    readonly METHOD_NOT_FOUND: {
+        readonly code: -32601;
+        readonly message: "Method not found";
+    };
+    readonly INVALID_PARAMS: {
+        readonly code: -32602;
+        readonly message: "Invalid params";
+    };
+    readonly INTERNAL_ERROR: {
+        readonly code: -32603;
+        readonly message: "Internal error";
+    };
+    readonly TOOL_NOT_FOUND: {
+        readonly code: -32001;
+        readonly message: "Tool not found";
+    };
+    readonly RESOURCE_NOT_FOUND: {
+        readonly code: -32002;
+        readonly message: "Resource not found";
+    };
+    readonly PROMPT_NOT_FOUND: {
+        readonly code: -32003;
+        readonly message: "Prompt not found";
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/protocols/mcp/types.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * MCP Server types — JSON-RPC 2.0 based Model Context Protocol
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_ERRORS = void 0;
+exports.MCP_ERRORS = {
+    PARSE_ERROR: { code: -32700, message: 'Parse error' },
+    INVALID_REQUEST: { code: -32600, message: 'Invalid Request' },
+    METHOD_NOT_FOUND: { code: -32601, message: 'Method not found' },
+    INVALID_PARAMS: { code: -32602, message: 'Invalid params' },
+    INTERNAL_ERROR: { code: -32603, message: 'Internal error' },
+    TOOL_NOT_FOUND: { code: -32001, message: 'Tool not found' },
+    RESOURCE_NOT_FOUND: { code: -32002, message: 'Resource not found' },
+    PROMPT_NOT_FOUND: { code: -32003, message: 'Prompt not found' },
+};
+//# sourceMappingURL=types.js.map

package/dist/publish/index.d.ts

@@ -0,0 +1,45 @@
+export interface PackageManifest {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license: string;
+    agent: {
+        model: string;
+        provider: string;
+        channels: string[];
+        skills: string[];
+        tools: string[];
+    };
+    files: string[];
+    checksum: string;
+    createdAt: string;
+}
+export interface PublishOptions {
+    dryRun?: boolean;
+    registry?: string;
+    tag?: string;
+    access?: 'public' | 'private';
+}
+export declare class AgentPackager {
+    validate(dir: string): Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    listFiles(dir: string): Promise<string[]>;
+    pack(dir: string): Promise<{
+        path: string;
+        manifest: PackageManifest;
+    }>;
+}
+export declare class AgentPublisher {
+    publish(packagePath: string, manifest: PackageManifest, options?: PublishOptions): Promise<{
+        success: boolean;
+        url?: string;
+    }>;
+}
+export declare class AgentInstaller {
+    install(source: string, targetDir: string): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map