@praveencs/agent 0.9.8 → 0.9.10

package/dist/src/server/app.js

@@ -3,7 +3,7 @@ import cors from 'cors';
 import { createServer } from 'node:http';
 import { Server } from 'socket.io';
 import { InstanceRegistry } from '../instance/registry.js';
-import { resolve } from 'node:path';
+import { resolve, join } from 'node:path';
 import { MemoryStore } from '../memory/store.js';
 import { GoalStore } from '../goals/store.js';
 import { ConfigLoader } from '../config/loader.js';
@@ -12,6 +12,8 @@ import { SkillLoader } from '../skills/loader.js';
 import { CommandLoader } from '../commands/loader.js';
 import { ScriptLoader } from '../scripts/loader.js';
 import { HookRegistry } from '../hooks/registry.js';
+import { DaemonManager } from '../daemon/manager.js';
+import { writeFile, mkdir, readFile, readdir, rm, access } from 'node:fs/promises';
 export function createStudioServer() {
     const app = express();
     const server = createServer(app);
@@ -19,39 +21,44 @@ export function createStudioServer() {
     const registry = new InstanceRegistry();
     app.use(cors());
     app.use(express.json());
-    // --- INSTANCES API ---
+    // ═══════════════════════════════════════════════
+    // HELPER: resolve instance by ID
+    // ═══════════════════════════════════════════════
+    async function resolveInstance(id) {
+        const instances = await registry.listActive();
+        return instances.find(i => i.id === id) ?? null;
+    }
+    // ═══════════════════════════════════════════════
+    // INSTANCES API
+    // ═══════════════════════════════════════════════
     app.get('/api/instances', async (_req, res) => {
         try {
             const instances = await registry.listActive();
             res.json(instances);
-            return;
         }
         catch (err) {
             res.status(500).json({ error: err.message });
-            return;
         }
     });
     app.get('/api/instances/:id', async (req, res) => {
         try {
-            const instances = await registry.listActive();
-            const inst = instances.find(i => i.id === req.params.id);
+            const inst = await resolveInstance(req.params.id);
             if (!inst) {
                 res.status(404).json({ error: 'Instance not found' });
                 return;
             }
             res.json(inst);
-            return;
         }
         catch (err) {
             res.status(500).json({ error: err.message });
-            return;
         }
     });
-    // --- OBSERVABILITY API ---
+    // ═══════════════════════════════════════════════
+    // MEMORY API
+    // ═══════════════════════════════════════════════
     app.get('/api/instances/:id/memory', async (req, res) => {
         try {
-            const instances = await registry.listActive();
-            const inst = instances.find(i => i.id === req.params.id);
+            const inst = await resolveInstance(req.params.id);
             if (!inst) {
                 res.status(404).json({ error: 'Instance not found' });
                 return;
@@ -62,24 +69,78 @@ export function createStudioServer() {
                 stats: memoryStore.stats(),
                 memories
             });
-            return;
         }
         catch (err) {
             res.status(500).json({ error: err.message });
-            return;
         }
     });
+    app.get('/api/instances/:id/memory/search', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const q = req.query.q;
+            if (!q) {
+                res.status(400).json({ error: 'Query parameter "q" required' });
+                return;
+            }
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const results = memoryStore.search(q, 20);
+            res.json({ results });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/memory', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { content, category, tags } = req.body;
+            if (!content) {
+                res.status(400).json({ error: 'Content required' });
+                return;
+            }
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const memory = memoryStore.save(content, category || 'general', 'user', tags || []);
+            res.json(memory);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/instances/:id/memory/:memoryId', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const ok = memoryStore.forget(parseInt(req.params.memoryId));
+            res.json({ success: ok });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ═══════════════════════════════════════════════
+    // GOALS & TASKS API
+    // ═══════════════════════════════════════════════
     app.get('/api/instances/:id/goals', async (req, res) => {
         try {
-            const instances = await registry.listActive();
-            const inst = instances.find(i => i.id === req.params.id);
+            const inst = await resolveInstance(req.params.id);
             if (!inst) {
                 res.status(404).json({ error: 'Instance not found' });
                 return;
             }
             const memoryStore = MemoryStore.open(inst.cwd);
             const goalStore = new GoalStore(memoryStore);
-            // Get all tasks and cluster them by goal
             const db = memoryStore.db;
             const goals = db.prepare('SELECT * FROM goals ORDER BY created_at DESC').all();
             const tasks = db.prepare('SELECT * FROM tasks ORDER BY created_at ASC').all();
@@ -91,17 +152,110 @@ export function createStudioServer() {
                 stats: goalStore.stats(),
                 goals: goalsWithTasks
             });
-            return;
         }
         catch (err) {
             res.status(500).json({ error: err.message });
-            return;
         }
     });
+    app.post('/api/instances/:id/goals', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { title, description, priority, deadline } = req.body;
+            if (!title) {
+                res.status(400).json({ error: 'Title required' });
+                return;
+            }
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const goalStore = new GoalStore(memoryStore);
+            const goal = goalStore.addGoal(title, { description, priority, deadline });
+            res.json(goal);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.put('/api/instances/:id/goals/:goalId/status', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { status } = req.body;
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const goalStore = new GoalStore(memoryStore);
+            goalStore.updateGoalStatus(parseInt(req.params.goalId), status);
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/instances/:id/goals/:goalId', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const goalStore = new GoalStore(memoryStore);
+            const ok = goalStore.removeGoal(parseInt(req.params.goalId));
+            res.json({ success: ok });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/goals/:goalId/tasks', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { title, description, skill, dependsOn, requiresApproval } = req.body;
+            if (!title) {
+                res.status(400).json({ error: 'Title required' });
+                return;
+            }
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const goalStore = new GoalStore(memoryStore);
+            const task = goalStore.addTask(parseInt(req.params.goalId), title, {
+                description, skill, dependsOn, requiresApproval
+            });
+            res.json(task);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/tasks/:taskId/approve', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const memoryStore = MemoryStore.open(inst.cwd);
+            const goalStore = new GoalStore(memoryStore);
+            const ok = goalStore.approveTask(parseInt(req.params.taskId));
+            res.json({ success: ok });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ═══════════════════════════════════════════════
+    // CAPABILITIES API (read-only)
+    // ═══════════════════════════════════════════════
     app.get('/api/instances/:id/capabilities', async (req, res) => {
         try {
-            const instances = await registry.listActive();
-            const inst = instances.find(i => i.id === req.params.id);
+            const inst = await resolveInstance(req.params.id);
             if (!inst) {
                 res.status(404).json({ error: 'Instance not found' });
                 return;
@@ -113,7 +267,6 @@ export function createStudioServer() {
             const pluginLoader = new PluginLoader();
             const scriptLoader = new ScriptLoader();
             const hookRegistry = new HookRegistry();
-            // Load all capabilities from the agent's CWD
             await skillLoader.loadAll();
             await cmdLoader.loadProjectCommands(inst.cwd);
             await scriptLoader.loadAll(config.scripts?.installPaths ?? ['.agent/scripts'], inst.cwd);
@@ -125,35 +278,384 @@ export function createStudioServer() {
                 scripts: scriptLoader.list(),
                 plugins: loadedPlugins
             });
-            return;
         }
         catch (err) {
             res.status(500).json({ error: err.message });
-            return;
         }
     });
-    // --- SOCKET.IO FOR LIVE LOGS ---
+    // ═══════════════════════════════════════════════
+    // SKILLS CRUD API
+    // ═══════════════════════════════════════════════
+    app.get('/api/instances/:id/skills', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const configLoader = new ConfigLoader();
+            const config = await configLoader.load();
+            const skillLoader = new SkillLoader(config);
+            await skillLoader.loadAll();
+            const skills = skillLoader.list().map(s => ({
+                name: s.manifest.name,
+                description: s.manifest.description,
+                version: s.manifest.version,
+                entrypoint: s.manifest.entrypoint,
+                tools: s.manifest.tools,
+                path: s.path,
+                promptContent: s.promptContent ?? null,
+            }));
+            res.json({ skills });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/skills', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { name, description, prompt, tools } = req.body;
+            if (!name) {
+                res.status(400).json({ error: 'Name required' });
+                return;
+            }
+            const skillDir = join(inst.cwd, '.agent', 'skills', name);
+            await mkdir(skillDir, { recursive: true });
+            const manifest = {
+                name,
+                description: description || `Skill: ${name}`,
+                version: '1.0.0',
+                entrypoint: 'prompt.md',
+                tools: tools || [],
+            };
+            await writeFile(join(skillDir, 'skill.json'), JSON.stringify(manifest, null, 2));
+            await writeFile(join(skillDir, 'prompt.md'), prompt || `# ${name}\n\nDescribe the skill behavior here.`);
+            res.json({ success: true, path: skillDir, manifest });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.put('/api/instances/:id/skills/:name', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { prompt, description, tools } = req.body;
+            const skillDir = join(inst.cwd, '.agent', 'skills', req.params.name);
+            try {
+                await access(skillDir);
+            }
+            catch {
+                res.status(404).json({ error: 'Skill not found' });
+                return;
+            }
+            if (prompt !== undefined) {
+                await writeFile(join(skillDir, 'prompt.md'), prompt);
+            }
+            if (description !== undefined || tools !== undefined) {
+                const manifestRaw = await readFile(join(skillDir, 'skill.json'), 'utf-8');
+                const manifest = JSON.parse(manifestRaw);
+                if (description !== undefined)
+                    manifest.description = description;
+                if (tools !== undefined)
+                    manifest.tools = tools;
+                await writeFile(join(skillDir, 'skill.json'), JSON.stringify(manifest, null, 2));
+            }
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/instances/:id/skills/:name', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const skillDir = join(inst.cwd, '.agent', 'skills', req.params.name);
+            await rm(skillDir, { recursive: true, force: true });
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ═══════════════════════════════════════════════
+    // COMMANDS CRUD API
+    // ═══════════════════════════════════════════════
+    app.get('/api/instances/:id/commands', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const cmdLoader = new CommandLoader();
+            await cmdLoader.loadProjectCommands(inst.cwd);
+            res.json({ commands: cmdLoader.list() });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/commands', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { name, description, tools, body } = req.body;
+            if (!name) {
+                res.status(400).json({ error: 'Name required' });
+                return;
+            }
+            const commandsDir = join(inst.cwd, '.agent', 'commands');
+            await mkdir(commandsDir, { recursive: true });
+            const frontmatter = [
+                '---',
+                `name: ${name}`,
+                `description: ${description || `Command: ${name}`}`,
+                `tools: [${(tools || []).join(', ')}]`,
+                '---',
+            ].join('\n');
+            const content = `${frontmatter}\n${body || `# ${name}\n\nDescribe what this command does.`}`;
+            const filePath = join(commandsDir, `${name}.md`);
+            await writeFile(filePath, content);
+            res.json({ success: true, path: filePath });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/instances/:id/commands/:name', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const filePath = join(inst.cwd, '.agent', 'commands', `${req.params.name}.md`);
+            await rm(filePath, { force: true });
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ═══════════════════════════════════════════════
+    // SCRIPTS CRUD API
+    // ═══════════════════════════════════════════════
+    app.get('/api/instances/:id/scripts', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const configLoader = new ConfigLoader();
+            const config = await configLoader.load();
+            const scriptLoader = new ScriptLoader();
+            await scriptLoader.loadAll(config.scripts?.installPaths ?? ['.agent/scripts'], inst.cwd);
+            res.json({ scripts: scriptLoader.list() });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/scripts', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const { name, description, entrypoint, content, args } = req.body;
+            if (!name) {
+                res.status(400).json({ error: 'Name required' });
+                return;
+            }
+            const scriptDir = join(inst.cwd, '.agent', 'scripts', name);
+            await mkdir(scriptDir, { recursive: true });
+            // Write script.yaml
+            const yamlLines = [
+                `name: ${name}`,
+                `description: ${description || `Script: ${name}`}`,
+                `entrypoint: ${entrypoint || 'run.sh'}`,
+            ];
+            if (args && Object.keys(args).length > 0) {
+                yamlLines.push('args:');
+                for (const [key, val] of Object.entries(args)) {
+                    yamlLines.push(`  ${key}:`);
+                    yamlLines.push(`    description: ${val.description || key}`);
+                    if (val.default)
+                        yamlLines.push(`    default: ${val.default}`);
+                }
+            }
+            await writeFile(join(scriptDir, 'script.yaml'), yamlLines.join('\n'));
+            // Write entrypoint file
+            const ep = entrypoint || 'run.sh';
+            await writeFile(join(scriptDir, ep), content || `#!/bin/bash\necho "Running ${name}..."\n`);
+            res.json({ success: true, path: scriptDir });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/instances/:id/scripts/:name', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const scriptDir = join(inst.cwd, '.agent', 'scripts', req.params.name);
+            await rm(scriptDir, { recursive: true, force: true });
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ═══════════════════════════════════════════════
+    // PLUGINS API
+    // ═══════════════════════════════════════════════
+    app.get('/api/instances/:id/plugins', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const pluginsDir = join(inst.cwd, '.agent', 'plugins');
+            const plugins = [];
+            try {
+                await access(pluginsDir);
+                const entries = await readdir(pluginsDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    try {
+                        const manifestRaw = await readFile(join(pluginsDir, entry.name, 'plugin.json'), 'utf-8');
+                        plugins.push(JSON.parse(manifestRaw));
+                    }
+                    catch { /* skip invalid */ }
+                }
+            }
+            catch { /* no plugin dir */ }
+            res.json({ plugins });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/instances/:id/plugins/:name', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const pluginDir = join(inst.cwd, '.agent', 'plugins', req.params.name);
+            await rm(pluginDir, { recursive: true, force: true });
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ═══════════════════════════════════════════════
+    // DAEMON CONTROL API
+    // ═══════════════════════════════════════════════
+    app.get('/api/instances/:id/daemon/status', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const daemon = new DaemonManager();
+            const status = await daemon.status();
+            res.json(status);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/daemon/start', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const daemon = new DaemonManager();
+            const result = await daemon.start();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/instances/:id/daemon/stop', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const daemon = new DaemonManager();
+            const result = await daemon.stop();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/instances/:id/daemon/logs', async (req, res) => {
+        try {
+            const inst = await resolveInstance(req.params.id);
+            if (!inst) {
+                res.status(404).json({ error: 'Instance not found' });
+                return;
+            }
+            const daemon = new DaemonManager();
+            const lines = parseInt(req.query.lines) || 50;
+            const logs = await daemon.getLogs(lines);
+            res.json({ logs });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ═══════════════════════════════════════════════
+    // SOCKET.IO FOR LIVE LOGS & APPROVAL RELAY
+    // ═══════════════════════════════════════════════
     io.on('connection', (socket) => {
         console.log(`[Studio] Client connected: ${socket.id}`);
         socket.on('subscribe', (instanceId) => {
             console.log(`[Studio] Client subscribed to ${instanceId}`);
             socket.join(instanceId);
         });
-        // Relays commands from the UI downwards to the actual Agent CLI in the terminal
         socket.on('agent:command', (data) => {
-            console.log(`[Studio] Relaying command to instance ${data.instanceId}`);
             socket.to(data.instanceId).emit('agent:command', data);
         });
-        // Relays live logs from the Agent CLI upwards to all active UI Dashboards
         socket.on('agent:log', (data) => {
-            // we broadcast to the room EXCEPT the sender
             socket.to(data.instanceId).emit('agent:log', data);
         });
-        // Relay approval requests from Agent -> UI
         socket.on('agent:approval:request', (data) => {
             socket.to(data.instanceId).emit('agent:approval:request', data);
         });
-        // Relay approval responses from UI -> Agent
         socket.on('agent:approval:response', (data) => {
             socket.to(data.instanceId).emit(`agent:approval:response:${data.tool}`, data);
         });
@@ -161,7 +663,9 @@ export function createStudioServer() {
             console.log(`[Studio] Client disconnected: ${socket.id}`);
         });
     });
-    // --- SERVE FRONTEND ---
+    // ═══════════════════════════════════════════════
+    // SERVE FRONTEND
+    // ═══════════════════════════════════════════════
     const reactAppPath = resolve(process.cwd(), 'studio/dist');
     app.use(express.static(reactAppPath));
     app.use((_req, res) => { res.sendFile(resolve(reactAppPath, 'index.html')); });