@agent-spaces/server 0.3.62 → 0.3.64

package/dist/routes/database.js

@@ -0,0 +1,345 @@
+import { Router } from 'express';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as store from '../storage/database-store.js';
+import * as databaseVector from '../services/database-vector.js';
+import * as agentService from '../services/agent.js';
+import * as workspaceService from '../services/workspace.js';
+import { createDatabaseFunctionTools } from '../services/builtin-tools/index.js';
+import { createAgentRuntime } from '../adapters/agent-runtime.js';
+import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { getDataDir, ensureDir } from '../storage/json-store.js';
+import { generateAgentDesign } from '../agents/agent-designer.js';
+const router = Router({ mergeParams: true });
+const pendingContentSaves = new Map();
+const CONTENT_SAVE_IDLE_MS = 30_000;
+const DATABASE_AGENT_ID = 'database-agent';
+const DATABASE_AGENT_TOOLS = [
+    'ListDatabases',
+    'ListDatabaseNodes',
+    'SearchDatabaseNodes',
+    'QueryDatabaseVectors',
+    'ReadDatabaseNode',
+    'ListDatabaseNodeVersions',
+    'CreateDatabaseNode',
+    'WriteDatabaseNode',
+    'DeleteDatabaseNode',
+    'MoveDatabaseNode',
+    'UpdateDatabaseNodeMeta',
+];
+const wid = (req) => req.params.id;
+const databaseId = (req) => req.query.databaseId || store.getDefaultDatabase(wid(req)).id;
+router.get('/agent-presets', (req, res) => {
+    res.json([readDatabaseAgent(wid(req))]);
+});
+router.get('/agent-presets/:presetId', (req, res) => {
+    if (req.params.presetId !== DATABASE_AGENT_ID)
+        return res.status(404).json({ error: 'database agent not found' });
+    res.json(readDatabaseAgent(wid(req)));
+});
+router.put('/agent-presets/:presetId', (req, res) => {
+    if (req.params.presetId !== DATABASE_AGENT_ID)
+        return res.status(404).json({ error: 'database agent not found' });
+    res.json(writeDatabaseAgent(wid(req), req.body));
+});
+router.post('/agent-presets/test-connection', async (req, res) => {
+    const result = await agentService.testConnection(wid(req), req.body);
+    if (!result)
+        return res.status(404).json({ error: 'workspace not found' });
+    res.status(result.success ? 200 : 400).json(result);
+});
+router.post('/agent-presets/generate', async (req, res) => {
+    const { prompt } = req.body;
+    if (!prompt?.trim())
+        return res.status(400).json({ error: 'prompt is required' });
+    try {
+        res.json(await generateAgentDesign(prompt));
+    }
+    catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : 'agent generation failed' });
+    }
+});
+router.post('/chat', async (req, res) => {
+    const workspaceId = wid(req);
+    const { message, history } = req.body;
+    const prompt = message?.trim();
+    if (!prompt)
+        return res.status(400).json({ error: 'message is required' });
+    const workspace = workspaceService.getById(workspaceId);
+    if (!workspace)
+        return res.status(404).json({ error: 'workspace not found' });
+    const agent = readDatabaseAgent(workspaceId);
+    if (agent.enabled === false)
+        return res.status(400).json({ error: 'database agent is disabled' });
+    const workingDir = workspace.boundDirs[0] || process.cwd();
+    const functionTools = createDatabaseFunctionTools(workspaceId, agent.tools);
+    const runtime = createAgentRuntime({
+        kind: agent.runtimeKind,
+        provider: agent.modelProvider,
+        model: agent.modelId,
+        apiKey: agent.apiKey,
+        baseURL: getRuntimeBaseURL(agent.modelProvider, agent.apiBase),
+        adapterBaseURL: agent.apiBase,
+        ...getThinkingRuntimeConfig(agent),
+    });
+    const result = await runtime.execute(buildDatabaseAgentPrompt(workspaceId, agent, prompt, history ?? []), workingDir, {
+        maxTurns: 60,
+        functionTools,
+        mcpServers: {},
+        skills: [],
+        sandboxDirs: [],
+        outputStyle: agent.outputStyle,
+    });
+    const finalMessage = result.success
+        ? extractFinalMessage(result.output, result.summary)
+        : result.error || extractFinalMessage(result.output, result.summary);
+    res.status(result.success ? 200 : 400).json({ finalMessage });
+});
+router.get('/databases', (req, res) => {
+    const databases = store.listDatabases(wid(req));
+    res.json(databases.length > 0 ? databases : [store.getDefaultDatabase(wid(req))]);
+});
+router.post('/databases', (req, res) => {
+    const database = store.createDatabase(wid(req), req.body);
+    res.status(201).json(database);
+});
+router.put('/databases/:databaseId', (req, res) => {
+    const database = store.updateDatabase(wid(req), req.params.databaseId, req.body);
+    if (!database)
+        return res.status(404).json({ error: 'Database not found' });
+    res.json(database);
+});
+router.get('/databases/:databaseId/vector', (req, res) => {
+    if (!store.getDatabase(wid(req), req.params.databaseId)) {
+        return res.status(404).json({ error: 'Database not found' });
+    }
+    res.json(store.getVectorStats(wid(req), req.params.databaseId));
+});
+router.put('/databases/:databaseId/vector', (req, res) => {
+    const { embeddingModelId } = req.body;
+    const database = store.setDatabaseEmbeddingModel(wid(req), req.params.databaseId, embeddingModelId || null);
+    if (!database)
+        return res.status(404).json({ error: 'Database not found' });
+    res.json(store.getVectorStats(wid(req), req.params.databaseId));
+});
+router.post('/databases/:databaseId/vector/index', async (req, res) => {
+    try {
+        res.json(await databaseVector.indexDatabaseVectors(wid(req), req.params.databaseId));
+    }
+    catch (error) {
+        console.error('[database:vector:index] failed', {
+            workspaceId: wid(req),
+            databaseId: req.params.databaseId,
+            error: error instanceof Error ? error.message : String(error),
+            debug: error instanceof databaseVector.DatabaseVectorError ? error.debug : undefined,
+        });
+        res.status(400).json({
+            error: error instanceof Error ? error.message : String(error),
+            debug: error instanceof databaseVector.DatabaseVectorError ? error.debug : undefined,
+        });
+    }
+});
+router.delete('/databases/:databaseId', (req, res) => {
+    if (!store.deleteDatabase(wid(req), req.params.databaseId)) {
+        return res.status(404).json({ error: 'Database not found' });
+    }
+    res.json({ ok: true });
+});
+// List all nodes
+router.get('/', (req, res) => {
+    res.json(store.listNodes(wid(req), databaseId(req)));
+});
+// Get single node
+router.get('/:nodeId', (req, res) => {
+    const node = store.getNode(wid(req), req.params.nodeId, databaseId(req));
+    if (!node)
+        return res.status(404).json({ error: 'Node not found' });
+    res.json(node);
+});
+router.get('/:nodeId/versions', (req, res) => {
+    flushPendingContentSave(wid(req), databaseId(req), req.params.nodeId);
+    const limit = typeof req.query.limit === 'string' ? Number(req.query.limit) : 50;
+    const versions = store.listNodeVersions(wid(req), req.params.nodeId, databaseId(req), limit);
+    res.json(versions);
+});
+// Create node
+router.post('/', (req, res) => {
+    const node = store.createNode(wid(req), { ...req.body, databaseId: databaseId(req) });
+    res.status(201).json(node);
+});
+// Update node
+router.put('/:nodeId', (req, res) => {
+    const workspaceId = wid(req);
+    const activeDatabaseId = databaseId(req);
+    const nodeId = req.params.nodeId;
+    const body = req.body;
+    const { content, ...metadataUpdates } = body;
+    let node = Object.keys(metadataUpdates).length > 0
+        ? store.updateNode(workspaceId, nodeId, metadataUpdates, activeDatabaseId)
+        : store.getNode(workspaceId, nodeId, activeDatabaseId);
+    if (!node)
+        return res.status(404).json({ error: 'Node not found' });
+    if (typeof content === 'string') {
+        scheduleContentSave(workspaceId, activeDatabaseId, nodeId, content);
+        node = { ...node, content, updatedAt: Date.now() };
+    }
+    res.json(node);
+});
+// Move node (change parent)
+router.put('/:nodeId/move', (req, res) => {
+    const { parentId } = req.body;
+    const node = store.moveNode(wid(req), req.params.nodeId, parentId ?? null, databaseId(req));
+    if (!node)
+        return res.status(404).json({ error: 'Node not found' });
+    res.json(node);
+});
+// Trash node (soft delete)
+router.put('/:nodeId/trash', (req, res) => {
+    const node = store.trashNode(wid(req), req.params.nodeId, databaseId(req));
+    if (!node)
+        return res.status(404).json({ error: 'Node not found' });
+    res.json(node);
+});
+// Restore node from trash
+router.put('/:nodeId/restore', (req, res) => {
+    const node = store.restoreNode(wid(req), req.params.nodeId, databaseId(req));
+    if (!node)
+        return res.status(404).json({ error: 'Node not found' });
+    res.json(node);
+});
+// Delete node permanently
+router.delete('/:nodeId', (req, res) => {
+    if (!store.deleteNode(wid(req), req.params.nodeId, databaseId(req))) {
+        return res.status(404).json({ error: 'Node not found' });
+    }
+    res.json({ ok: true });
+});
+function scheduleContentSave(workspaceId, activeDatabaseId, nodeId, content) {
+    const key = `${workspaceId}:${activeDatabaseId}:${nodeId}`;
+    const existing = pendingContentSaves.get(key);
+    if (existing)
+        clearTimeout(existing.timer);
+    const timer = setTimeout(() => {
+        flushPendingContentSave(workspaceId, activeDatabaseId, nodeId);
+    }, CONTENT_SAVE_IDLE_MS);
+    pendingContentSaves.set(key, { timer, content });
+}
+function flushPendingContentSave(workspaceId, activeDatabaseId, nodeId) {
+    const key = `${workspaceId}:${activeDatabaseId}:${nodeId}`;
+    const pending = pendingContentSaves.get(key);
+    if (!pending)
+        return;
+    clearTimeout(pending.timer);
+    pendingContentSaves.delete(key);
+    store.updateNode(workspaceId, nodeId, { content: pending.content }, activeDatabaseId);
+}
+function databaseAgentPath(workspaceId) {
+    return join(getDataDir(), 'workspaces', workspaceId, 'database', 'agent.json');
+}
+function readDatabaseAgent(workspaceId) {
+    const filePath = databaseAgentPath(workspaceId);
+    if (!existsSync(filePath))
+        return defaultDatabaseAgent();
+    try {
+        return normalizeDatabaseAgent(JSON.parse(readFileSync(filePath, 'utf-8')));
+    }
+    catch {
+        return defaultDatabaseAgent();
+    }
+}
+function writeDatabaseAgent(workspaceId, input) {
+    const agent = normalizeDatabaseAgent(input);
+    ensureDir(join(getDataDir(), 'workspaces', workspaceId, 'database'));
+    writeFileSync(databaseAgentPath(workspaceId), JSON.stringify(agent, null, 2), 'utf-8');
+    return agent;
+}
+function defaultDatabaseAgent() {
+    return normalizeDatabaseAgent({
+        name: 'Database AI',
+        role: 'agent',
+        description: 'Knowledge base assistant for Agent Spaces database documents.',
+        runtimeKind: 'claude-code',
+        modelProvider: undefined,
+        modelId: '',
+        apiBase: '',
+        apiKey: '',
+        systemPrompt: [
+            'You are the database knowledge base assistant.',
+            'Answer from Agent Spaces database content when possible.',
+            'Use only the provided database tools for knowledge base operations.',
+            'Return only the final answer in concise Markdown.',
+        ].join('\n'),
+        temperature: 0.2,
+        maxTokens: 4096,
+        enabled: true,
+    });
+}
+function normalizeDatabaseAgent(input) {
+    return {
+        id: DATABASE_AGENT_ID,
+        name: input.name?.trim() || 'Database AI',
+        role: 'agent',
+        description: input.description || '',
+        runtimeKind: input.runtimeKind || 'claude-code',
+        modelProvider: input.modelProvider,
+        modelId: input.modelId || '',
+        apiBase: input.apiBase || '',
+        apiKey: input.apiKey || '',
+        workingDir: '',
+        mcps: {},
+        skills: [],
+        tools: DATABASE_AGENT_TOOLS,
+        systemPrompt: input.systemPrompt || defaultDatabaseAgent().systemPrompt,
+        outputStyle: input.outputStyle,
+        temperature: input.temperature ?? 0.2,
+        maxTokens: input.maxTokens ?? 4096,
+        sandboxDirs: [],
+        maxRetries: input.maxRetries,
+        enabled: input.enabled ?? true,
+    };
+}
+function buildDatabaseAgentPrompt(workspaceId, agent, userMessage, history) {
+    const recentHistory = history
+        .slice(-12)
+        .map((item) => `${item.role === 'user' ? 'User' : 'Agent'}: ${item.content}`)
+        .join('\n\n');
+    return [
+        agent.systemPrompt?.trim(),
+        'Runtime constraints:',
+        `- Current workspace id: ${workspaceId}`,
+        '- MCP servers configured for this agent: none.',
+        `- Available database tools: ${DATABASE_AGENT_TOOLS.map((tool) => `mcp__agent-spaces__${tool}`).join(', ')}.`,
+        '- Use mcp__agent-spaces__ListDatabases when you need to know valid database IDs.',
+        '- If the user does not specify a database, omit databaseId and the first database will be used automatically.',
+        '- Never use the workspace id as databaseId.',
+        '- Do not use filesystem, command, issue, channel, web, or other non-database tools for knowledge base work.',
+        '- If you need database content, call the database tools before answering.',
+        '- Return only the final answer in Markdown. Do not include tool logs or implementation traces.',
+        recentHistory ? `Conversation history:\n${recentHistory}` : '',
+        `User message:\n${userMessage}`,
+    ].filter(Boolean).join('\n\n');
+}
+function extractFinalMessage(output, fallback) {
+    const candidates = output
+        .map((line) => line.trim())
+        .filter((line) => {
+        if (!line)
+            return false;
+        if (/^\[Usage\]/i.test(line))
+            return false;
+        if (/^(Tool:|Todo:|Codex initialized\b|Claude Code initialized\b)/i.test(line))
+            return false;
+        if (/^\[Reasoning\]/i.test(line))
+            return false;
+        return true;
+    });
+    return candidates.at(-1) || fallback || '';
+}
+function getRuntimeBaseURL(provider, apiBase) {
+    if (provider === 'openai-responses-to-anthropic-messages'
+        || provider === 'openai-chat-completions-to-anthropic-messages')
+        return undefined;
+    return apiBase;
+}
+export default router;
+//# sourceMappingURL=database.js.map

package/dist/routes/git.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { gitStatus, gitDiff, gitLog, gitCommit, gitDiscard, gitDiscardAll, gitBranches, gitCheckout, gitInit, gitGenerateCommitMsg, gitPush, gitPull, gitGetRemotes, gitAddRemote, gitCheckoutDetached, gitCherryPick, gitCreateBranch, gitDeleteBranch, gitCreateTag, gitCommitDiff, gitGetRemoteUrl, gitMergeBase, gitGetConfig, gitSetConfig } from '../adapters/git.js';
+import { gitStatus, gitDiff, gitLog, gitCommit, gitDiscard, gitDiscardAll, gitBranches, gitCheckout, gitInit, gitGenerateCommitMsg, gitPush, gitPull, gitFetch, gitGetRemotes, gitAddRemote, gitCheckoutDetached, gitCherryPick, gitCreateBranch, gitDeleteBranch, gitCreateTag, gitCommitDiff, gitGetRemoteUrl, gitMergeBase, gitGetConfig, gitSetConfig, gitStage, gitUnstage, gitResolveFile } from '../adapters/git.js';
 const router = Router({ mergeParams: true });
 router.get('/status', async (req, res) => {
     try {
@@ -67,6 +67,48 @@ router.post('/discard-all', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+router.post('/stage', async (req, res) => {
+    try {
+        const { path } = req.body;
+        if (!path) {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        await gitStage(req.params.id, path);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/unstage', async (req, res) => {
+    try {
+        const { path } = req.body;
+        if (!path) {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        await gitUnstage(req.params.id, path);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/resolve-file', async (req, res) => {
+    try {
+        const { path, content, stage } = req.body;
+        if (!path || typeof content !== 'string') {
+            res.status(400).json({ error: 'path and content are required' });
+            return;
+        }
+        await gitResolveFile(req.params.id, path, content, stage !== false);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 router.get('/branches', async (req, res) => {
     try {
         const result = await gitBranches(req.params.id);
@@ -108,6 +150,15 @@ router.post('/generate-commit-message', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+router.post('/fetch', async (req, res) => {
+    try {
+        await gitFetch(req.params.id);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 router.post('/push', async (req, res) => {
     try {
         await gitPush(req.params.id);

package/dist/routes/hooks.js

@@ -0,0 +1,88 @@
+import { Router } from 'express';
+import * as store from '../storage/hook-store.js';
+const router = Router({ mergeParams: true });
+router.get('/', (req, res) => {
+    try {
+        res.json(store.listHooks(req.params.id));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/:name', (req, res) => {
+    try {
+        const hook = store.getHook(req.params.id, req.params.name);
+        if (!hook) {
+            res.status(404).json({ error: 'Hook not found' });
+            return;
+        }
+        res.json(hook);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/', (req, res) => {
+    try {
+        const config = req.body;
+        if (!config.name) {
+            res.status(400).json({ error: 'name required' });
+            return;
+        }
+        store.saveHook(req.params.id, config);
+        res.status(201).json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.put('/:name', (req, res) => {
+    try {
+        const config = req.body;
+        config.name = req.params.name;
+        store.saveHook(req.params.id, config);
+        res.json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:name', (req, res) => {
+    try {
+        store.deleteHook(req.params.id, req.params.name);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/upload', (req, res) => {
+    try {
+        const { content } = req.body;
+        if (!content || typeof content !== 'string') {
+            res.status(400).json({ error: 'content (string) required' });
+            return;
+        }
+        const config = store.uploadHook(req.params.id, content);
+        res.status(201).json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:name/apply', (req, res) => {
+    try {
+        const { targetWorkspaceId } = req.body;
+        if (!targetWorkspaceId) {
+            res.status(400).json({ error: 'targetWorkspaceId required' });
+            return;
+        }
+        store.applyToWorkspace(req.params.id, req.params.name, targetWorkspaceId);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+export default router;
+//# sourceMappingURL=hooks.js.map

package/dist/routes/issue.js

@@ -8,6 +8,7 @@ import * as agentService from '../services/agent.js';
 import * as taskService from '../services/task.js';
 import { retryIssue } from '../services/issue-retry.js';
 import { hasActiveIssueAutomation, runIssueAutomation } from '../agents/issue-agent-runner.js';
+import { continueIssueTaskScheduling, stopIssueAutomation } from '../agents/issue-task-controller.js';
 import * as workflowService from '../services/workflow.js';
 const router = Router({ mergeParams: true });
 router.get('/', (req, res) => {
@@ -48,13 +49,15 @@ router.put('/:issueId', (req, res) => {
         return;
     }
     const previousStatus = issue.status;
-    const { title, description, status, members, workflowId } = req.body;
+    const { title, description, status, members, workflowId, continuousRun } = req.body;
     if (title)
         issue.title = title;
     if (description !== undefined)
         issue.description = description;
     if (workflowId !== undefined)
         issue.workflowId = workflowId || undefined;
+    if (continuousRun !== undefined)
+        issue.continuousRun = continuousRun !== false;
     if (members !== undefined) {
         issue.members = normalizeIssueMembers(req.params.id, mergeWorkflowMembers(members, issue.workflowId));
     }
@@ -142,6 +145,61 @@ router.post('/:issueId/resume', async (req, res) => {
     }
     res.json(result.issue);
 });
+router.post('/:issueId/continue', (req, res) => {
+    const workspaceId = req.params.id;
+    const { issueId } = req.params;
+    const before = issueService.getById(workspaceId, issueId);
+    if (!before) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    const issue = before.status === 'draft' || before.status === 'planned'
+        ? issueService.updateStatus(workspaceId, issueId, 'in_progress')
+        : before;
+    if (!issue) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    if (issue.status !== before.status) {
+        broadcastToWorkspace(workspaceId, 'issue.status_changed', { issueId, from: before.status, to: issue.status });
+    }
+    broadcastToWorkspace(workspaceId, 'issue.updated', issue);
+    res.json(issue);
+    const ctx = {
+        workspaceId,
+        broadcast: (event, data) => broadcastToWorkspace(workspaceId, event, data),
+        getSession: (sessionId) => agentService.getById(workspaceId, sessionId),
+        updateSessionStatus: (sessionId, status, extra) => agentService.updateStatus(workspaceId, sessionId, status, extra),
+    };
+    continueIssueTaskScheduling(workspaceId, issueId, ctx).catch((err) => {
+        console.error(`[issue-continue] scheduling error for issue ${issueId}:`, err);
+    });
+});
+router.post('/:issueId/interrupt', (req, res) => {
+    const workspaceId = req.params.id;
+    const { issueId } = req.params;
+    const before = issueService.getById(workspaceId, issueId);
+    if (!before) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    const reason = 'Interrupted by user';
+    const failedTasks = stopIssueAutomation(workspaceId, issueId, reason);
+    for (const { task, from } of failedTasks) {
+        broadcastToWorkspace(workspaceId, 'task.status_changed', { taskId: task.id, from, to: task.status });
+        broadcastToWorkspace(workspaceId, 'task.updated', task);
+    }
+    if (before.channelId)
+        stopChannelRuns(workspaceId, before.channelId);
+    const issue = issueService.markError(workspaceId, issueId, reason);
+    if (!issue) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    broadcastToWorkspace(workspaceId, 'issue.status_changed', { issueId, from: before.status, to: 'error' });
+    broadcastToWorkspace(workspaceId, 'issue.updated', issue);
+    res.json(issue);
+});
 router.delete('/:issueId', (req, res) => {
     const { id, issueId } = req.params;
     const issue = issueService.getById(id, issueId);

package/dist/routes/kanban.js

@@ -0,0 +1,39 @@
+import { Router } from 'express';
+import * as svc from '../services/kanban.js';
+const router = Router({ mergeParams: true });
+// GET /api/workspaces/:id/kanban — 获取或初始化 board
+router.get('/', (req, res) => {
+    const workspaceId = req.params.id;
+    if (!workspaceId) {
+        res.status(400).json({ error: 'workspaceId required' });
+        return;
+    }
+    try {
+        const board = svc.ensureBoard(workspaceId);
+        res.json(board);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// PUT /api/workspaces/:id/kanban — 保存完整 board 状态
+router.put('/', (req, res) => {
+    const workspaceId = req.params.id;
+    if (!workspaceId) {
+        res.status(400).json({ error: 'workspaceId required' });
+        return;
+    }
+    try {
+        const board = svc.saveBoard(workspaceId, req.body);
+        if (!board) {
+            res.status(404).json({ error: 'Board not found' });
+            return;
+        }
+        res.json(board);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+export default router;
+//# sourceMappingURL=kanban.js.map

package/dist/routes/output-style.js

@@ -0,0 +1,48 @@
+import { Router } from 'express';
+import { listOutputStyles, createOutputStyle, updateOutputStyle, deleteOutputStyle, applyOutputStyleToAgents, listOutputStyleAgentCandidates, } from '../services/output-style.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(listOutputStyles());
+});
+router.get('/agents', (_req, res) => {
+    res.json(listOutputStyleAgentCandidates());
+});
+router.post('/', (req, res) => {
+    const { name, content, storeId, description } = req.body;
+    if (!name || !content) {
+        res.status(400).json({ error: 'name and content required' });
+        return;
+    }
+    res.json(createOutputStyle(name, content, storeId, description));
+});
+router.put('/:id', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const data = req.body;
+    const tmpl = updateOutputStyle(id, data);
+    if (!tmpl) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json(tmpl);
+});
+router.delete('/:id', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const ok = deleteOutputStyle(id);
+    if (!ok) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.post('/:id/apply', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const { agentIds } = req.body;
+    if (!agentIds?.length) {
+        res.status(400).json({ error: 'agentIds required' });
+        return;
+    }
+    const applied = applyOutputStyleToAgents(id, agentIds);
+    res.json({ applied });
+});
+export default router;
+//# sourceMappingURL=output-style.js.map