@agent-spaces/server 0.3.63 → 0.3.64

package/dist/adapters/claude-code-runtime/message-format.js

@@ -24,7 +24,7 @@ export function formatMessage(message) {
         case 'tool_progress':
             return `${message.tool_name} running (${message.elapsed_time_seconds}s)`;
         case 'tool_use_summary':
-            return message.summary;
+            return null;
         default:
             return null;
     }

package/dist/adapters/git.js

@@ -36,26 +36,36 @@ function getGit(workspace) {
 }
 function mapStatus(raw) {
     const files = [];
+    const addOrUpdate = (file) => {
+        const existing = files.find(x => x.path === file.path);
+        if (existing) {
+            Object.assign(existing, file, {
+                staged: existing.staged || file.staged,
+                conflicted: existing.conflicted || file.conflicted,
+                status: file.conflicted ? 'conflicted' : existing.status,
+            });
+        }
+        else {
+            files.push(file);
+        }
+    };
     for (const f of raw.staged) {
-        files.push({ path: f, status: mapStatusCode(raw.files.find(r => r.path === f)?.index) });
+        addOrUpdate({ path: f, status: mapStatusCode(raw.files.find(r => r.path === f)?.index), staged: true });
     }
     for (const f of raw.modified) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'modified' });
-        }
+        addOrUpdate({ path: f, status: 'modified' });
     }
     for (const f of raw.not_added) {
-        files.push({ path: f, status: 'untracked' });
+        addOrUpdate({ path: f, status: 'untracked' });
     }
     for (const f of raw.deleted) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'deleted' });
-        }
+        addOrUpdate({ path: f, status: 'deleted' });
     }
     for (const f of raw.created) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'added' });
-        }
+        addOrUpdate({ path: f, status: 'added', staged: raw.staged.includes(f) });
+    }
+    for (const f of raw.conflicted) {
+        addOrUpdate({ path: f, status: 'conflicted', conflicted: true });
     }
     return {
         branch: raw.current || 'HEAD',
@@ -67,6 +77,73 @@ function mapStatus(raw) {
         deletions: 0,
     };
 }
+async function getUpstreamRef(git, branch) {
+    const upstream = await git.raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
+        .then(v => v.trim())
+        .catch(() => '');
+    if (upstream)
+        return upstream;
+    if (!branch || branch === 'HEAD')
+        return null;
+    const originBranch = `origin/${branch}`;
+    const hasOriginBranch = await git.raw(['rev-parse', '--verify', '--quiet', originBranch])
+        .then(() => true)
+        .catch(() => false);
+    return hasOriginBranch ? originBranch : null;
+}
+function splitConflictSides(content) {
+    const left = [];
+    const right = [];
+    let mode = 'both';
+    let hasConflict = false;
+    for (const line of content.split('\n')) {
+        if (line.startsWith('<<<<<<< ')) {
+            hasConflict = true;
+            mode = 'left';
+            continue;
+        }
+        if (line.startsWith('=======')) {
+            mode = 'right';
+            continue;
+        }
+        if (line.startsWith('>>>>>>> ')) {
+            mode = 'both';
+            continue;
+        }
+        if (mode === 'both' || mode === 'left')
+            left.push(line);
+        if (mode === 'both' || mode === 'right')
+            right.push(line);
+    }
+    return { left: left.join('\n'), right: right.join('\n'), hasConflict };
+}
+async function buildWorkingDiff(git, rootDir, filePath, conflicted = false) {
+    const binary = isBinaryPath(filePath);
+    const workingContent = binary ? '' : await readFile(join(rootDir, filePath), 'utf-8').catch(() => '');
+    if (!binary && conflicted) {
+        const conflict = splitConflictSides(workingContent);
+        if (conflict.hasConflict) {
+            return {
+                path: filePath,
+                oldContent: conflict.left,
+                newContent: conflict.right,
+                isBinary: false,
+                isNew: false,
+                isDeleted: false,
+                isConflict: true,
+            };
+        }
+    }
+    const oldContent = binary ? '' : await git.show([`HEAD:${filePath}`]).catch(() => '');
+    return {
+        path: filePath,
+        oldContent,
+        newContent: workingContent,
+        isBinary: binary,
+        isNew: !oldContent,
+        isDeleted: !workingContent,
+    };
+}
 function mapStatusCode(code) {
     switch (code) {
         case 'A': return 'added';
@@ -83,6 +160,19 @@ export async function gitStatus(workspaceId) {
     const git = getGit(ws);
     const raw = await git.status();
     const result = mapStatus(raw);
+    try {
+        const headHash = await git.revparse(['--short', 'HEAD']);
+        result.headHash = headHash.trim();
+    }
+    catch { }
+    try {
+        const upstream = await getUpstreamRef(git, result.branch);
+        if (upstream) {
+            const remoteHeadHash = await git.revparse(['--short', upstream]);
+            result.remoteHeadHash = remoteHeadHash.trim();
+        }
+    }
+    catch { }
     if (!result.clean) {
         try {
             // Tracked changes: modified/deleted/renamed
@@ -122,66 +212,73 @@ export async function gitDiff(workspaceId, filePath) {
         throw new Error('Workspace not found');
     const git = getGit(ws);
     const diffs = [];
+    const status = await git.status();
+    const conflicted = new Set(status.conflicted);
     if (filePath) {
-        const diff = await git.diff([filePath]);
-        const oldContent = await git.show([`HEAD:${filePath}`]).catch(() => '');
-        const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${filePath}`, 'utf-8')).catch(() => '');
-        diffs.push({
-            path: filePath,
-            oldContent: isBinaryPath(filePath) ? '' : oldContent,
-            newContent: isBinaryPath(filePath) ? '' : newContent,
-            isBinary: isBinaryPath(filePath),
-            isNew: !oldContent,
-            isDeleted: !newContent,
-        });
+        diffs.push(await buildWorkingDiff(git, ws.boundDirs[0], filePath, conflicted.has(filePath)));
     }
     else {
         const raw = await git.diff(['--name-only']);
-        const files = raw.split('\n').filter(Boolean);
+        const cachedRaw = await git.diff(['--cached', '--name-only']);
+        const files = Array.from(new Set([
+            ...raw.split('\n').filter(Boolean),
+            ...cachedRaw.split('\n').filter(Boolean),
+            ...status.not_added,
+            ...status.conflicted,
+        ]));
         for (const f of files) {
-            const binary = isBinaryPath(f);
-            const oldContent = binary ? '' : await git.show([`HEAD:${f}`]).catch(() => '');
-            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            diffs.push({
-                path: f,
-                oldContent,
-                newContent,
-                isBinary: binary,
-                isNew: !oldContent,
-                isDeleted: !newContent,
-            });
-        }
-        // Also check untracked (staged new files)
-        const status = await git.status();
-        for (const f of status.not_added) {
-            const binary = isBinaryPath(f);
-            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            if (newContent || binary) {
-                diffs.push({
-                    path: f,
-                    oldContent: '',
-                    newContent: binary ? '' : newContent,
-                    isBinary: binary,
-                    isNew: true,
-                    isDeleted: false,
-                });
-            }
+            diffs.push(await buildWorkingDiff(git, ws.boundDirs[0], f, conflicted.has(f)));
         }
     }
     return diffs;
 }
+export async function gitStage(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.add(filePath);
+}
+export async function gitUnstage(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.raw(['restore', '--staged', '--', filePath]).catch(async () => {
+        await git.raw(['reset', 'HEAD', '--', filePath]);
+    });
+}
+export async function gitResolveFile(workspaceId, filePath, content, stage = true) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await writeFile(join(ws.boundDirs[0], filePath), content, 'utf-8');
+    if (stage)
+        await git.add(filePath);
+}
 export async function gitLog(workspaceId, maxCount = 50) {
     const ws = getWorkspace(workspaceId);
     if (!ws)
         throw new Error('Workspace not found');
     const git = getGit(ws);
-    const log = await git.log({ maxCount });
-    return log.all.map(entry => ({
-        hash: entry.hash.substring(0, 7),
-        message: entry.message,
-        author: entry.author_name,
-        date: entry.date,
-    }));
+    const status = await git.status();
+    const upstream = await getUpstreamRef(git, status.current || 'HEAD');
+    const refs = upstream ? ['HEAD', upstream] : ['HEAD'];
+    const pretty = '%H%x1f%s%x1f%an%x1f%aI%x1e';
+    const raw = await git.raw(['log', `--max-count=${maxCount}`, `--pretty=format:${pretty}`, ...refs]);
+    return raw.split('\x1e')
+        .map(record => record.trim())
+        .filter(Boolean)
+        .map(record => {
+        const [hash = '', message = '', author = '', date = ''] = record.split('\x1f');
+        return {
+            hash: hash.substring(0, 7),
+            message,
+            author,
+            date,
+        };
+    });
 }
 export async function gitCommit(workspaceId, message) {
     const ws = getWorkspace(workspaceId);
@@ -274,6 +371,13 @@ export async function gitPush(workspaceId) {
         throw new Error('No remote repository configured. Please add a remote first.');
     await git.push('origin', branch);
 }
+export async function gitFetch(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.fetch('origin');
+}
 export async function gitPull(workspaceId) {
     const ws = getWorkspace(workspaceId);
     if (!ws)

package/dist/agents/agent-designer.js

@@ -28,13 +28,36 @@ export async function generateAgentDesign(userPrompt) {
         apiBase: maskUrl(config.apiBase),
         promptLength: prompt.length,
     });
-    const content = await requestDesign(config, prompt);
+    const content = await requestText(config, buildDesignSystemPrompt(config), prompt);
     console.info('[agent-designer] model text extracted', {
         length: content.length,
         preview: content.slice(0, 500),
     });
     return normalizeDesign(parseJsonObject(content));
 }
+export async function optimizeAgentPrompt(userPrompt, currentPrompt) {
+    const prompt = userPrompt.trim();
+    if (!prompt)
+        throw new Error('prompt is required');
+    const config = resolveModelConfig();
+    if (!config) {
+        throw new Error(`Configure model settings for ${AGENT_GENERATOR_PRESET_ID} before optimizing prompts.`);
+    }
+    console.info('[agent-designer] optimizing agent prompt', {
+        agentId: AGENT_GENERATOR_PRESET_ID,
+        provider: config.modelProvider ?? inferProvider(config.apiBase),
+        modelId: config.modelId,
+        apiBase: maskUrl(config.apiBase),
+        promptLength: prompt.length,
+        currentPromptLength: currentPrompt.trim().length,
+    });
+    const content = await requestText(config, buildOptimizationSystemPrompt(config), buildPromptOptimizationUserPrompt(prompt, currentPrompt));
+    console.info('[agent-designer] optimized prompt received', {
+        length: content.length,
+        preview: content.slice(0, 500),
+    });
+    return { systemPrompt: normalizePrompt(content) };
+}
 function resolveModelConfig() {
     const preset = readAgentTemplate(AGENT_GENERATOR_PRESET_ID);
     if (preset?.apiBase && preset.apiKey && preset.modelId) {
@@ -51,14 +74,17 @@ function resolveModelConfig() {
     return null;
 }
 async function requestDesign(config, userPrompt) {
+    return requestText(config, buildDesignSystemPrompt(config), userPrompt);
+}
+async function requestText(config, systemPrompt, userPrompt) {
     const provider = config.modelProvider ?? inferProvider(config.apiBase);
     if (provider === 'anthropic-messages')
-        return requestAnthropic(config, userPrompt);
+        return requestAnthropic(config, systemPrompt, userPrompt);
     if (provider === 'gemini-generate-content')
-        return requestGemini(config, userPrompt);
-    return requestOpenAICompatible(config, userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
+        return requestGemini(config, systemPrompt, userPrompt);
+    return requestOpenAICompatible(config, systemPrompt, userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
 }
-async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
+async function requestOpenAICompatible(config, systemPrompt, userPrompt, useResponsesApi) {
     const url = joinUrl(config.apiBase, useResponsesApi ? '/responses' : '/chat/completions');
     const response = await fetch(url, {
         method: 'POST',
@@ -69,14 +95,14 @@ async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
         body: JSON.stringify(useResponsesApi
             ? {
                 model: config.modelId,
-                input: `${buildSystemPrompt(config)}\n\nUser request:\n${userPrompt}`,
+                input: `${systemPrompt}\n\nUser request:\n${userPrompt}`,
                 temperature: config.temperature ?? 0.2,
                 max_output_tokens: config.maxTokens,
             }
             : {
                 model: config.modelId,
                 messages: [
-                    { role: 'system', content: buildSystemPrompt(config) },
+                    { role: 'system', content: systemPrompt },
                     { role: 'user', content: userPrompt },
                 ],
                 temperature: config.temperature ?? 0.2,
@@ -88,7 +114,7 @@ async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-async function requestAnthropic(config, userPrompt) {
+async function requestAnthropic(config, systemPrompt, userPrompt) {
     const response = await fetch(getAnthropicMessagesUrl(config.apiBase), {
         method: 'POST',
         headers: {
@@ -98,7 +124,7 @@ async function requestAnthropic(config, userPrompt) {
         },
         body: JSON.stringify({
             model: config.modelId,
-            system: buildSystemPrompt(config),
+            system: systemPrompt,
             messages: [{ role: 'user', content: userPrompt }],
             max_tokens: config.maxTokens ?? 4096,
             temperature: config.temperature ?? 0.2,
@@ -109,7 +135,7 @@ async function requestAnthropic(config, userPrompt) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-async function requestGemini(config, userPrompt) {
+async function requestGemini(config, systemPrompt, userPrompt) {
     const response = await fetch(joinUrl(config.apiBase, `/models/${encodeURIComponent(config.modelId)}:generateContent`), {
         method: 'POST',
         headers: {
@@ -117,7 +143,7 @@ async function requestGemini(config, userPrompt) {
             'Content-Type': 'application/json',
         },
         body: JSON.stringify({
-            systemInstruction: { parts: [{ text: buildSystemPrompt(config) }] },
+            systemInstruction: { parts: [{ text: systemPrompt }] },
             contents: [{ role: 'user', parts: [{ text: userPrompt }] }],
             generationConfig: {
                 temperature: config.temperature ?? 0.2,
@@ -130,12 +156,40 @@ async function requestGemini(config, userPrompt) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-function buildSystemPrompt(config) {
+function buildDesignSystemPrompt(config) {
     const custom = config.systemPrompt?.trim();
     if (!custom)
         return SYSTEM_PROMPT;
     return `${custom}\n\n${SYSTEM_PROMPT}`;
 }
+function buildOptimizationSystemPrompt(config) {
+    const custom = config.systemPrompt?.trim();
+    const base = [
+        'You optimize agent system prompts.',
+        'Return only the rewritten prompt text.',
+        'Do not wrap the result in markdown fences.',
+        'Do not add commentary, bullets about the process, or any explanation outside the prompt.',
+        'Keep the prompt actionable, concise, and directly usable as a system prompt.',
+        'Preserve important constraints from the current prompt unless the user request clearly asks to change them.',
+    ].join('\n');
+    if (!custom)
+        return base;
+    return `${custom}\n\n${base}`;
+}
+function buildPromptOptimizationUserPrompt(userRequest, currentPrompt) {
+    return [
+        'User request:',
+        userRequest,
+        '',
+        'Current system prompt:',
+        currentPrompt.trim() || '(empty)',
+        '',
+        'Rewrite the current system prompt according to the user request. Return only the final prompt text.',
+    ].join('\n');
+}
+function normalizePrompt(text) {
+    return text.trim().replace(/^```(?:markdown|md)?\s*/i, '').replace(/\s*```$/i, '');
+}
 async function readResponseBody(response) {
     const raw = await response.text();
     if (!raw)

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';

package/dist/app.js

@@ -7,7 +7,7 @@ import { createServer } from 'node:http';
 import { WebSocketServer } from 'ws';
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } 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,10 @@ 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 { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
@@ -158,6 +161,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 +252,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 +264,7 @@ 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);
 // 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

@@ -143,11 +143,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);
@@ -36,6 +36,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;