opc-agent 2.0.0 → 2.0.1

package/dist/studio/server.js

@@ -0,0 +1,625 @@
+"use strict";
+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.StudioServer = void 0;
+const http_1 = require("http");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const net = __importStar(require("net"));
+const MODULE_REGISTRY = [
+    { name: 'DeepBrain', path: 'brain', port: 4001, icon: '🧠' },
+    { name: 'AgentKits', path: 'kits', port: 4002, icon: '📊' },
+    { name: 'Workstation', path: 'workstation', port: 4003, icon: '👤' },
+];
+class StudioServer {
+    server;
+    config;
+    tracer;
+    constructor(config = {}) {
+        this.config = {
+            port: config.port || 4000,
+            agentDir: config.agentDir || process.cwd(),
+            staticDir: config.staticDir || (0, path_1.join)(__dirname, '../studio-ui'),
+        };
+    }
+    setTracer(tracer) {
+        this.tracer = tracer;
+    }
+    getTracer() {
+        return this.tracer;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    async start() {
+        this.server = (0, http_1.createServer)((req, res) => this.handleRequest(req, res));
+        this.server.listen(this.config.port);
+        console.log(`🎨 OPC Studio: http://localhost:${this.config.port}`);
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async handleRequest(req, res) {
+        const url = new URL(req.url || '/', `http://localhost`);
+        // Handle CORS preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type',
+            });
+            res.end();
+            return;
+        }
+        // API routes
+        if (url.pathname.startsWith('/api/')) {
+            return this.handleAPI(req, res, url);
+        }
+        // Module proxy routes
+        for (const mod of MODULE_REGISTRY) {
+            if (url.pathname.startsWith(`/${mod.path}/`) || url.pathname === `/${mod.path}`) {
+                return this.proxyToModule(req, res, mod, url);
+            }
+        }
+        // Static files
+        return this.serveStatic(req, res, url);
+    }
+    async handleAPI(req, res, url) {
+        const route = url.pathname.replace('/api/', '');
+        try {
+            let data;
+            switch (route) {
+                case 'modules':
+                    data = await this.getModulesStatus();
+                    break;
+                case 'agent/info':
+                    data = await this.getAgentInfo();
+                    break;
+                case 'agent/config':
+                    if (req.method === 'GET')
+                        data = await this.getAgentConfig();
+                    else if (req.method === 'PUT')
+                        data = await this.saveConfig(req);
+                    break;
+                case 'agent/chat':
+                    data = await this.handleChat(req);
+                    break;
+                case 'memory/list':
+                    data = await this.getMemoryList();
+                    break;
+                case 'memory/search':
+                    data = await this.searchMemory(url.searchParams.get('q') || '');
+                    break;
+                case 'memory/stats':
+                    data = await this.getMemoryStats();
+                    break;
+                case 'skills/list':
+                    data = await this.getSkills();
+                    break;
+                case 'tools/list':
+                    data = await this.getTools();
+                    break;
+                case 'workflows/list':
+                    data = await this.getWorkflows();
+                    break;
+                case 'jobs/list':
+                    data = await this.getJobs();
+                    break;
+                case 'logs/recent':
+                    data = await this.getRecentLogs();
+                    break;
+                case 'analytics/overview':
+                    data = await this.getAnalytics();
+                    break;
+                case 'doctor/check':
+                    data = await this.runDoctor();
+                    break;
+                case 'channels/list':
+                    data = await this.getChannels();
+                    break;
+                case 'plugins/list':
+                    data = await this.getPlugins();
+                    break;
+                case 'security/approvals':
+                    data = await this.getPendingApprovals();
+                    break;
+                case 'eval/suites':
+                    data = await this.getEvalSuites();
+                    break;
+                case 'eval/run':
+                    if (req.method === 'POST')
+                        data = await this.runEvalSuite(req);
+                    else {
+                        res.writeHead(405);
+                        res.end();
+                        return;
+                    }
+                    break;
+                case 'a2a/card':
+                    data = this.getA2ACard();
+                    break;
+                case 'a2a/tasks':
+                    data = this.getA2ATasks();
+                    break;
+                case 'a2a/discover':
+                    if (req.method === 'POST')
+                        data = await this.discoverA2AAgent(req);
+                    else {
+                        res.writeHead(405);
+                        res.end();
+                        return;
+                    }
+                    break;
+                case 'protocols':
+                    data = await this.getProtocols();
+                    break;
+                case 'protocols/mcp':
+                    data = this.getMCPServerStatus();
+                    break;
+                case 'eval/reports':
+                    data = await this.getEvalReports();
+                    break;
+                case 'telemetry/stats':
+                    data = this.tracer ? this.tracer.getStats() : { error: 'Telemetry not enabled' };
+                    break;
+                case 'telemetry/traces':
+                    data = this.getTelemetryTraces(url);
+                    break;
+                case 'telemetry/metrics':
+                    data = this.tracer ? this.tracer.getMetrics() : [];
+                    break;
+                default:
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Not found' }));
+                    return;
+            }
+            res.writeHead(200, {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*',
+            });
+            res.end(JSON.stringify(data));
+        }
+        catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: e.message }));
+        }
+    }
+    // --- API Implementations ---
+    async getAgentInfo() {
+        const oad = this.loadOAD();
+        const pkg = this.loadPackageJson();
+        return {
+            name: oad?.metadata?.name || pkg?.name || 'unknown',
+            version: oad?.metadata?.version || pkg?.version || '0.0.0',
+            description: oad?.metadata?.description || pkg?.description || '',
+            model: oad?.spec?.model || 'unknown',
+            provider: oad?.spec?.provider?.default || 'unknown',
+            channels: oad?.spec?.channels?.map((c) => c.type) || [],
+            skills: oad?.spec?.skills?.map((s) => s.name) || [],
+            status: 'running',
+        };
+    }
+    async getAgentConfig() {
+        const yamlPath = (0, path_1.join)(this.config.agentDir, 'agent.yaml');
+        if ((0, fs_1.existsSync)(yamlPath)) {
+            return { content: (0, fs_1.readFileSync)(yamlPath, 'utf-8') };
+        }
+        return { content: '', error: 'agent.yaml not found' };
+    }
+    async saveConfig(req) {
+        const body = await this.readBody(req);
+        const { content } = JSON.parse(body);
+        const yamlPath = (0, path_1.join)(this.config.agentDir, 'agent.yaml');
+        const { writeFileSync } = require('fs');
+        writeFileSync(yamlPath, content, 'utf-8');
+        return { success: true };
+    }
+    async handleChat(req) {
+        const body = await this.readBody(req);
+        const { message, sessionId } = JSON.parse(body);
+        try {
+            const { BaseAgent, InMemoryStore } = require('../index');
+            const oad = this.loadOAD();
+            const agent = new BaseAgent({
+                name: oad?.metadata?.name || 'studio-agent',
+                systemPrompt: oad?.spec?.systemPrompt || 'You are a helpful assistant.',
+                provider: oad?.spec?.provider?.default || 'ollama',
+                model: oad?.spec?.model || 'qwen2.5',
+                memory: new InMemoryStore(),
+            });
+            await agent.init();
+            const response = await agent.handleMessage({
+                id: String(Date.now()),
+                content: message,
+                sender: 'studio-user',
+                channel: 'studio',
+                sessionId: sessionId || 'studio-session',
+                timestamp: new Date(),
+            });
+            return { response: response.content };
+        }
+        catch (e) {
+            return { response: `Error: ${e.message}` };
+        }
+    }
+    async getMemoryList() {
+        try {
+            const { Brain } = require('deepbrain');
+            const oad = this.loadOAD();
+            const dbPath = oad?.spec?.memory?.longTerm?.database || './data/brain.db';
+            const brain = new Brain({ database: dbPath, embedding_provider: 'ollama' });
+            await brain.connect();
+            const pages = await brain.list({ limit: 50 });
+            await brain.disconnect();
+            return { pages };
+        }
+        catch {
+            return { pages: [], error: 'DeepBrain not available' };
+        }
+    }
+    async searchMemory(query) {
+        try {
+            const { Brain } = require('deepbrain');
+            const oad = this.loadOAD();
+            const dbPath = oad?.spec?.memory?.longTerm?.database || './data/brain.db';
+            const brain = new Brain({ database: dbPath, embedding_provider: 'ollama' });
+            await brain.connect();
+            const results = await brain.search(query);
+            await brain.disconnect();
+            return { results };
+        }
+        catch {
+            return { results: [], error: 'Search failed' };
+        }
+    }
+    async getMemoryStats() {
+        try {
+            const { Brain } = require('deepbrain');
+            const oad = this.loadOAD();
+            const dbPath = oad?.spec?.memory?.longTerm?.database || './data/brain.db';
+            const brain = new Brain({ database: dbPath, embedding_provider: 'ollama' });
+            await brain.connect();
+            const stats = await brain.stats();
+            await brain.disconnect();
+            return stats;
+        }
+        catch {
+            return { pages: 0, chunks: 0, error: 'Stats unavailable' };
+        }
+    }
+    async getSkills() {
+        try {
+            const { SkillLearner } = require('../index');
+            const learner = new SkillLearner('.opc/skills');
+            const skills = learner.loadSkills();
+            return { skills };
+        }
+        catch {
+            return { skills: [] };
+        }
+    }
+    async getTools() {
+        try {
+            const { getBuiltinTools } = require('../index');
+            const tools = getBuiltinTools(this.config.agentDir);
+            return { tools: tools.map((t) => ({ name: t.definition.name, description: t.definition.description })) };
+        }
+        catch {
+            return { tools: [] };
+        }
+    }
+    async getWorkflows() {
+        const oad = this.loadOAD();
+        return { workflows: oad?.spec?.workflows || [] };
+    }
+    async getJobs() {
+        const oad = this.loadOAD();
+        return { jobs: oad?.spec?.scheduler?.jobs || [] };
+    }
+    async getRecentLogs() {
+        const logPath = (0, path_1.join)(this.config.agentDir, '.opc', 'agent.log');
+        if ((0, fs_1.existsSync)(logPath)) {
+            const content = (0, fs_1.readFileSync)(logPath, 'utf-8');
+            const lines = content.split('\n').slice(-100);
+            return { lines };
+        }
+        return { lines: [] };
+    }
+    async getAnalytics() {
+        return {
+            totalMessages: 0,
+            totalSessions: 0,
+            avgResponseTime: 0,
+            topSkills: [],
+            note: 'Analytics tracking starts when agent is running via opc run/start',
+        };
+    }
+    async runDoctor() {
+        try {
+            const { runDoctor } = require('../doctor');
+            const results = await runDoctor();
+            return results;
+        }
+        catch {
+            return { error: 'Doctor not available' };
+        }
+    }
+    async getChannels() {
+        const oad = this.loadOAD();
+        return { channels: oad?.spec?.channels || [] };
+    }
+    async getPlugins() {
+        const oad = this.loadOAD();
+        return { plugins: oad?.spec?.plugins || [] };
+    }
+    async getProtocols() {
+        const oad = this.loadOAD();
+        const protocols = oad?.spec?.protocols || {};
+        return {
+            protocols: [
+                { name: 'a2a', description: 'Agent-to-Agent', enabled: !!protocols.a2a?.enabled, config: protocols.a2a || {} },
+                { name: 'agui', description: 'AG-UI — Agent-User Interaction (SSE)', enabled: !!protocols.agui?.enabled, config: protocols.agui || {} },
+                { name: 'mcp', description: 'MCP Server — Expose as MCP tools', enabled: !!protocols.mcp?.enabled, config: protocols.mcp || {} },
+            ],
+        };
+    }
+    async getPendingApprovals() {
+        return { approvals: [] };
+    }
+    getMCPServerStatus() {
+        const oad = this.loadOAD();
+        const mcpConfig = oad?.spec?.protocols?.mcp;
+        const { agentToMCPTools } = require('../protocols/mcp/agent-tools');
+        const agentName = oad?.metadata?.name || 'opc-agent';
+        const tools = agentToMCPTools({ name: agentName });
+        return {
+            enabled: !!mcpConfig?.enabled,
+            mode: mcpConfig?.mode || 'stdio',
+            port: mcpConfig?.port || 3002,
+            tools: tools.map((t) => ({ name: t.name, description: t.description })),
+            toolCount: tools.length,
+            exposedTools: mcpConfig?.exposedTools || tools.map((t) => t.name),
+        };
+    }
+    getTelemetryTraces(url) {
+        if (!this.tracer)
+            return { traces: [] };
+        const traceId = url.searchParams.get('id');
+        if (traceId) {
+            return { spans: this.tracer.getTrace(traceId) };
+        }
+        const limit = parseInt(url.searchParams.get('limit') || '50');
+        const spans = this.tracer.getSpans({ limit });
+        // Group by traceId for trace list
+        const traceMap = new Map();
+        for (const s of spans) {
+            if (!traceMap.has(s.traceId)) {
+                traceMap.set(s.traceId, { traceId: s.traceId, rootSpan: s.name, startTime: s.startTime, spanCount: 0, status: s.status });
+            }
+            traceMap.get(s.traceId).spanCount++;
+        }
+        return { traces: Array.from(traceMap.values()) };
+    }
+    async getEvalSuites() {
+        const { AgentEvaluator } = require('../eval');
+        return { suites: AgentEvaluator.builtinSuites() };
+    }
+    async runEvalSuite(req) {
+        const body = await this.readBody(req);
+        const { suite: suiteName } = JSON.parse(body || '{}');
+        const { AgentEvaluator } = require('../eval');
+        const suite = AgentEvaluator.loadBuiltinSuite(suiteName || 'basic');
+        // Use a mock agent for studio eval (no real agent loaded)
+        const mockAgent = { chat: async (input) => `[mock response to: ${input}]` };
+        const evaluator = new AgentEvaluator(mockAgent);
+        const report = await evaluator.evalSuite(suite);
+        // Save report
+        const reportsDir = (0, path_1.join)(this.config.agentDir, '.eval-reports');
+        const reportPath = (0, path_1.join)(reportsDir, `${suiteName || 'basic'}-${Date.now()}.json`);
+        AgentEvaluator.saveReport(report, reportPath);
+        return report;
+    }
+    async getEvalReports() {
+        const reportsDir = (0, path_1.join)(this.config.agentDir, '.eval-reports');
+        if (!(0, fs_1.existsSync)(reportsDir))
+            return { reports: [] };
+        const files = require('fs').readdirSync(reportsDir).filter((f) => f.endsWith('.json'));
+        return {
+            reports: files.map((f) => {
+                try {
+                    return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(reportsDir, f), 'utf-8'));
+                }
+                catch {
+                    return null;
+                }
+            }).filter(Boolean)
+        };
+    }
+    // --- A2A Protocol ---
+    getA2ACard() {
+        try {
+            const { oadToAgentCard } = require('../protocols/a2a');
+            const yaml = require('js-yaml');
+            for (const name of ['agent.yaml', 'agent.yml']) {
+                const p = (0, path_1.join)(this.config.agentDir, name);
+                if ((0, fs_1.existsSync)(p)) {
+                    const oad = yaml.load((0, fs_1.readFileSync)(p, 'utf-8'));
+                    return oadToAgentCard(oad, `http://localhost:${this.config.port}`);
+                }
+            }
+            return { error: 'No agent.yaml found' };
+        }
+        catch {
+            return { error: 'Failed to generate agent card' };
+        }
+    }
+    getA2ATasks() {
+        // In-memory tasks from A2A server if running
+        return { tasks: [] };
+    }
+    async discoverA2AAgent(req) {
+        const body = await this.readBody(req);
+        const { url } = JSON.parse(body || '{}');
+        if (!url)
+            return { error: 'url required' };
+        try {
+            const { A2AClient } = require('../protocols/a2a');
+            const client = new A2AClient(url);
+            return await client.getAgentCard();
+        }
+        catch (err) {
+            return { error: err.message };
+        }
+    }
+    // --- Module Proxy & Health ---
+    proxyToModule(req, res, mod, url) {
+        const targetPath = url.pathname.slice(`/${mod.path}`.length) || '/';
+        const proxyReq = (0, http_1.request)({
+            hostname: 'localhost',
+            port: mod.port,
+            path: targetPath + (url.search || ''),
+            method: req.method,
+            headers: { ...req.headers, host: `localhost:${mod.port}` },
+        }, (proxyRes) => {
+            res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+            proxyRes.pipe(res, { end: true });
+        });
+        proxyReq.on('error', () => {
+            res.writeHead(502, { 'Content-Type': 'text/html' });
+            res.end(`<html><body style="font-family:system-ui;padding:40px;color:#999;background:#1a1a2e;text-align:center"><h2>${mod.icon} ${mod.name}</h2><p>Module not running on port ${mod.port}</p></body></html>`);
+        });
+        req.pipe(proxyReq, { end: true });
+    }
+    checkPort(port) {
+        return new Promise((resolve) => {
+            const sock = new net.Socket();
+            sock.setTimeout(500);
+            sock.once('connect', () => { sock.destroy(); resolve(true); });
+            sock.once('error', () => { sock.destroy(); resolve(false); });
+            sock.once('timeout', () => { sock.destroy(); resolve(false); });
+            sock.connect(port, 'localhost');
+        });
+    }
+    async getModulesStatus() {
+        const modules = await Promise.all(MODULE_REGISTRY.map(async (mod) => ({
+            name: mod.name,
+            path: `/${mod.path}/`,
+            port: mod.port,
+            icon: mod.icon,
+            running: await this.checkPort(mod.port),
+        })));
+        return { modules };
+    }
+    // --- Helpers ---
+    loadOAD() {
+        try {
+            const yamlPath = (0, path_1.join)(this.config.agentDir, 'agent.yaml');
+            if (!(0, fs_1.existsSync)(yamlPath))
+                return null;
+            const content = (0, fs_1.readFileSync)(yamlPath, 'utf-8');
+            try {
+                const { loadOAD } = require('../index');
+                return loadOAD(yamlPath);
+            }
+            catch {
+                // Fallback: simple yaml parse
+                const yaml = require('js-yaml');
+                return yaml.load(content);
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    loadPackageJson() {
+        try {
+            const pkgPath = (0, path_1.join)(this.config.agentDir, 'package.json');
+            if (!(0, fs_1.existsSync)(pkgPath))
+                return null;
+            return JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    serveStatic(req, res, url) {
+        let filePath = url.pathname === '/' ? '/index.html' : url.pathname;
+        const fullPath = (0, path_1.join)(this.config.staticDir, filePath);
+        if (!(0, fs_1.existsSync)(fullPath)) {
+            // SPA fallback
+            const indexPath = (0, path_1.join)(this.config.staticDir, 'index.html');
+            if ((0, fs_1.existsSync)(indexPath)) {
+                const content = (0, fs_1.readFileSync)(indexPath, 'utf-8');
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(content);
+                return;
+            }
+            res.writeHead(404);
+            res.end('Not found');
+            return;
+        }
+        const mimeTypes = {
+            '.html': 'text/html',
+            '.css': 'text/css',
+            '.js': 'application/javascript',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.svg': 'image/svg+xml',
+            '.ico': 'image/x-icon',
+        };
+        const ext = (0, path_1.extname)(fullPath);
+        const contentType = mimeTypes[ext] || 'application/octet-stream';
+        const content = (0, fs_1.readFileSync)(fullPath);
+        res.writeHead(200, { 'Content-Type': contentType });
+        res.end(content);
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let body = '';
+            req.on('data', (chunk) => (body += chunk));
+            req.on('end', () => resolve(body));
+            req.on('error', reject);
+        });
+    }
+}
+exports.StudioServer = StudioServer;
+//# sourceMappingURL=server.js.map