@agent-spaces/server 0.3.62 → 0.3.64

package/dist/routes/prompt-template.js

@@ -5,12 +5,12 @@ router.get('/', (_req, res) => {
     res.json(listPromptTemplates());
 });
 router.post('/', (req, res) => {
-    const { name, content } = req.body;
+    const { name, content, storeId } = req.body;
     if (!name || !content) {
         res.status(400).json({ error: 'name and content required' });
         return;
     }
-    res.json(createPromptTemplate(name, content));
+    res.json(createPromptTemplate(name, content, storeId));
 });
 router.put('/:id', (req, res) => {
     const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];

package/dist/routes/skill.js

@@ -1,5 +1,9 @@
 import { Router } from 'express';
-import { listSkills, importSkill, importSkillsBatch, toggleFavorite, toggleEnabled, toggleAllEnabled, updateSkillContent, deleteSkill, checkSkillSync, syncSkills } from '../services/skill.js';
+import { exec } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { listSkills, importSkill, importSkillsBatch, importSkillFromStore, toggleFavorite, updateSkillContent, deleteSkill, checkSkillSync, syncSkills, importSkillsFromGit, listSkillFiles, readSkillFile, writeSkillFile } from '../services/skill.js';
+import { getDataDir } from '../storage/json-store.js';
 const router = Router();
 router.get('/', (_req, res) => {
     res.json(listSkills());
@@ -34,25 +38,38 @@ router.post('/import-batch', (req, res) => {
     const skills = importSkillsBatch(items);
     res.json(skills);
 });
+router.post('/import-store', (req, res) => {
+    const { path, group } = req.body;
+    if (!path) {
+        res.status(400).json({ error: 'path required' });
+        return;
+    }
+    const skill = importSkillFromStore(path, group || '');
+    if (!skill) {
+        res.status(404).json({ error: 'Store skill not found' });
+        return;
+    }
+    res.json(skill);
+});
+router.post('/import-git', (req, res) => {
+    const { url } = req.body;
+    if (!url) {
+        res.status(400).json({ error: 'url required' });
+        return;
+    }
+    try {
+        const skills = importSkillsFromGit(url);
+        res.json(skills);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message || 'Git clone failed' });
+    }
+});
 router.post('/:name/favorite', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const favorited = toggleFavorite(name);
     res.json({ favorited });
 });
-router.post('/:name/toggle', (req, res) => {
-    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
-    const enabled = toggleEnabled(name);
-    res.json({ enabled });
-});
-router.post('/toggle-all', (req, res) => {
-    const { names, enabled } = req.body;
-    if (!Array.isArray(names) || typeof enabled !== 'boolean') {
-        res.status(400).json({ error: 'names and enabled required' });
-        return;
-    }
-    toggleAllEnabled(names, enabled);
-    res.json({ success: true });
-});
 router.put('/:name', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const { content } = req.body;
@@ -67,6 +84,60 @@ router.put('/:name', (req, res) => {
     }
     res.json({ success: true });
 });
+router.get('/:name/files', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const files = listSkillFiles(name);
+    res.json(files);
+});
+router.get('/:name/files/{*filePath}', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const filePath = Array.isArray(req.params.filePath) ? req.params.filePath.join('/') : req.params.filePath;
+    if (!filePath) {
+        res.status(400).json({ error: 'file path required' });
+        return;
+    }
+    const content = readSkillFile(name, filePath);
+    if (content === null) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+    }
+    res.json({ content });
+});
+router.put('/:name/files/{*filePath}', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const filePath = Array.isArray(req.params.filePath) ? req.params.filePath.join('/') : req.params.filePath;
+    const { content } = req.body;
+    if (!filePath || content === undefined) {
+        res.status(400).json({ error: 'file path and content required' });
+        return;
+    }
+    const ok = writeSkillFile(name, filePath, content);
+    if (!ok) {
+        res.status(400).json({ error: 'Failed to write file' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.post('/:name/reveal', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const skillDir = join(getDataDir(), 'skills', name);
+    if (!existsSync(skillDir)) {
+        res.status(404).json({ error: 'Skill folder not found' });
+        return;
+    }
+    const cmd = process.platform === 'darwin'
+        ? `open "${skillDir}"`
+        : process.platform === 'win32'
+            ? `explorer "${skillDir}"`
+            : `xdg-open "${skillDir}"`;
+    exec(cmd, (err) => {
+        if (err) {
+            res.status(500).json({ error: 'Failed to reveal', detail: err.message });
+            return;
+        }
+        res.json({ ok: true, path: skillDir });
+    });
+});
 router.delete('/:name', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const ok = deleteSkill(name);

package/dist/routes/task.js

@@ -11,15 +11,23 @@ router.post('/', (req, res) => {
         res.status(400).json({ error: 'issueId and title are required' });
         return;
     }
+    if (typeof agentConfigId !== 'string' || !agentConfigId.trim()) {
+        res.status(400).json({ error: 'agentConfigId is required' });
+        return;
+    }
     const issue = issueService.getById(req.params.id, issueId);
     if (!issue) {
         res.status(404).json({ error: 'issue not found' });
         return;
     }
+    if (!issue.members.includes(agentConfigId)) {
+        res.status(400).json({ error: 'agentConfigId must be an issue member' });
+        return;
+    }
     const task = taskService.create(req.params.id, issueId, {
         title,
         description: description || '',
-        agentConfigId,
+        agentConfigId: agentConfigId.trim(),
         dependsOnTaskIds,
         sandboxDirs,
     });
@@ -60,6 +68,10 @@ router.put('/:taskId', (req, res) => {
         res.status(400).json({ error: 'title, description, agentConfigId, dependsOnTaskIds, or sandboxDirs is required' });
         return;
     }
+    if (agentConfigId !== undefined && (typeof agentConfigId !== 'string' || !agentConfigId.trim())) {
+        res.status(400).json({ error: 'agentConfigId cannot be empty' });
+        return;
+    }
     const task = taskService.update(req.params.id, req.params.taskId, { title, description, agentConfigId, dependsOnTaskIds, sandboxDirs });
     if (!task) {
         res.status(404).json({ error: 'task not found or not editable (must be pending)' });

package/dist/services/agent-commands.js

@@ -0,0 +1,168 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir, ensureDir } from '../storage/json-store.js';
+function getAgentTemplatesDir() {
+    return join(getDataDir(), 'agent-templates');
+}
+function getCommandsDir(agentId) {
+    return join(getAgentTemplatesDir(), agentId, 'commands');
+}
+function getAgentName(agentId) {
+    const agentPath = join(getAgentTemplatesDir(), agentId, 'agent.json');
+    if (!existsSync(agentPath))
+        return undefined;
+    try {
+        const config = JSON.parse(readFileSync(agentPath, 'utf-8'));
+        return config.name || agentId;
+    }
+    catch {
+        return agentId;
+    }
+}
+function readCommandsFromDir(dir, agentId, group = '') {
+    if (!existsSync(dir))
+        return [];
+    const agentName = getAgentName(agentId);
+    return readdirSync(dir, { withFileTypes: true })
+        .flatMap((entry) => {
+        if (entry.isDirectory()) {
+            return readCommandsFromDir(join(dir, entry.name), agentId, entry.name);
+        }
+        if (!entry.name.endsWith('.md'))
+            return [];
+        return {
+            name: entry.name.replace(/\.md$/, ''),
+            content: readFileSync(join(dir, entry.name), 'utf-8'),
+            group,
+            agentId,
+            agentName,
+        };
+    });
+}
+export function listAgentsWithCommands() {
+    const templatesDir = getAgentTemplatesDir();
+    if (!existsSync(templatesDir))
+        return [];
+    return readdirSync(templatesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => {
+        const commandsDir = getCommandsDir(entry.name);
+        const commands = readCommandsFromDir(commandsDir, entry.name);
+        return {
+            agentId: entry.name,
+            agentName: getAgentName(entry.name) || entry.name,
+            commandCount: commands.length,
+        };
+    });
+}
+export function listAllCommands() {
+    const templatesDir = getAgentTemplatesDir();
+    if (!existsSync(templatesDir))
+        return [];
+    return readdirSync(templatesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .flatMap((entry) => {
+        const commandsDir = getCommandsDir(entry.name);
+        return readCommandsFromDir(commandsDir, entry.name);
+    });
+}
+export function listCommands(agentId) {
+    return readCommandsFromDir(getCommandsDir(agentId), agentId);
+}
+function resolveCommandPath(agentId, name, group) {
+    if (group) {
+        return join(getCommandsDir(agentId), group, `${name}.md`);
+    }
+    return join(getCommandsDir(agentId), `${name}.md`);
+}
+function findCommandPath(agentId, name, group) {
+    if (group) {
+        const p = join(getCommandsDir(agentId), group, `${name}.md`);
+        return existsSync(p) ? p : null;
+    }
+    // Search root first, then subdirectories
+    const root = join(getCommandsDir(agentId), `${name}.md`);
+    if (existsSync(root))
+        return root;
+    if (existsSync(getCommandsDir(agentId))) {
+        for (const entry of readdirSync(getCommandsDir(agentId), { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const p = join(getCommandsDir(agentId), entry.name, `${name}.md`);
+                if (existsSync(p))
+                    return p;
+            }
+        }
+    }
+    return null;
+}
+export function getCommand(agentId, name, group) {
+    const filePath = findCommandPath(agentId, name, group);
+    if (!filePath)
+        return null;
+    // Infer group from path
+    const commandsDir = getCommandsDir(agentId);
+    const relative = filePath.slice(commandsDir.length + 1);
+    const parts = relative.split('/');
+    const inferredGroup = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
+    return {
+        name,
+        content: readFileSync(filePath, 'utf-8'),
+        group: inferredGroup,
+        agentId,
+        agentName: getAgentName(agentId),
+    };
+}
+export function createCommand(agentId, name, content, group) {
+    const dir = group ? join(getCommandsDir(agentId), group) : getCommandsDir(agentId);
+    ensureDir(dir);
+    const filePath = join(dir, `${name}.md`);
+    writeFileSync(filePath, content, 'utf-8');
+    return {
+        name,
+        content,
+        group: group || '',
+        agentId,
+        agentName: getAgentName(agentId),
+    };
+}
+export function updateCommand(agentId, name, content, group) {
+    const filePath = findCommandPath(agentId, name, group);
+    if (!filePath)
+        return null;
+    writeFileSync(filePath, content, 'utf-8');
+    const commandsDir = getCommandsDir(agentId);
+    const relative = filePath.slice(commandsDir.length + 1);
+    const parts = relative.split('/');
+    const inferredGroup = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
+    return {
+        name,
+        content,
+        group: inferredGroup,
+        agentId,
+        agentName: getAgentName(agentId),
+    };
+}
+export function deleteCommand(agentId, name, group) {
+    const filePath = findCommandPath(agentId, name, group);
+    if (!filePath)
+        return false;
+    unlinkSync(filePath);
+    return true;
+}
+export function applyCommandToAgents(sourceAgentId, name, group, targetAgentIds) {
+    const src = getCommand(sourceAgentId, name, group);
+    if (!src)
+        return 0;
+    let applied = 0;
+    for (const targetId of targetAgentIds) {
+        if (targetId === sourceAgentId)
+            continue;
+        try {
+            createCommand(targetId, src.name, src.content);
+            applied++;
+        }
+        catch { /* skip */ }
+    }
+    return applied;
+}
+//# sourceMappingURL=agent-commands.js.map

package/dist/services/builtin-tools/command-tools.js

@@ -0,0 +1,117 @@
+import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
+import * as commandService from '../command.js';
+import * as commandProcessManager from '../command-process-manager.js';
+const readTerminalOutputInputSchema = {
+    type: 'object',
+    properties: {
+        workspaceId: {
+            type: 'string',
+            description: 'Optional workspace ID. If omitted, the current workspace is used.',
+        },
+        sessionId: {
+            type: 'string',
+            description: 'Terminal session ID to read.',
+        },
+        offset: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Number of newest lines to skip before reading. Defaults to 0.',
+        },
+        limit: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 1000,
+            description: 'Maximum number of lines to read. Defaults to 100.',
+        },
+    },
+    required: ['sessionId'],
+    additionalProperties: false,
+};
+export function createCommandFunctionTools(workspaceId, allowedTools) {
+    const allowedToolNames = new Set(allowedTools ?? BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
+    const tools = [
+        {
+            name: 'ReadTerminalOutput',
+            description: 'Read paginated terminal output by terminal session ID. Defaults to the newest 100 lines.',
+            inputSchema: readTerminalOutputInputSchema,
+            annotations: { readOnly: true, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId && data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                return commandProcessManager.readTerminalOutput(workspaceId, data.sessionId, {
+                    offset: data.offset,
+                    limit: data.limit,
+                });
+            },
+        },
+        {
+            name: 'ListQuickCommands',
+            description: 'List all quick commands for the workspace with running status.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    workspaceId: { type: 'string', description: 'The workspace ID' },
+                },
+                required: ['workspaceId'],
+                additionalProperties: false,
+            },
+            annotations: { readOnly: true, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                const commands = commandService.listCommands(workspaceId);
+                const processes = commandProcessManager.getCommandProcesses(workspaceId);
+                const processMap = new Map(processes.map(p => [p.commandId, p]));
+                return commands.map(cmd => ({
+                    ...cmd,
+                    running: processMap.has(cmd.id) ? processMap.get(cmd.id).status : false,
+                }));
+            },
+        },
+        {
+            name: 'RunQuickCommand',
+            description: 'Run a quick command by ID. Returns sessionId.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    workspaceId: { type: 'string' },
+                    commandId: { type: 'string' },
+                },
+                required: ['workspaceId', 'commandId'],
+                additionalProperties: false,
+            },
+            annotations: { destructive: false, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                return { sessionId: commandProcessManager.runCommand(workspaceId, data.commandId) };
+            },
+        },
+        {
+            name: 'StopQuickCommand',
+            description: 'Stop a running quick command by ID.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    workspaceId: { type: 'string' },
+                    commandId: { type: 'string' },
+                },
+                required: ['workspaceId', 'commandId'],
+                additionalProperties: false,
+            },
+            annotations: { destructive: false, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                commandProcessManager.stopCommand(workspaceId, data.commandId);
+                return { stopped: true };
+            },
+        },
+    ];
+    return tools.filter((tool) => allowedToolNames.has(tool.name));
+}
+//# sourceMappingURL=command-tools.js.map