@agent-spaces/server 0.3.63 → 0.3.65

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/agent.js

@@ -3,7 +3,7 @@ import { copyFileSync, cpSync, existsSync, readFileSync, readdirSync, rmSync, st
 import { basename, extname, isAbsolute, join, normalize, relative } from 'node:path';
 import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
 import { listAgentSessions, getAgentSession, createAgentSession, updateAgentSession, deleteAgentSession, getAgentUsageDashboard, recordAgentUsage, } from '../storage/agent-store.js';
-import { getWorkspace } from '../storage/workspace-store.js';
+import { getWorkspace, listWorkspaces } from '../storage/workspace-store.js';
 import { listIssues, updateIssue } from '../storage/issue-store.js';
 import { listChannels, updateChannel } from './channel.js';
 import { ensureDir, getDataDir } from '../storage/json-store.js';
@@ -13,6 +13,7 @@ export const AGENT_GENERATOR_PRESET_ID = 'agent-generator';
 export const AGENT_COMMIT_PRESET_ID = 'commit-agent';
 const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain'];
 const VALID_TOOL_NAMES = new Set(BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
+const CLAUDE_BUILT_IN_DIRS = ['agents', 'commands'];
 const ANTHROPIC_BRIDGE_PROVIDERS = [
     'openai-responses-to-anthropic-messages',
     'openai-chat-completions-to-anthropic-messages',
@@ -338,6 +339,20 @@ export function getAgentConfigDir(workspaceId, preset) {
     ensureWorkspaceAgentCopy(preset, ws.agentspaceDir);
     return workspaceAgentDir;
 }
+export function syncTemplatesToAllWorkspaces() {
+    const templates = listTemplates().filter((template) => existsSync(getGlobalAgentTemplateDir(template.id)));
+    const workspaces = listWorkspaces();
+    let agents = 0;
+    for (const workspace of workspaces) {
+        if (!workspace.agentspaceDir)
+            continue;
+        for (const template of templates) {
+            writeWorkspaceAgentCopy(template, workspace.agentspaceDir);
+            agents++;
+        }
+    }
+    return { workspaces: workspaces.length, agents };
+}
 export function getAvailableSkillNames(agentDir, skills) {
     if (!agentDir || !Array.isArray(skills))
         return [];
@@ -541,10 +556,29 @@ function writeWorkspaceAgentCopy(preset, agentspaceDir) {
 function ensureWorkspaceAgentCopy(preset, agentspaceDir) {
     const workspaceAgentDir = getWorkspaceAgentDir(agentspaceDir, preset.id);
     const requiredFiles = ['agent.json', 'mcp.json'];
-    if (requiredFiles.every((file) => existsSync(join(workspaceAgentDir, file))))
+    const sourceDir = getGlobalAgentTemplateDir(preset.id);
+    const missingRequiredFile = requiredFiles.some((file) => !existsSync(join(workspaceAgentDir, file)));
+    const missingBuiltInDir = CLAUDE_BUILT_IN_DIRS.some((dir) => {
+        const sourceBuiltInDir = join(sourceDir, dir);
+        const targetBuiltInDir = join(workspaceAgentDir, dir);
+        return existsSync(sourceBuiltInDir)
+            && statSync(sourceBuiltInDir).isDirectory()
+            && countFiles(sourceBuiltInDir) > countFiles(targetBuiltInDir);
+    });
+    if (!missingRequiredFile && !missingBuiltInDir)
         return;
     writeWorkspaceAgentCopy(preset, agentspaceDir);
 }
+function countFiles(dir) {
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+        return 0;
+    return readdirSync(dir, { withFileTypes: true }).reduce((count, entry) => {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory())
+            return count + countFiles(fullPath);
+        return entry.isFile() ? count + 1 : count;
+    }, 0);
+}
 export function readAgentTemplate(agentId) {
     const filePath = join(getGlobalAgentTemplateDir(agentId), 'agent.json');
     if (!existsSync(filePath)) {

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