opc-agent 3.0.1 → 4.0.1

package/dist/studio/server.js

@@ -37,22 +37,56 @@ exports.StudioServer = void 0;
 const http_1 = require("http");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const os = __importStar(require("os"));
 const net = __importStar(require("net"));
+const templates_data_1 = require("./templates-data");
+const marketplace_1 = require("../skills/marketplace");
+const cron_engine_1 = require("../scheduler/cron-engine");
+const image_generator_1 = require("../tools/image-generator");
+const document_processor_1 = require("../tools/document-processor");
 const MODULE_REGISTRY = [
     { name: 'DeepBrain', path: 'brain', port: 4001, icon: '🧠' },
     { name: 'AgentKits', path: 'kits', port: 4002, icon: '📊' },
     { name: 'Workstation', path: 'workstation', port: 4003, icon: '👤' },
 ];
+// Settings config helpers
+function getSettingsConfigPath() {
+    const dir = (0, path_1.join)(os.homedir(), '.opc');
+    if (!(0, fs_1.existsSync)(dir))
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, path_1.join)(dir, 'config.json');
+}
+function loadSettingsConfig() {
+    const p = getSettingsConfigPath();
+    if ((0, fs_1.existsSync)(p)) {
+        try {
+            return JSON.parse((0, fs_1.readFileSync)(p, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+function saveSettingsConfig(config) {
+    (0, fs_1.writeFileSync)(getSettingsConfigPath(), JSON.stringify(config, null, 2));
+}
 class StudioServer {
     server;
     config;
     tracer;
+    skillMarketplace;
+    cronEngine;
+    imageGenerator;
     constructor(config = {}) {
         this.config = {
             port: config.port || 4000,
             agentDir: config.agentDir || process.cwd(),
             staticDir: config.staticDir || (0, path_1.join)(__dirname, '../studio-ui'),
         };
+        this.cronEngine = new cron_engine_1.CronEngine();
+        this.imageGenerator = new image_generator_1.ImageGenerator();
+        this.skillMarketplace = new marketplace_1.SkillMarketplace();
     }
     setTracer(tracer) {
         this.tracer = tracer;
@@ -64,11 +98,19 @@ class StudioServer {
         return { ...this.config };
     }
     async start() {
+        const opcDir = (0, path_1.join)(os.homedir(), '.opc');
+        if (!(0, fs_1.existsSync)(opcDir))
+            (0, fs_1.mkdirSync)(opcDir, { recursive: true });
+        const cfgPath = (0, path_1.join)(opcDir, 'config.json');
+        if (!(0, fs_1.existsSync)(cfgPath))
+            (0, fs_1.writeFileSync)(cfgPath, JSON.stringify({}, null, 2));
         this.server = (0, http_1.createServer)((req, res) => this.handleRequest(req, res));
         this.server.listen(this.config.port);
+        this.cronEngine.start();
         console.log(`🎨 OPC Studio: http://localhost:${this.config.port}`);
     }
     async stop() {
+        this.cronEngine.stop();
         return new Promise((resolve) => {
             if (this.server) {
                 this.server.close(() => resolve());
@@ -107,6 +149,195 @@ class StudioServer {
         const route = url.pathname.replace('/api/', '');
         try {
             let data;
+            // Dynamic agent routes
+            if (route === 'agents' && req.method === 'POST') {
+                data = await this.createAgent(req);
+                res.writeHead(201, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'agents' && req.method === 'GET') {
+                data = this.listAgents();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'templates' && req.method === 'GET') {
+                const industry = url.searchParams.get('industry') || '';
+                const search = url.searchParams.get('q') || '';
+                data = this.getTemplates(industry, search);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^templates\/[^/]+$/) && req.method === 'GET') {
+                const tplId = route.split('/')[1];
+                data = this.getTemplateById(tplId);
+                res.writeHead(data.error ? 404 : 200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^agents\/[^/]+\/memory$/) && req.method === 'GET') {
+                const agentId = route.split('/')[1];
+                data = this.getAgentMemory(agentId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^agents\/[^/]+\/chat$/) && req.method === 'POST') {
+                const agentId = route.split('/')[1];
+                return this.handleAgentChat(req, res, agentId);
+            }
+            if (route.match(/^agents\/[^/]+$/) && req.method === 'GET') {
+                const agentId = route.split('/')[1];
+                data = this.getAgentById(agentId);
+                res.writeHead(data.error ? 404 : 200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^agents\/[^/]+$/) && req.method === 'PUT') {
+                const agentId = route.split('/')[1];
+                data = await this.updateAgent(agentId, req);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^agents\/[^/]+$/) && req.method === 'DELETE') {
+                const agentId = route.split('/')[1];
+                data = this.deleteAgent(agentId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            // --- Document upload routes ---
+            if (route.match(/^agents\/[^/]+\/upload$/) && req.method === 'POST') {
+                const agentId = route.split('/')[1];
+                return this.handleDocumentUpload(req, res, agentId);
+            }
+            if (route.match(/^agents\/[^/]+\/documents$/) && req.method === 'GET') {
+                const agentId = route.split('/')[1];
+                data = this.getDocumentList(agentId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^agents\/[^/]+\/documents\/[^/]+$/) && req.method === 'DELETE') {
+                const parts = route.split('/');
+                const agentId = parts[1];
+                const docId = parts[3];
+                data = this.deleteDocument(agentId, docId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            // --- Settings API routes ---
+            if (route === 'settings/models' && req.method === 'GET') {
+                const cfg = loadSettingsConfig();
+                data = cfg.models || { mode: 'local', provider: 'ollama', chatModel: 'qwen2.5:7b', embeddingModel: 'nomic-embed-text', providers: {} };
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/models' && req.method === 'PUT') {
+                const body = JSON.parse(await this.readBody(req));
+                const cfg = loadSettingsConfig();
+                cfg.models = { ...(cfg.models || {}), ...body };
+                saveSettingsConfig(cfg);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify({ success: true, models: cfg.models }));
+                return;
+            }
+            if (route === 'settings/models/test' && req.method === 'POST') {
+                const body = JSON.parse(await this.readBody(req));
+                const { provider, apiKey, baseUrl } = body;
+                data = await this.testModelConnection(provider, apiKey, baseUrl);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/models/local' && req.method === 'GET') {
+                data = await this.detectLocalOllama();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/channels' && req.method === 'GET') {
+                const cfg = loadSettingsConfig();
+                data = cfg.channels || {};
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^settings\/channels\/[^/]+$/) && req.method === 'PUT') {
+                const channelName = route.split('/')[2];
+                const body = JSON.parse(await this.readBody(req));
+                const cfg = loadSettingsConfig();
+                if (!cfg.channels)
+                    cfg.channels = {};
+                cfg.channels[channelName] = { ...(cfg.channels[channelName] || {}), ...body, updated: new Date().toISOString() };
+                saveSettingsConfig(cfg);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify({ success: true, channel: cfg.channels[channelName] }));
+                return;
+            }
+            // Web Search settings
+            if (route === 'settings/search' && req.method === 'GET') {
+                const cfg = loadSettingsConfig();
+                data = cfg.webSearch || { defaultEngine: 'duckduckgo', enabled: true, engines: { duckduckgo: { enabled: true } } };
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/search' && req.method === 'PUT') {
+                const body = JSON.parse(await this.readBody(req));
+                const cfg = loadSettingsConfig();
+                cfg.webSearch = { ...(cfg.webSearch || {}), ...body, updated: new Date().toISOString() };
+                saveSettingsConfig(cfg);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify({ success: true, config: cfg.webSearch }));
+                return;
+            }
+            if (route === 'settings/search/test' && req.method === 'POST') {
+                try {
+                    const { webSearch: doSearch } = require('../tools/web-search');
+                    const body = JSON.parse(await this.readBody(req));
+                    const query = body.query || 'test search';
+                    const cfg = loadSettingsConfig();
+                    const searchCfg = { ...(cfg.webSearch || { defaultEngine: 'duckduckgo', enabled: true, engines: { duckduckgo: { enabled: true } } }), ...body.config };
+                    const results = await doSearch(query, searchCfg, { maxResults: 3 });
+                    data = { success: true, results, engine: searchCfg.defaultEngine };
+                }
+                catch (e) {
+                    data = { success: false, error: e.message };
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/status' && req.method === 'GET') {
+                data = await this.getSettingsStatus();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/status/start' && req.method === 'POST') {
+                data = { success: true, status: 'running', message: 'Agent started' };
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/status/stop' && req.method === 'POST') {
+                data = { success: true, status: 'stopped', message: 'Agent stopped' };
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'settings/usage' && req.method === 'GET') {
+                data = await this.getUsageStats();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
             // Dynamic workflow routes (parameterized)
             if (route.match(/^workflows\/[^/]+\/run$/) && req.method === 'POST') {
                 const wfId = route.split('/')[1];
@@ -129,6 +360,119 @@ class StudioServer {
                 res.end(JSON.stringify(data));
                 return;
             }
+            // --- Schedules API ---
+            if (route === 'schedules' && req.method === 'GET') {
+                data = this.cronEngine.listTasks();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'schedules' && req.method === 'POST') {
+                const body = JSON.parse(await this.readBody(req));
+                data = this.cronEngine.createTask(body);
+                res.writeHead(201, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^schedules\/[^/]+$/) && req.method === 'PUT') {
+                const id = route.split('/')[1];
+                const body = JSON.parse(await this.readBody(req));
+                data = this.cronEngine.updateTask(id, body);
+                res.writeHead(data ? 200 : 404, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data || { error: 'Schedule not found' }));
+                return;
+            }
+            if (route.match(/^schedules\/[^/]+$/) && req.method === 'DELETE') {
+                const id = route.split('/')[1];
+                const success = this.cronEngine.deleteTask(id);
+                res.writeHead(success ? 200 : 404, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify({ success }));
+                return;
+            }
+            if (route.match(/^schedules\/[^/]+\/run$/) && req.method === 'POST') {
+                const id = route.split('/')[1];
+                const success = await this.cronEngine.runTask(id);
+                res.writeHead(success ? 200 : 404, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify({ success }));
+                return;
+            }
+            // --- Image Generation API ---
+            if (route === 'image-gen/status' && req.method === 'GET') {
+                data = this.imageGenerator.getStatus();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'image-gen/generate' && req.method === 'POST') {
+                const body = JSON.parse(await this.readBody(req));
+                data = await this.imageGenerator.generate(body.prompt, body);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'image-gen/config' && req.method === 'PUT') {
+                const body = JSON.parse(await this.readBody(req));
+                const cfg = loadSettingsConfig();
+                cfg.imageGen = { ...(cfg.imageGen || {}), ...body };
+                saveSettingsConfig(cfg);
+                this.imageGenerator = new image_generator_1.ImageGenerator({
+                    openaiApiKey: body.openaiApiKey,
+                    replicateApiKey: body.replicateApiKey,
+                    sdApiUrl: body.sdApiUrl,
+                });
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify({ success: true }));
+                return;
+            }
+            if (route === 'first-run/status' && req.method === 'GET') {
+                data = await this.getFirstRunStatus();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'first-run/complete' && req.method === 'POST') {
+                const body = JSON.parse(await this.readBody(req));
+                data = await this.completeFirstRun(body);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            // === Skill Marketplace API ===
+            if (route === 'skills/marketplace' && req.method === 'GET') {
+                const category = url.searchParams.get('category') || undefined;
+                const search = url.searchParams.get('q') || undefined;
+                data = this.skillMarketplace.listAll(category, search);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'skills/installed' && req.method === 'GET') {
+                data = this.skillMarketplace.getInstalled();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^skills\/marketplace\/[^/]+$/) && req.method === 'GET') {
+                const skillId = route.split('/')[2];
+                data = this.skillMarketplace.getSkill(skillId);
+                res.writeHead(data ? 200 : 404, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data || { error: 'Skill not found' }));
+                return;
+            }
+            if (route.match(/^skills\/marketplace\/[^/]+\/install$/) && req.method === 'POST') {
+                const skillId = route.split('/')[2];
+                data = this.skillMarketplace.install(skillId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^skills\/marketplace\/[^/]+\/uninstall$/) && req.method === 'DELETE') {
+                const skillId = route.split('/')[2];
+                data = this.skillMarketplace.uninstall(skillId);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
             switch (route) {
                 case 'modules':
                     data = await this.getModulesStatus();
@@ -266,6 +610,254 @@ class StudioServer {
             res.end(JSON.stringify({ error: e.message }));
         }
     }
+    // --- Agent CRUD & Templates ---
+    getAgentsDir() {
+        const dir = (0, path_1.join)(os.homedir(), '.opc', 'agents');
+        if (!(0, fs_1.existsSync)(dir))
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        return dir;
+    }
+    async createAgent(req) {
+        const body = await this.readBody(req);
+        const { name, templateId, description, model, language } = JSON.parse(body);
+        const template = templates_data_1.TEMPLATES.find(t => t.id === templateId);
+        const id = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const agent = {
+            id,
+            name: name || template?.name || 'My Agent',
+            templateId: templateId || null,
+            templateName: template?.name || 'Custom',
+            templateIcon: template?.icon || '🤖',
+            description: description || template?.description || '',
+            model: model || template?.suggestedModel || 'gpt-4o-mini',
+            language: language || 'en',
+            systemPrompt: template?.systemPrompt || 'You are a helpful assistant.',
+            industry: template?.industry || 'general',
+            created: new Date().toISOString(),
+            updated: new Date().toISOString(),
+            messageCount: 0,
+            lastActive: new Date().toISOString(),
+        };
+        const filePath = (0, path_1.join)(this.getAgentsDir(), `${id}.json`);
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(agent, null, 2));
+        return agent;
+    }
+    listAgents() {
+        const dir = this.getAgentsDir();
+        const files = (0, fs_1.readdirSync)(dir).filter(f => f.endsWith('.json'));
+        const agents = files.map(f => {
+            try {
+                return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(dir, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean).sort((a, b) => new Date(b.updated).getTime() - new Date(a.updated).getTime());
+        return { agents };
+    }
+    getAgentById(id) {
+        const filePath = (0, path_1.join)(this.getAgentsDir(), `${id}.json`);
+        if (!(0, fs_1.existsSync)(filePath))
+            return { error: 'Agent not found' };
+        return JSON.parse((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    }
+    async updateAgent(id, req) {
+        const filePath = (0, path_1.join)(this.getAgentsDir(), `${id}.json`);
+        if (!(0, fs_1.existsSync)(filePath))
+            return { error: 'Agent not found' };
+        const existing = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf-8'));
+        const body = await this.readBody(req);
+        const updates = JSON.parse(body);
+        const updated = { ...existing, ...updates, id, updated: new Date().toISOString() };
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(updated, null, 2));
+        return updated;
+    }
+    deleteAgent(id) {
+        const filePath = (0, path_1.join)(this.getAgentsDir(), `${id}.json`);
+        if ((0, fs_1.existsSync)(filePath))
+            (0, fs_1.unlinkSync)(filePath);
+        return { success: true };
+    }
+    getTemplates(industry, search) {
+        let filtered = templates_data_1.TEMPLATES;
+        if (industry)
+            filtered = filtered.filter(t => t.industry === industry);
+        if (search) {
+            const q = search.toLowerCase();
+            filtered = filtered.filter(t => t.name.toLowerCase().includes(q) || t.nameZh.includes(q) ||
+                t.description.toLowerCase().includes(q) || t.descriptionZh.includes(q) ||
+                t.tags.some(tag => tag.includes(q)));
+        }
+        return { templates: filtered, industries: templates_data_1.INDUSTRIES };
+    }
+    getTemplateById(id) {
+        const tpl = templates_data_1.TEMPLATES.find(t => t.id === id);
+        return tpl || { error: 'Template not found' };
+    }
+    getAgentMemory(agentId) {
+        const memDir = (0, path_1.join)(this.getAgentsDir(), agentId + '-memory');
+        if (!(0, fs_1.existsSync)(memDir))
+            return { entries: [], timeline: [] };
+        const files = (0, fs_1.readdirSync)(memDir).filter(f => f.endsWith('.json'));
+        const entries = files.map(f => {
+            try {
+                return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(memDir, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        return { entries, timeline: entries.map((e) => ({ date: e.timestamp, summary: e.summary || e.content?.slice(0, 100) })) };
+    }
+    async handleAgentChat(req, res, agentId) {
+        const body = JSON.parse(await this.readBody(req));
+        const { messages = [] } = body;
+        const agent = this.getAgentById(agentId);
+        if (agent.error) {
+            res.writeHead(404, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+            res.end(JSON.stringify(agent));
+            return;
+        }
+        // Update message count
+        agent.messageCount = (agent.messageCount || 0) + 1;
+        agent.lastActive = new Date().toISOString();
+        agent.updated = new Date().toISOString();
+        const filePath = (0, path_1.join)(this.getAgentsDir(), `${agentId}.json`);
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(agent, null, 2));
+        // SSE streaming response
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+        });
+        const allMsgs = [{ role: 'system', content: agent.systemPrompt }, ...messages];
+        const lastMsg = allMsgs[allMsgs.length - 1]?.content || '';
+        // Try to call the real /v1/chat/completions endpoint
+        try {
+            const completionReq = (0, http_1.request)({
+                hostname: 'localhost',
+                port: this.config.port,
+                path: '/v1/chat/completions',
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+            }, (completionRes) => {
+                if (completionRes.statusCode === 200) {
+                    completionRes.pipe(res);
+                }
+                else {
+                    // Fallback to simulated response
+                    this.sendSimulatedResponse(res, lastMsg, agent);
+                }
+            });
+            completionReq.on('error', () => {
+                this.sendSimulatedResponse(res, lastMsg, agent);
+            });
+            completionReq.write(JSON.stringify({
+                model: agent.model,
+                messages: allMsgs,
+                stream: true,
+            }));
+            completionReq.end();
+        }
+        catch {
+            this.sendSimulatedResponse(res, lastMsg, agent);
+        }
+    }
+    sendSimulatedResponse(res, lastMsg, agent) {
+        const response = `Hello! I'm ${agent.name}. You said: "${lastMsg}"\n\nI'm ready to help you. (Note: Connect a model provider for real AI responses)`;
+        const words = response.split(' ');
+        let i = 0;
+        const interval = setInterval(() => {
+            if (i >= words.length) {
+                res.write('data: [DONE]\n\n');
+                res.end();
+                clearInterval(interval);
+                return;
+            }
+            const chunk = (i === 0 ? '' : ' ') + words[i];
+            res.write(`data: ${JSON.stringify({ choices: [{ delta: { content: chunk } }] })}\n\n`);
+            i++;
+        }, 50);
+    }
+    // --- Settings Implementations ---
+    async detectLocalOllama() {
+        return new Promise((resolve) => {
+            const req = (0, http_1.request)({ hostname: 'localhost', port: 11434, path: '/api/tags', method: 'GET', timeout: 3000 }, (res) => {
+                let body = '';
+                res.on('data', (c) => body += c);
+                res.on('end', () => {
+                    try {
+                        const data = JSON.parse(body);
+                        const models = (data.models || []).map((m) => ({
+                            name: m.name, size: m.size, modified: m.modified_at,
+                            details: m.details || {},
+                        }));
+                        resolve({ running: true, models });
+                    }
+                    catch {
+                        resolve({ running: true, models: [] });
+                    }
+                });
+            });
+            req.on('error', () => resolve({ running: false, models: [] }));
+            req.on('timeout', () => { req.destroy(); resolve({ running: false, models: [] }); });
+            req.end();
+        });
+    }
+    async testModelConnection(provider, apiKey, baseUrl) {
+        const endpoints = {
+            openai: { url: 'api.openai.com', path: '/v1/models' },
+            deepseek: { url: 'api.deepseek.com', path: '/v1/models' },
+            anthropic: { url: 'api.anthropic.com', path: '/v1/models' },
+            openrouter: { url: 'openrouter.ai', path: '/api/v1/models' },
+        };
+        const ep = endpoints[provider];
+        if (!ep && !baseUrl)
+            return { success: false, error: 'Unknown provider' };
+        const hostname = baseUrl ? new URL(baseUrl).hostname : ep.url;
+        const path = baseUrl ? '/v1/models' : ep.path;
+        const headers = { 'Authorization': `Bearer ${apiKey}` };
+        if (provider === 'anthropic') {
+            headers['x-api-key'] = apiKey;
+            headers['anthropic-version'] = '2023-06-01';
+            delete headers['Authorization'];
+        }
+        return new Promise((resolve) => {
+            const https = require('https');
+            const req = https.request({ hostname, path, method: 'GET', headers, timeout: 10000 }, (res) => {
+                resolve({ success: res.statusCode === 200, statusCode: res.statusCode });
+            });
+            req.on('error', (e) => resolve({ success: false, error: e.message }));
+            req.on('timeout', () => { req.destroy(); resolve({ success: false, error: 'Timeout' }); });
+            req.end();
+        });
+    }
+    async getSettingsStatus() {
+        const uptime = process.uptime();
+        const mem = process.memoryUsage();
+        const modules = await this.getModulesStatus();
+        const logPath = (0, path_1.join)(this.config.agentDir, '.opc', 'agent.log');
+        let recentLogs = [];
+        if ((0, fs_1.existsSync)(logPath)) {
+            const content = (0, fs_1.readFileSync)(logPath, 'utf-8');
+            recentLogs = content.split('\n').slice(-50);
+        }
+        return {
+            status: 'running',
+            uptime,
+            memory: { rss: mem.rss, heapUsed: mem.heapUsed, heapTotal: mem.heapTotal },
+            cpu: os.loadavg(),
+            modules: modules.modules,
+            logs: recentLogs,
+            startedAt: new Date(Date.now() - uptime * 1000).toISOString(),
+        };
+    }
+    async getUsageStats() {
+        const cfg = loadSettingsConfig();
+        const usage = cfg.usage || { totalTokens: 0, totalCost: 0, daily: [], byModel: {} };
+        return usage;
+    }
     // --- API Implementations ---
     async getAgentInfo() {
         const oad = this.loadOAD();
@@ -640,6 +1232,32 @@ class StudioServer {
             return { error: err.message };
         }
     }
+    async getFirstRunStatus() {
+        const configPath = (0, path_1.join)(os.homedir(), '.opc', 'config.json');
+        const ollamaStatus = await this.detectLocalOllama();
+        if (!(0, fs_1.existsSync)(configPath)) {
+            return { firstRun: true, ollamaDetected: ollamaStatus.running, ollamaModels: ollamaStatus.models || [] };
+        }
+        try {
+            const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+            return { firstRun: !config.firstRunComplete, ollamaDetected: ollamaStatus.running, ollamaModels: ollamaStatus.models || [] };
+        }
+        catch {
+            return { firstRun: true, ollamaDetected: ollamaStatus.running, ollamaModels: ollamaStatus.models || [] };
+        }
+    }
+    async completeFirstRun(choices) {
+        const cfg = loadSettingsConfig();
+        cfg.firstRunComplete = true;
+        if (choices) {
+            if (choices.templateId)
+                cfg.firstRunTemplate = choices.templateId;
+            if (choices.model)
+                cfg.models = { ...(cfg.models || {}), chatModel: choices.model };
+        }
+        saveSettingsConfig(cfg);
+        return { success: true };
+    }
     // --- Module Proxy & Health ---
     proxyToModule(req, res, mod, url) {
         const targetPath = url.pathname.slice(`/${mod.path}`.length) || '/';
@@ -763,6 +1381,168 @@ class StudioServer {
         res.write('data: [DONE]\n\n');
         res.end();
     }
+    // --- Document upload handlers ---
+    getDocumentsDir(agentId) {
+        const dir = (0, path_1.join)(this.getAgentsDir(), agentId + '-documents');
+        if (!(0, fs_1.existsSync)(dir))
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        return dir;
+    }
+    async handleDocumentUpload(req, res, agentId) {
+        const corsHeaders = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' };
+        try {
+            // Parse multipart form data manually
+            const { buffer, filename } = await this.parseMultipart(req);
+            if (!filename) {
+                res.writeHead(400, corsHeaders);
+                res.end(JSON.stringify({ error: 'No file uploaded' }));
+                return;
+            }
+            if (buffer.length > 50 * 1024 * 1024) {
+                res.writeHead(413, corsHeaders);
+                res.end(JSON.stringify({ error: 'File too large (max 50MB)' }));
+                return;
+            }
+            // Process document
+            const processor = new document_processor_1.DocumentProcessor();
+            const doc = await processor.process(buffer, filename);
+            // Store chunks via DeepBrain learn()
+            let learnedCount = 0;
+            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();
+                for (const chunk of doc.chunks) {
+                    const content = `[Source: ${filename}] ${chunk.title}\n\n${chunk.content}`;
+                    if (typeof brain.store === 'function') {
+                        await brain.store('documents', `${doc.id}-${chunk.metadata.chunkIndex}`, content, {
+                            source: filename,
+                            docId: doc.id,
+                            chunkIndex: chunk.metadata.chunkIndex,
+                            tags: ['document-upload', filename],
+                        });
+                    }
+                    else if (typeof brain.learn === 'function') {
+                        await brain.learn(content, {
+                            tags: ['document-upload', filename],
+                            slug: `${doc.id}-${chunk.metadata.chunkIndex}`,
+                        });
+                    }
+                    learnedCount++;
+                }
+                await brain.disconnect();
+            }
+            catch {
+                // If DeepBrain is not available, store in local memory files
+                const memDir = (0, path_1.join)(this.getAgentsDir(), agentId + '-memory');
+                if (!(0, fs_1.existsSync)(memDir))
+                    (0, fs_1.mkdirSync)(memDir, { recursive: true });
+                for (const chunk of doc.chunks) {
+                    const entry = {
+                        id: `${doc.id}-${chunk.metadata.chunkIndex}`,
+                        content: chunk.content,
+                        summary: `[${filename}] ${chunk.title}`,
+                        timestamp: new Date().toISOString(),
+                        source: filename,
+                        docId: doc.id,
+                        tags: ['document-upload'],
+                    };
+                    (0, fs_1.writeFileSync)((0, path_1.join)(memDir, `${entry.id}.json`), JSON.stringify(entry, null, 2));
+                    learnedCount++;
+                }
+            }
+            // Save document metadata
+            const docsDir = this.getDocumentsDir(agentId);
+            const docMeta = {
+                id: doc.id,
+                filename: doc.filename,
+                format: doc.format,
+                size: doc.size,
+                chunks: doc.chunks.length,
+                processedAt: doc.processedAt,
+            };
+            (0, fs_1.writeFileSync)((0, path_1.join)(docsDir, `${doc.id}.json`), JSON.stringify(docMeta, null, 2));
+            res.writeHead(200, corsHeaders);
+            res.end(JSON.stringify({ success: true, document: docMeta, learnedCount }));
+        }
+        catch (e) {
+            res.writeHead(500, corsHeaders);
+            res.end(JSON.stringify({ error: e.message || 'Upload failed' }));
+        }
+    }
+    async parseMultipart(req) {
+        return new Promise((resolve, reject) => {
+            const contentType = req.headers['content-type'] || '';
+            const boundaryMatch = contentType.match(/boundary=(.+)/);
+            if (!boundaryMatch) {
+                reject(new Error('Missing multipart boundary'));
+                return;
+            }
+            const boundary = boundaryMatch[1];
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('error', reject);
+            req.on('end', () => {
+                const body = Buffer.concat(chunks);
+                const bodyStr = body.toString('latin1');
+                const parts = bodyStr.split('--' + boundary).filter(p => p.trim() && p.trim() !== '--');
+                for (const part of parts) {
+                    const headerEnd = part.indexOf('\r\n\r\n');
+                    if (headerEnd === -1)
+                        continue;
+                    const headers = part.slice(0, headerEnd);
+                    const filenameMatch = headers.match(/filename="([^"]+)"/);
+                    if (!filenameMatch)
+                        continue;
+                    const filename = filenameMatch[1];
+                    // Extract binary content properly
+                    const contentStart = body.indexOf('\r\n\r\n', body.indexOf(Buffer.from(headers.slice(0, 40), 'latin1'))) + 4;
+                    const nextBoundary = body.indexOf(Buffer.from('\r\n--' + boundary, 'latin1'), contentStart);
+                    const fileBuffer = body.slice(contentStart, nextBoundary);
+                    resolve({ buffer: fileBuffer, filename });
+                    return;
+                }
+                reject(new Error('No file found in upload'));
+            });
+        });
+    }
+    getDocumentList(agentId) {
+        const docsDir = this.getDocumentsDir(agentId);
+        const files = (0, fs_1.readdirSync)(docsDir).filter(f => f.endsWith('.json'));
+        const documents = files.map(f => {
+            try {
+                return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(docsDir, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean).sort((a, b) => new Date(b.processedAt).getTime() - new Date(a.processedAt).getTime());
+        return { documents };
+    }
+    deleteDocument(agentId, docId) {
+        const docsDir = this.getDocumentsDir(agentId);
+        const docPath = (0, path_1.join)(docsDir, `${docId}.json`);
+        if (!(0, fs_1.existsSync)(docPath)) {
+            return { error: 'Document not found' };
+        }
+        // Delete document metadata
+        (0, fs_1.unlinkSync)(docPath);
+        // Try to delete from DeepBrain
+        try {
+            // Remove memory entries with this docId
+            const memDir = (0, path_1.join)(this.getAgentsDir(), agentId + '-memory');
+            if ((0, fs_1.existsSync)(memDir)) {
+                const files = (0, fs_1.readdirSync)(memDir).filter(f => f.startsWith(docId));
+                for (const f of files) {
+                    (0, fs_1.unlinkSync)((0, path_1.join)(memDir, f));
+                }
+            }
+        }
+        catch { /* best effort */ }
+        return { success: true, deleted: docId };
+    }
     readBody(req) {
         return new Promise((resolve, reject) => {
             let body = '';