@agent-spaces/server 0.3.63 → 0.3.65

package/dist/agents/commit-agent.js

@@ -27,13 +27,14 @@ export async function runCommitAgent(workspaceId) {
     const workingDir = agentService.resolveWorkingDir(workspaceId, commitAgent);
     const systemPrompt = commitAgent.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
     const truncatedDiff = diff.length > 8000 ? diff.substring(0, 8000) + '\n... (truncated)' : diff;
-    const result = await runtime.execute(prependPersistentAgentContext([
+    const userPrompt = [
         'Generate exactly one commit message for these changes.',
         'Do not inspect files or run commands. Use only this diff.',
         'Output only the commit message.',
         '',
         truncatedDiff,
-    ].join('\n'), {
+    ].join('\n');
+    const result = await runtime.execute(prependPersistentAgentContext(userPrompt, {
         workspaceId,
         workingDir,
         boundDirs: ws.boundDirs,
@@ -41,6 +42,7 @@ export async function runCommitAgent(workspaceId) {
         excludeNativeClaudeMd: commitAgent.runtimeKind === 'claude-code',
     }), workingDir, {
         maxTurns: 1,
+        userPrompt,
         systemPrompt,
         outputStyle: commitAgent.outputStyle,
     });

package/dist/agents/issue-task-controller.js

@@ -5,7 +5,7 @@ import * as issueService from '../services/issue.js';
 import * as taskService from '../services/task.js';
 import * as workspaceService from '../services/workspace.js';
 import { mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
-import { createIssueFunctionTools } from '../services/builtin-tools.js';
+import { createIssueFunctionTools } from '../services/builtin-tools/index.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
@@ -49,8 +49,10 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
         },
     });
     const runtime = createRuntimeForPreset(taskSyncPreset);
-    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskSyncPrompt(issue, input, taskSyncWorkingDir), taskSyncWorkingDir, taskSyncPreset), taskSyncWorkingDir, {
+    const taskSyncUserPrompt = buildTaskSyncPrompt(issue, input, taskSyncWorkingDir);
+    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, taskSyncUserPrompt, taskSyncWorkingDir, taskSyncPreset), taskSyncWorkingDir, {
         maxTurns: 20,
+        userPrompt: taskSyncUserPrompt,
         mcpServers: undefined,
         functionTools: createTaskSyncTools(workspaceId, issue, taskSyncPreset, ctx),
         skills: [],
@@ -199,8 +201,10 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     });
     let result;
     try {
-        result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
+        const taskUserPrompt = buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir);
+        result = await runtime.execute(buildIssueAgentPrompt(workspaceId, taskUserPrompt, agentWorkingDir, taskAgentPreset), agentWorkingDir, {
             maxTurns: 100,
+            userPrompt: taskUserPrompt,
             mcpServers: agentService.getMcpServers(taskAgentPreset.mcps),
             functionTools: createCurrentIssueTools(workspaceId, issue, taskAgentPreset),
             skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, taskAgentPreset), taskAgentPreset.skills),

package/dist/app.js

@@ -5,9 +5,9 @@ import express from 'express';
 import cors from 'cors';
 import { createServer } from 'node:http';
 import { WebSocketServer } from 'ws';
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import { join, dirname, basename } from 'node:path';
+import { join, dirname, extname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import workspaceRouter from './routes/workspace.js';
 import fileRouter from './routes/file.js';
@@ -31,7 +31,11 @@ import subscriptionRouter from './routes/subscription.js';
 import agentSseRouter from './routes/agent-sse.js';
 import searchRouter from './routes/search.js';
 import notificationRouter from './routes/notification.js';
+import databaseRouter from './routes/database.js';
+import kanbanRouter from './routes/kanban.js';
 import speechRecognitionRouter, { handleSpeechStream } from './routes/speech-recognition.js';
+import agentCommandsRouter from './routes/agent-commands.js';
+import robotAccountRouter from './routes/robot-account.js';
 import { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
@@ -67,73 +71,9 @@ app.use('/api', authMiddleware);
 // Serve static files from public/
 const publicDir = resolveRuntimeDir('public');
 app.use('/public', express.static(publicDir));
-// Scan public/prompt/ and generate index.json for the prompt store
-function scanPromptStore() {
-    const promptDir = join(publicDir, 'prompt');
-    if (!existsSync(promptDir))
-        return;
-    const files = readdirSync(promptDir).filter((f) => f.endsWith('.md'));
-    const index = files.map((filename) => {
-        const id = basename(filename, '.md');
-        const content = readFileSync(join(promptDir, filename), 'utf-8');
-        const firstHeading = content.split('\n').find((l) => /^#\s+/.test(l));
-        const name = firstHeading ? firstHeading.replace(/^#\s+/, '').trim() : id.replace(/[-_]/g, ' ');
-        return { id, name, filename };
-    });
-    writeFileSync(join(promptDir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
-    console.log(`[prompt-store] scanned ${index.length} templates`);
-}
-scanPromptStore();
-// Scan public/output-styles/ and generate index.json
-function scanOutputStyleStore() {
-    const dir = join(publicDir, 'output-styles');
-    if (!existsSync(dir))
-        return;
-    const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
-    const index = files.map((filename) => {
-        const id = basename(filename, '.md');
-        const content = readFileSync(join(dir, filename), 'utf-8');
-        const firstHeading = content.split('\n').find((l) => /^#\s+/.test(l));
-        const name = firstHeading ? firstHeading.replace(/^#\s+/, '').trim() : id.replace(/[-_]/g, ' ');
-        return { id, name, filename };
-    });
-    writeFileSync(join(dir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
-    console.log(`[output-style-store] scanned ${index.length} templates`);
-}
-scanOutputStyleStore();
-// Scan public/skills/{group}/{skill-name}/SKILL.md and generate index.json
-function scanSkillStore() {
-    const dir = join(publicDir, 'skills');
-    if (!existsSync(dir))
-        return;
-    const index = [];
-    for (const groupEntry of readdirSync(dir, { withFileTypes: true })) {
-        if (!groupEntry.isDirectory())
-            continue;
-        const group = groupEntry.name;
-        const groupDir = join(dir, group);
-        for (const skillEntry of readdirSync(groupDir, { withFileTypes: true })) {
-            if (!skillEntry.isDirectory())
-                continue;
-            const skillName = skillEntry.name;
-            const skillFile = join(groupDir, skillName, 'SKILL.md');
-            if (!existsSync(skillFile))
-                continue;
-            const content = readFileSync(skillFile, 'utf-8');
-            const fm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-            let name = skillName;
-            if (fm) {
-                const nameLine = fm[1].split(/\r?\n/).find((l) => /^\s*name\s*:/i.test(l));
-                if (nameLine)
-                    name = nameLine.split(':', 2)[1].trim() || skillName;
-            }
-            index.push({ id: skillName, name, group, path: `${group}/${skillName}` });
-        }
-    }
-    writeFileSync(join(dir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
-    console.log(`[skill-store] scanned ${index.length} skills`);
-}
-scanSkillStore();
+// Serve agents store from packages/agents/
+const agentsDir = resolveRuntimeDir('../agents');
+app.use('/agents-store', express.static(agentsDir));
 app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', timestamp: new Date().toISOString(), platform: process.platform });
 });
@@ -158,6 +98,49 @@ app.post('/api/upload/avatar', async (req, res) => {
     await writeFile(join(avatarsDir, name), Buffer.from(base64, 'base64'));
     res.json({ url: `/static/avatars/${name}` });
 });
+// Font upload
+const FONT_EXTS = new Set(['.ttf', '.otf', '.woff', '.woff2']);
+const fontsDir = join(publicDir, 'fonts');
+if (!existsSync(fontsDir))
+    mkdirSync(fontsDir, { recursive: true });
+app.get('/api/fonts', (_req, res) => {
+    if (!existsSync(fontsDir)) {
+        res.json([]);
+        return;
+    }
+    const fonts = readdirSync(fontsDir).filter(f => FONT_EXTS.has(extname(f).toLowerCase()));
+    res.json(fonts.map(f => ({ name: f, url: `/static/fonts/${f}` })));
+});
+app.post('/api/fonts/upload', async (req, res) => {
+    const { name, content } = req.body;
+    if (!name || !content) {
+        res.status(400).json({ error: 'name and content are required' });
+        return;
+    }
+    const ext = extname(name).toLowerCase();
+    if (!FONT_EXTS.has(ext)) {
+        res.status(400).json({ error: 'Unsupported font format' });
+        return;
+    }
+    const safeName = basename(name).replace(/[^a-zA-Z0-9._-]/g, '_');
+    await writeFile(join(fontsDir, safeName), Buffer.from(content, 'base64'));
+    res.json({ name: safeName, url: `/static/fonts/${safeName}` });
+});
+app.delete('/api/fonts/:name', (req, res) => {
+    const name = basename(req.params.name);
+    const ext = extname(name).toLowerCase();
+    if (!FONT_EXTS.has(ext)) {
+        res.status(400).json({ error: 'Invalid font file' });
+        return;
+    }
+    const filePath = join(fontsDir, name);
+    if (!existsSync(filePath)) {
+        res.status(404).json({ error: 'Font not found' });
+        return;
+    }
+    import('node:fs').then(fs => fs.unlinkSync(filePath));
+    res.json({ ok: true });
+});
 // User settings
 app.get('/api/user/settings', (_req, res) => {
     const settings = getUserSettings();
@@ -206,6 +189,8 @@ app.post('/api/git-config', async (req, res) => {
     }
 });
 app.use('/api/workspaces/:id/search', searchRouter);
+app.use('/api/workspaces/:id/database', databaseRouter);
+app.use('/api/workspaces/:id/kanban', kanbanRouter);
 app.use('/api/workspaces/:id/notifications', notificationRouter);
 app.use('/api/agents', agentRouter);
 app.use('/api', llmRouter);
@@ -216,6 +201,8 @@ app.use('/api/output-styles', outputStyleRouter);
 app.use('/api/mcps', mcpRouter);
 app.use('/api/subscriptions', subscriptionRouter);
 app.use('/api/speech-recognition', speechRecognitionRouter);
+app.use('/api/agent-commands', agentCommandsRouter);
+app.use('/api/robot-accounts', robotAccountRouter);
 // Serve static web frontend in production (after API routes, before catch-all)
 const webDir = resolveRuntimeDir('web');
 if (existsSync(webDir)) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.3.63",
+  "version": "0.3.64",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",

package/dist/routes/agent-commands.js

@@ -0,0 +1,72 @@
+import { Router } from 'express';
+import { listAgentsWithCommands, listAllCommands, listCommands, getCommand, createCommand, updateCommand, deleteCommand, applyCommandToAgents, } from '../services/agent-commands.js';
+const router = Router();
+router.get('/agents', (_req, res) => {
+    res.json(listAgentsWithCommands());
+});
+router.get('/all', (_req, res) => {
+    res.json(listAllCommands());
+});
+router.get('/:agentId', (req, res) => {
+    const agentId = typeof req.params.agentId === 'string' ? req.params.agentId : req.params.agentId[0];
+    res.json(listCommands(agentId));
+});
+router.get('/:agentId/:name', (req, res) => {
+    const agentId = typeof req.params.agentId === 'string' ? req.params.agentId : req.params.agentId[0];
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const group = req.query.group;
+    const cmd = getCommand(agentId, name, group);
+    if (!cmd) {
+        res.status(404).json({ error: 'Command not found' });
+        return;
+    }
+    res.json(cmd);
+});
+router.post('/:agentId', (req, res) => {
+    const agentId = typeof req.params.agentId === 'string' ? req.params.agentId : req.params.agentId[0];
+    const { name, content, group } = req.body;
+    if (!name || !content) {
+        res.status(400).json({ error: 'name and content required' });
+        return;
+    }
+    res.json(createCommand(agentId, name, content, group));
+});
+router.put('/:agentId/:name', (req, res) => {
+    const agentId = typeof req.params.agentId === 'string' ? req.params.agentId : req.params.agentId[0];
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const { content, group } = req.body;
+    if (!content) {
+        res.status(400).json({ error: 'content required' });
+        return;
+    }
+    const cmd = updateCommand(agentId, name, content, group);
+    if (!cmd) {
+        res.status(404).json({ error: 'Command not found' });
+        return;
+    }
+    res.json(cmd);
+});
+router.delete('/:agentId/:name', (req, res) => {
+    const agentId = typeof req.params.agentId === 'string' ? req.params.agentId : req.params.agentId[0];
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const group = req.query.group;
+    const ok = deleteCommand(agentId, name, group);
+    if (!ok) {
+        res.status(404).json({ error: 'Command not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.post('/:agentId/:name/apply', (req, res) => {
+    const agentId = typeof req.params.agentId === 'string' ? req.params.agentId : req.params.agentId[0];
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const { group, agentIds } = req.body;
+    if (!Array.isArray(agentIds) || agentIds.length === 0) {
+        res.status(400).json({ error: 'agentIds required' });
+        return;
+    }
+    const applied = applyCommandToAgents(agentId, name, group || '', agentIds);
+    res.json({ applied });
+});
+export default router;
+//# sourceMappingURL=agent-commands.js.map

package/dist/routes/agent-sse.js

@@ -79,6 +79,7 @@ router.post('/run', async (req, res) => {
             skills,
             configDir,
             sandboxDirs: preset.sandboxDirs,
+            userPrompt,
             outputStyle: body.outputStyle ?? preset.outputStyle,
             onEvent: wrapOnEventWithHooks((event) => {
                 if (event.type === 'output')
@@ -143,11 +144,17 @@ function prepareSse(res) {
     res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
     res.setHeader('Cache-Control', 'no-cache, no-transform');
     res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
     res.flushHeaders?.();
+    res.socket?.setNoDelay?.(true);
 }
 function writeSse(res, event, data) {
     res.write(`event: ${event}\n`);
     res.write(`data: ${JSON.stringify(data)}\n\n`);
+    // Force flush — compression middleware and some proxies buffer small writes
+    const flushable = res;
+    if (typeof flushable.flush === 'function')
+        flushable.flush();
 }
 function resolveUserPrompt(body) {
     const direct = body.prompt ?? body.message;

package/dist/routes/agent.js

@@ -1,6 +1,6 @@
 import { Router } from 'express';
 import * as agentService from '../services/agent.js';
-import { generateAgentDesign } from '../agents/agent-designer.js';
+import { generateAgentDesign, optimizeAgentPrompt } from '../agents/agent-designer.js';
 const router = Router({ mergeParams: true });
 router.get('/usage/dashboard', (req, res) => {
     const days = Number(req.query.days ?? 30);
@@ -22,6 +22,9 @@ router.post('/presets', (req, res) => {
     const preset = agentService.createPreset(req.params.id, body);
     res.status(201).json(preset);
 });
+router.post('/presets/sync-workspaces', (_req, res) => {
+    res.json(agentService.syncTemplatesToAllWorkspaces());
+});
 router.post('/presets/generate', async (req, res) => {
     const { prompt } = req.body;
     if (!prompt?.trim()) {
@@ -36,6 +39,20 @@ router.post('/presets/generate', async (req, res) => {
         res.status(400).json({ error: err instanceof Error ? err.message : 'agent generation failed' });
     }
 });
+router.post('/presets/optimize-prompt', async (req, res) => {
+    const { prompt, currentPrompt } = req.body;
+    if (!prompt?.trim()) {
+        res.status(400).json({ error: 'prompt is required' });
+        return;
+    }
+    try {
+        res.json(await optimizeAgentPrompt(prompt, currentPrompt ?? ''));
+    }
+    catch (err) {
+        console.error('[agent-designer] optimize failed', err);
+        res.status(400).json({ error: err instanceof Error ? err.message : 'prompt optimization failed' });
+    }
+});
 router.post('/presets/test-connection', async (req, res) => {
     const workspaceId = req.params.id;
     const data = req.body;