@agent-spaces/server 0.1.2 → 0.2.1

package/dist/routes/agent.js

@@ -6,31 +6,45 @@ router.get('/usage/dashboard', (req, res) => {
     res.json(agentService.usageDashboard(Number.isFinite(days) ? days : 30));
 });
 router.get('/presets', (req, res) => {
-    const presets = agentService.listPresets(req.params.id);
-    if (!presets) {
-        res.status(404).json({ error: 'workspace not found' });
-        return;
-    }
-    res.json(presets);
+    res.json(agentService.listTemplates());
 });
-router.post('/presets', (req, res) => {
-    const preset = agentService.createPreset(req.params.id, req.body);
+router.get('/presets/:presetId', (req, res) => {
+    const preset = agentService.readAgentTemplate(req.params.presetId);
     if (!preset) {
-        res.status(404).json({ error: 'workspace not found' });
+        res.status(404).json({ error: 'agent preset not found' });
         return;
     }
+    res.json(preset);
+});
+router.post('/presets', (req, res) => {
+    const body = req.body;
+    const preset = agentService.createPreset(req.params.id, body);
     res.status(201).json(preset);
 });
 router.post('/presets/test-connection', async (req, res) => {
-    const result = await agentService.testConnection(req.params.id, req.body);
+    const workspaceId = req.params.id;
+    const data = req.body;
+    if (workspaceId) {
+        const result = await agentService.testConnection(workspaceId, data);
+        if (!result) {
+            res.status(404).json({ error: 'workspace not found' });
+            return;
+        }
+        res.status(result.success ? 200 : 400).json(result);
+        return;
+    }
+    // Global: test connection without workspace context
+    const { apiBase, apiKey, modelId, modelProvider } = data;
+    const result = await agentService.testConnection('', { apiBase, apiKey, modelId, modelProvider });
     if (!result) {
-        res.status(404).json({ error: 'workspace not found' });
+        res.status(400).json({ error: 'connection test failed' });
         return;
     }
     res.status(result.success ? 200 : 400).json(result);
 });
 router.put('/presets/:presetId', (req, res) => {
-    const preset = agentService.updatePreset(req.params.id, req.params.presetId, req.body);
+    const data = req.body;
+    const preset = agentService.updatePreset(req.params.id, req.params.presetId, data);
     if (!preset) {
         res.status(404).json({ error: 'agent preset not found' });
         return;
@@ -38,11 +52,21 @@ router.put('/presets/:presetId', (req, res) => {
     res.json(preset);
 });
 router.delete('/presets/:presetId', (req, res) => {
-    const deleted = agentService.deletePreset(req.params.id, req.params.presetId);
-    if (deleted === null) {
-        res.status(404).json({ error: 'workspace not found' });
+    const workspaceId = req.params.id;
+    if (workspaceId) {
+        const deleted = agentService.deletePreset(workspaceId, req.params.presetId);
+        if (deleted === null) {
+            res.status(404).json({ error: 'workspace not found' });
+            return;
+        }
+        if (!deleted) {
+            res.status(404).json({ error: 'agent preset not found' });
+            return;
+        }
+        res.status(204).end();
         return;
     }
+    const deleted = agentService.deleteGlobalPreset(req.params.presetId);
     if (!deleted) {
         res.status(404).json({ error: 'agent preset not found' });
         return;
@@ -59,8 +83,7 @@ router.post('/start', (req, res) => {
         res.status(400).json({ error: 'role is required' });
         return;
     }
-    const validRoles = ['scheduler', 'planner', 'executor', 'reviewer', 'custom', 'bot'];
-    if (!validRoles.includes(role)) {
+    if (!agentService.isValidRole(role)) {
         res.status(400).json({ error: `invalid role: ${role}` });
         return;
     }

package/dist/routes/channel.js

@@ -1,7 +1,8 @@
 import { Router } from 'express';
 import { listChannels, createChannel, getChannel, updateChannel, deleteChannel } from '../services/channel.js';
 import { listMessages, createMessage, updateMessage, deleteMessage, clearMessages } from '../services/message.js';
-import { broadcastToWorkspace, hasActiveChannelRuns, markInactiveChannelRunsStopped } from '../ws/handler.js';
+import { broadcastToWorkspace } from '../ws/connection-manager.js';
+import { hasActiveChannelRuns, markInactiveChannelRunsStopped, stopChannelRuns } from '../ws/agent-runner.js';
 import { getToolDetail } from '../services/tool-detail.js';
 const router = Router({ mergeParams: true });
 // GET /api/workspaces/:id/channels
@@ -38,6 +39,8 @@ router.put('/:channelId', (req, res) => {
 // DELETE /api/workspaces/:id/channels/:channelId
 router.delete('/:channelId', (req, res) => {
     const { id, channelId } = req.params;
+    // 先停止该频道中所有运行中的 agent
+    stopChannelRuns(id, channelId);
     const ok = deleteChannel(id, channelId);
     if (!ok) {
         res.status(404).json({ error: 'channel not found' });

package/dist/routes/command.js

@@ -0,0 +1,108 @@
+import { Router } from 'express';
+import * as commandService from '../services/command.js';
+import * as processManager from '../services/command-process-manager.js';
+const router = Router({ mergeParams: true });
+router.get('/', (req, res) => {
+    const workspaceId = req.params.id;
+    if (!workspaceId) {
+        res.status(400).json({ error: 'workspaceId required' });
+        return;
+    }
+    try {
+        res.json(commandService.listCommands(workspaceId));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/processes', (req, res) => {
+    const workspaceId = req.params.id;
+    if (!workspaceId) {
+        res.status(400).json({ error: 'workspaceId required' });
+        return;
+    }
+    res.json(processManager.getCommandProcesses(workspaceId));
+});
+router.post('/', (req, res) => {
+    const workspaceId = req.params.id;
+    if (!workspaceId) {
+        res.status(400).json({ error: 'workspaceId required' });
+        return;
+    }
+    try {
+        const cmd = commandService.createCommand(workspaceId, req.body);
+        res.status(201).json(cmd);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.put('/:commandId', (req, res) => {
+    const { id: workspaceId, commandId } = req.params;
+    if (!workspaceId || !commandId) {
+        res.status(400).json({ error: 'workspaceId and commandId required' });
+        return;
+    }
+    try {
+        const cmd = commandService.updateCommand(workspaceId, commandId, req.body);
+        res.json(cmd);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:commandId', (req, res) => {
+    const { id: workspaceId, commandId } = req.params;
+    if (!workspaceId || !commandId) {
+        res.status(400).json({ error: 'workspaceId and commandId required' });
+        return;
+    }
+    try {
+        const process = processManager.getCommandProcess(commandId);
+        if (process) {
+            try {
+                processManager.stopCommand(workspaceId, commandId);
+            }
+            catch { }
+        }
+        commandService.deleteCommand(workspaceId, commandId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:commandId/run', (req, res) => {
+    const { id: workspaceId, commandId } = req.params;
+    if (!workspaceId || !commandId) {
+        res.status(400).json({ error: 'workspaceId and commandId required' });
+        return;
+    }
+    try {
+        const sessionId = processManager.runCommand(workspaceId, commandId);
+        console.log(`[command] POST run: workspace=${workspaceId} command=${commandId} -> session=${sessionId}`);
+        res.json({ sessionId });
+    }
+    catch (error) {
+        console.error(`[command] POST run error: workspace=${workspaceId} command=${commandId}`, error.message);
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:commandId/stop', (req, res) => {
+    const { id: workspaceId, commandId } = req.params;
+    if (!workspaceId || !commandId) {
+        res.status(400).json({ error: 'workspaceId and commandId required' });
+        return;
+    }
+    try {
+        processManager.stopCommand(workspaceId, commandId);
+        console.log(`[command] POST stop: workspace=${workspaceId} command=${commandId}`);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        console.error(`[command] POST stop error: workspace=${workspaceId} command=${commandId}`, error.message);
+        res.status(400).json({ error: error.message });
+    }
+});
+export default router;
+//# sourceMappingURL=command.js.map

package/dist/routes/folder.js

@@ -1,41 +1,51 @@
 import { Router } from 'express';
-import { readdir, stat, mkdir, access } from 'node:fs/promises';
-import { join, resolve, sep } from 'node:path';
+import { readdir, stat, mkdir, access, readFile } from 'node:fs/promises';
+import { join, resolve, sep, extname } from 'node:path';
 import { homedir } from 'node:os';
 import { constants } from 'node:fs';
 const router = Router();
 router.get('/browse', async (req, res) => {
     const raw = req.query.path || '';
+    const includeFiles = req.query.files === '1';
+    const fileFilter = req.query.fileFilter || '';
     const rawPath = raw === '~' || raw === '' ? homedir() : raw.replace(/^~[/\\]/, homedir() + sep);
     const dirPath = resolve(rawPath);
     try {
         const entries = await readdir(dirPath, { withFileTypes: true });
         const directories = [];
+        const files = [];
         for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            // Skip hidden directories
+            // Skip hidden entries
             if (entry.name.startsWith('.'))
                 continue;
             try {
                 const fullPath = join(dirPath, entry.name);
                 await stat(fullPath);
-                directories.push({ name: entry.name, path: fullPath });
+                if (entry.isDirectory()) {
+                    directories.push({ name: entry.name, path: fullPath });
+                }
+                else if (includeFiles && entry.isFile()) {
+                    if (!fileFilter || entry.name.endsWith(fileFilter)) {
+                        files.push({ name: entry.name, path: fullPath });
+                    }
+                }
             }
             catch {
-                // Skip inaccessible directories
+                // Skip inaccessible entries
             }
         }
         // Compute parent path
         const parentPath = resolve(dirPath, '..');
         const isRoot = parentPath === dirPath;
         directories.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
+        files.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
         res.json({
             path: dirPath,
             parent: isRoot ? null : parentPath,
             separator: sep,
             home: homedir(),
             directories,
+            files,
         });
     }
     catch (err) {
@@ -97,5 +107,32 @@ router.get('/check-permissions', async (req, res) => {
     }
     res.json(result);
 });
+router.get('/read-file', async (req, res) => {
+    const raw = req.query.path;
+    if (!raw) {
+        res.status(400).json({ error: 'path is required' });
+        return;
+    }
+    const filePath = resolve(raw.replace(/^~[/\\]/, homedir() + sep));
+    const ext = extname(filePath).toLowerCase();
+    // Only allow reading text-based config files
+    const allowedExts = ['.json', '.yaml', '.yml', '.toml', '.txt', '.md', '.env', '.js', '.ts', '.mjs', '.cjs'];
+    if (!allowedExts.includes(ext)) {
+        res.status(400).json({ error: 'File type not allowed' });
+        return;
+    }
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        if (ext === '.json') {
+            res.json(JSON.parse(content));
+        }
+        else {
+            res.json({ content });
+        }
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message || 'Cannot read file' });
+    }
+});
 export default router;
 //# sourceMappingURL=folder.js.map

package/dist/routes/issue.js

@@ -2,11 +2,12 @@ import { Router } from 'express';
 import * as issueService from '../services/issue.js';
 import * as issueCommentService from '../services/issue-comment.js';
 import * as channelService from '../services/channel.js';
-import { broadcastToWorkspace } from '../ws/handler.js';
-import { getWorkspace } from '../storage/workspace-store.js';
+import { broadcastToWorkspace } from '../ws/connection-manager.js';
+import { stopChannelRuns } from '../ws/agent-runner.js';
 import * as agentService from '../services/agent.js';
 import { retryIssue } from '../services/issue-retry.js';
-import { hasActiveIssueAutomation, runIssueAutomation, shouldForcePlannerFromMentions } from '../agents/issue-agent-runner.js';
+import { hasActiveIssueAutomation, runIssueAutomation } from '../agents/issue-agent-runner.js';
+import * as workflowService from '../services/workflow.js';
 const router = Router({ mergeParams: true });
 router.get('/', (req, res) => {
     const status = req.query.status;
@@ -14,12 +15,17 @@ router.get('/', (req, res) => {
     res.json(issues);
 });
 router.post('/', (req, res) => {
-    const { title, description, members } = req.body;
+    const { title, description, members, workflowId } = req.body;
     if (!title) {
         res.status(400).json({ error: 'title is required' });
         return;
     }
-    const issue = issueService.create(req.params.id, { title, description: description || '', members });
+    const issue = issueService.create(req.params.id, {
+        title,
+        description: description || '',
+        members: mergeWorkflowMembers(members, workflowId),
+        workflowId,
+    });
     const channel = issue.channelId ? channelService.getChannel(req.params.id, issue.channelId) : null;
     if (channel)
         broadcastToWorkspace(req.params.id, 'channel.updated', channel);
@@ -40,27 +46,37 @@ router.put('/:issueId', (req, res) => {
         res.status(404).json({ error: 'issue not found' });
         return;
     }
-    const { title, description, status, members } = req.body;
+    const previousStatus = issue.status;
+    const { title, description, status, members, workflowId } = req.body;
     if (title)
         issue.title = title;
     if (description !== undefined)
         issue.description = description;
-    if (members) {
-        issue.members = normalizeIssueMembers(req.params.id, members);
-        if (issue.channelId) {
-            const updatedChannel = channelService.updateChannel(req.params.id, issue.channelId, { members: ['user', ...issue.members] });
-            if (updatedChannel)
-                broadcastToWorkspace(req.params.id, 'channel.updated', updatedChannel);
-        }
+    if (workflowId !== undefined)
+        issue.workflowId = workflowId || undefined;
+    if (members !== undefined) {
+        issue.members = normalizeIssueMembers(req.params.id, mergeWorkflowMembers(members, issue.workflowId));
+    }
+    else if (workflowId !== undefined) {
+        issue.members = normalizeIssueMembers(req.params.id, mergeWorkflowMembers(issue.members, issue.workflowId));
+    }
+    if ((members !== undefined || workflowId !== undefined) && issue.channelId) {
+        const updatedChannel = channelService.updateChannel(req.params.id, issue.channelId, { members: issue.members });
+        if (updatedChannel)
+            broadcastToWorkspace(req.params.id, 'channel.updated', updatedChannel);
     }
     if (status) {
-        const updated = issueService.updateStatus(req.params.id, req.params.issueId, status, { title: issue.title, description: issue.description });
-        broadcastToWorkspace(req.params.id, 'issue.updated', updated);
-        res.json(updated);
-        return;
+        issue.status = status;
     }
     const saved = issueService.save(req.params.id, issue);
     broadcastToWorkspace(req.params.id, 'issue.updated', saved);
+    if (status && status !== previousStatus) {
+        // 状态变更时停止该议题关联频道中所有运行中的 agent
+        if (issue.channelId) {
+            stopChannelRuns(req.params.id, issue.channelId);
+        }
+        broadcastToWorkspace(req.params.id, 'issue.status_changed', { issueId: req.params.issueId, from: previousStatus, to: status });
+    }
     res.json(saved);
 });
 router.post('/:issueId/start', (req, res) => {
@@ -108,11 +124,17 @@ router.post('/:issueId/resume', async (req, res) => {
     res.json(result.issue);
 });
 router.delete('/:issueId', (req, res) => {
-    const ok = issueService.remove(req.params.id, req.params.issueId);
-    if (!ok) {
+    const { id, issueId } = req.params;
+    const issue = issueService.getById(id, issueId);
+    if (!issue) {
         res.status(404).json({ error: 'issue not found' });
         return;
     }
+    // 先停止该议题关联频道中所有运行中的 agent
+    if (issue.channelId) {
+        stopChannelRuns(id, issue.channelId);
+    }
+    issueService.remove(id, issueId);
     res.status(204).send();
 });
 router.get('/:issueId/comments', (req, res) => {
@@ -164,9 +186,7 @@ router.post('/:issueId/comments', (req, res) => {
             getSession: (sessionId) => agentService.getById(workspaceId, sessionId),
             updateSessionStatus: (sessionId, status, extra) => agentService.updateStatus(workspaceId, sessionId, status, extra),
         };
-        runIssueAutomation(workspaceId, issueId, ctx, {
-            forcePlanner: shouldForcePlannerFromMentions(workspaceId, mentions),
-        }).catch((err) => {
+        runIssueAutomation(workspaceId, issueId, ctx).catch((err) => {
             console.error(`[issue-comment] automation error for issue ${issueId}:`, err);
         });
     }
@@ -194,7 +214,7 @@ router.delete('/:issueId/comments/:commentId', (req, res) => {
 });
 export default router;
 function normalizeIssueMembers(workspaceId, members) {
-    const agentIds = new Set((getWorkspace(workspaceId)?.agents || []).map((agent) => agent.id));
+    const agentIds = new Set(agentService.listPresets(workspaceId).map((agent) => agent.id));
     const normalized = [];
     const seen = new Set();
     for (const member of members) {
@@ -205,4 +225,18 @@ function normalizeIssueMembers(workspaceId, members) {
     }
     return normalized;
 }
+function mergeWorkflowMembers(members, workflowId) {
+    const base = Array.isArray(members)
+        ? members.filter((member) => typeof member === 'string' && Boolean(member.trim())).map((member) => member.trim())
+        : [];
+    if (typeof workflowId !== 'string' || !workflowId.trim())
+        return base;
+    const workflow = workflowService.getWorkflow(workflowId.trim());
+    if (!workflow)
+        return base;
+    return Array.from(new Set([
+        ...base,
+        ...workflow.nodes.map((node) => node.data.agentConfigId).filter(Boolean),
+    ]));
+}
 //# sourceMappingURL=issue.js.map

package/dist/routes/mcp.js

@@ -0,0 +1,50 @@
+import { Router } from 'express';
+import { listMcps, importMcps, updateMcpConfig, deleteMcp, toggleFavorite } from '../services/mcp.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(listMcps());
+});
+router.post('/import', (req, res) => {
+    const { jsonText } = req.body;
+    if (!jsonText) {
+        res.status(400).json({ error: 'jsonText required' });
+        return;
+    }
+    try {
+        const mcps = importMcps(jsonText);
+        res.json(mcps);
+    }
+    catch (e) {
+        res.status(400).json({ error: 'Invalid JSON: ' + e.message });
+    }
+});
+router.put('/:name', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const { config } = req.body;
+    if (!config) {
+        res.status(400).json({ error: 'config required' });
+        return;
+    }
+    const ok = updateMcpConfig(name, config);
+    if (!ok) {
+        res.status(404).json({ error: 'MCP server not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+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.delete('/:name', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const ok = deleteMcp(name);
+    if (!ok) {
+        res.status(404).json({ error: 'MCP server not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+export default router;
+//# sourceMappingURL=mcp.js.map

package/dist/routes/skill.js

@@ -0,0 +1,57 @@
+import { Router } from 'express';
+import { listSkills, importSkill, toggleFavorite, updateSkillContent, deleteSkill, checkSkillSync, syncSkills } from '../services/skill.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(listSkills());
+});
+router.get('/sync-check', (_req, res) => {
+    res.json(checkSkillSync());
+});
+router.post('/sync', (req, res) => {
+    const { items } = req.body;
+    if (!Array.isArray(items) || items.length === 0) {
+        res.status(400).json({ error: 'items required' });
+        return;
+    }
+    const synced = syncSkills(items);
+    res.json({ synced });
+});
+router.post('/import', (req, res) => {
+    const { filename, content } = req.body;
+    if (!filename || !content) {
+        res.status(400).json({ error: 'filename and content required' });
+        return;
+    }
+    const skill = importSkill(filename, content);
+    res.json(skill);
+});
+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.put('/:name', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const { content } = req.body;
+    if (content === undefined) {
+        res.status(400).json({ error: 'content required' });
+        return;
+    }
+    const ok = updateSkillContent(name, content);
+    if (!ok) {
+        res.status(404).json({ error: 'Skill not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.delete('/:name', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const ok = deleteSkill(name);
+    if (!ok) {
+        res.status(404).json({ error: 'Skill not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+export default router;
+//# sourceMappingURL=skill.js.map

package/dist/routes/subscription.js

@@ -0,0 +1,49 @@
+import { Router } from 'express';
+import * as store from '../storage/subscription-store.js';
+import { fetchQuota } from '../services/subscription/index.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(store.listSubscriptions());
+});
+router.get('/:id/quota', async (req, res) => {
+    const config = store.getSubscription(req.params.id);
+    if (!config) {
+        res.status(404).json({ error: 'subscription not found' });
+        return;
+    }
+    try {
+        const quota = await fetchQuota(config);
+        res.json(quota);
+    }
+    catch (err) {
+        console.error(`[subscription] fetchQuota failed for ${config.provider}/${config.id}:`, err.message ?? err);
+        res.status(502).json({ error: err.message ?? 'Failed to fetch quota' });
+    }
+});
+router.post('/', (req, res) => {
+    const { provider, label, headers, cookie } = req.body;
+    if (!provider || (!headers && !cookie)) {
+        res.status(400).json({ error: 'provider and headers or cookie are required' });
+        return;
+    }
+    const item = store.createSubscription({ provider, label: label || provider, headers, cookie });
+    res.status(201).json(item);
+});
+router.put('/:id', (req, res) => {
+    const { label, headers, cookie } = req.body;
+    const updated = store.updateSubscription(req.params.id, { label, headers, cookie });
+    if (!updated) {
+        res.status(404).json({ error: 'subscription not found' });
+        return;
+    }
+    res.json(updated);
+});
+router.delete('/:id', (req, res) => {
+    if (!store.deleteSubscription(req.params.id)) {
+        res.status(404).json({ error: 'subscription not found' });
+        return;
+    }
+    res.status(204).end();
+});
+export default router;
+//# sourceMappingURL=subscription.js.map

package/dist/routes/task.js

@@ -2,7 +2,7 @@ import { Router } from 'express';
 import * as taskService from '../services/task.js';
 import * as issueService from '../services/issue.js';
 import * as agentService from '../services/agent.js';
-import { broadcastToWorkspace } from '../ws/handler.js';
+import { broadcastToWorkspace } from '../ws/connection-manager.js';
 import { scheduleRunnableIssueTasks } from '../agents/issue-task-controller.js';
 const router = Router({ mergeParams: true });
 router.post('/', (req, res) => {
@@ -31,6 +31,21 @@ router.get('/', (req, res) => {
     const tasks = taskService.list(req.params.id, issueId);
     res.json(tasks);
 });
+router.put('/reorder', (req, res) => {
+    const { issueId, taskIds } = req.body;
+    if (!issueId || !Array.isArray(taskIds)) {
+        res.status(400).json({ error: 'issueId and taskIds are required' });
+        return;
+    }
+    const issue = issueService.getById(req.params.id, issueId);
+    if (!issue) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    issueService.replaceTasks(req.params.id, issueId, taskIds);
+    const updated = issueService.getById(req.params.id, issueId);
+    res.json(updated);
+});
 router.get('/:taskId', (req, res) => {
     const task = taskService.getById(req.params.id, req.params.taskId);
     if (!task) {