@agent-spaces/server 0.3.65 → 0.4.0

package/dist/routes/chat.js

@@ -0,0 +1,142 @@
+import { Router } from 'express';
+import * as svc from '../services/chat.js';
+import * as fileService from '../services/file.js';
+const router = Router();
+// GET /api/chat/agents — list all chat agents
+router.get('/agents', (_req, res) => {
+    try {
+        res.json(svc.listAgents());
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// POST /api/chat/agents — create agent (requires name, provider, model, apiKey)
+router.post('/agents', (req, res) => {
+    const body = req.body;
+    const name = typeof body.name === 'string' ? body.name.trim() : '';
+    const provider = stringValue(body.provider) || stringValue(body.modelProvider);
+    const model = stringValue(body.model) || stringValue(body.modelId);
+    if (!name || !provider || !model) {
+        res.status(400).json({ error: 'name, provider, and model are required' });
+        return;
+    }
+    try {
+        const agent = svc.createAgent(body);
+        res.status(201).json(agent);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// PUT /api/chat/agents/:id — update agent
+router.put('/agents/:id', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const patch = normalizeChatAgentPatch(req.body);
+        const agent = svc.updateAgent(id, patch);
+        if (!agent) {
+            res.status(404).json({ error: 'Agent not found' });
+            return;
+        }
+        res.json(agent);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+function normalizeChatAgentPatch(body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return {};
+    const patch = { ...body };
+    if (!patch.baseURL && patch.apiBase) {
+        patch.baseURL = patch.apiBase;
+    }
+    delete patch.apiBase;
+    return patch;
+}
+// DELETE /api/chat/agents/:id — delete agent + its messages
+router.delete('/agents/:id', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const deleted = svc.deleteAgent(id);
+        if (!deleted) {
+            res.status(404).json({ error: 'Agent not found' });
+            return;
+        }
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// GET /api/chat/agents/:id/messages — list messages (?limit=50&before=msgId)
+router.get('/agents/:id/messages', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const agent = svc.findAgent(id);
+        if (!agent) {
+            res.status(404).json({ error: 'Agent not found' });
+            return;
+        }
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : undefined;
+        const before = req.query.before;
+        res.json(svc.listMessages(id, limit, before));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// DELETE /api/chat/agents/:id/messages — clear messages
+router.delete('/agents/:id/messages', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        svc.clearMessages(id);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// GET /api/chat/agents/:id/workspace/tree - read chat agent working directory
+router.get('/agents/:id/workspace/tree', async (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const workspace = svc.getAgentWorkspace(id);
+        if (!workspace) {
+            res.status(404).json({ error: 'Agent workspace not found' });
+            return;
+        }
+        const relPath = typeof req.query.path === 'string' ? req.query.path : '';
+        const depth = req.query.depth ? Number(req.query.depth) : Infinity;
+        res.json(await fileService.readTree(workspace, relPath, depth));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+function stringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export default router;
+//# sourceMappingURL=chat.js.map

package/dist/routes/command.js

@@ -104,5 +104,21 @@ router.post('/:commandId/stop', (req, res) => {
         res.status(400).json({ error: error.message });
     }
 });
+router.post('/:commandId/restart', (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.restartCommand(workspaceId, commandId);
+        console.log(`[command] POST restart: workspace=${workspaceId} command=${commandId} -> session=${sessionId}`);
+        res.json({ sessionId });
+    }
+    catch (error) {
+        console.error(`[command] POST restart error: workspace=${workspaceId} command=${commandId}`, error.message);
+        res.status(400).json({ error: error.message });
+    }
+});
 export default router;
 //# sourceMappingURL=command.js.map

package/dist/routes/data.js

@@ -0,0 +1,189 @@
+import { Router } from 'express';
+import { existsSync, statSync, rmSync, cpSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import archiver from 'archiver';
+import AdmZip from 'adm-zip';
+import multer from 'multer';
+import { getDataDir } from '../storage/json-store.js';
+import * as agentStore from '../storage/agent-store.js';
+import * as databaseStore from '../storage/database-store.js';
+import * as kanbanStore from '../storage/kanban-store.js';
+const router = Router();
+const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 500 * 1024 * 1024 } });
+const CATEGORIES = {
+    'auth': { path: 'auth.json', label: 'Authentication', group: 'config' },
+    'user-settings': { path: 'user-settings.json', label: 'User Settings', group: 'config' },
+    'robot-accounts': { path: 'robot-accounts.json', label: 'Robot Accounts', group: 'config' },
+    'speech-recognition': { path: 'speech-recognition.json', label: 'Speech Recognition', group: 'config' },
+    'llm': { path: 'llm', label: 'LLM Models & Providers', group: 'ai' },
+    'agents': { path: 'agents', label: 'Agent Usage', group: 'content' },
+    'database': { path: 'database', label: 'Document Database', group: 'content' },
+    'kanban': { path: 'kanban', label: 'Kanban Boards', group: 'content' },
+    'output-styles': { path: 'output-styles', label: 'Output Styles', group: 'customization' },
+    'prompt-templates': { path: 'prompt-templates', label: 'Prompt Templates', group: 'customization' },
+    'subscriptions': { path: 'subscriptions', label: 'Subscriptions', group: 'billing' },
+    'skills': { path: 'skills', label: 'Skills', group: 'customization' },
+    'mcps': { path: 'mcps', label: 'MCP Servers', group: 'customization' },
+    'agent-templates': { path: 'agent-templates', label: 'Agent Templates', group: 'customization' },
+    'workflows': { path: 'workflows', label: 'Workflows', group: 'content' },
+};
+// GET /api/data/export — stream zip backup
+router.get('/export', (_req, res) => {
+    const dataDir = getDataDir();
+    const timestamp = new Date().toISOString().slice(0, 10);
+    res.setHeader('Content-Type', 'application/zip');
+    res.setHeader('Content-Disposition', `attachment; filename="agent-spaces-backup-${timestamp}.zip"`);
+    const archive = archiver('zip', { zlib: { level: 6 } });
+    archive.on('error', (err) => {
+        console.error('[data-export] archive error:', err);
+        if (!res.headersSent) {
+            res.status(500).json({ error: 'Failed to create archive' });
+        }
+        else {
+            res.end();
+        }
+    });
+    archive.pipe(res);
+    for (const { path: relPath } of Object.values(CATEGORIES)) {
+        const fullPath = join(dataDir, relPath);
+        if (!existsSync(fullPath))
+            continue;
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            archive.directory(fullPath, relPath);
+        }
+        else {
+            archive.file(fullPath, { name: relPath });
+        }
+    }
+    archive.finalize();
+});
+// POST /api/data/import/preview — upload zip, extract, return categories
+router.post('/import/preview', upload.single('file'), (req, res) => {
+    if (!req.file?.buffer) {
+        res.status(400).json({ error: 'No file uploaded' });
+        return;
+    }
+    try {
+        const zip = new AdmZip(req.file.buffer);
+        const sessionId = randomUUID();
+        const tempDir = join(tmpdir(), `agent-spaces-import-${sessionId}`);
+        zip.extractAllTo(tempDir, true);
+        const found = [];
+        for (const [key, { path: relPath, label, group }] of Object.entries(CATEGORIES)) {
+            const fullPath = join(tempDir, relPath);
+            if (!existsSync(fullPath))
+                continue;
+            const stat = statSync(fullPath);
+            const isDir = stat.isDirectory();
+            found.push({
+                key,
+                label,
+                group,
+                size: isDir ? getDirSize(fullPath) : stat.size,
+                type: isDir ? 'directory' : 'file',
+                details: isDir ? `${countFiles(fullPath)} files` : formatSize(stat.size),
+            });
+        }
+        activeImportSessions.set(sessionId, { tempDir, expiresAt: Date.now() + 30 * 60 * 1000 });
+        res.json({ sessionId, categories: found });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// POST /api/data/import/execute — restore selected categories
+router.post('/import/execute', (req, res) => {
+    const { sessionId, categories: selectedCategories } = req.body;
+    if (!sessionId || !selectedCategories?.length) {
+        res.status(400).json({ error: 'sessionId and categories are required' });
+        return;
+    }
+    const session = activeImportSessions.get(sessionId);
+    if (!session || Date.now() > session.expiresAt) {
+        res.status(410).json({ error: 'Import session expired. Please upload again.' });
+        return;
+    }
+    const dataDir = getDataDir();
+    const results = {};
+    for (const categoryKey of selectedCategories) {
+        const category = CATEGORIES[categoryKey];
+        if (!category) {
+            results[categoryKey] = 'skipped';
+            continue;
+        }
+        try {
+            const srcPath = join(session.tempDir, category.path);
+            const destPath = join(dataDir, category.path);
+            if (!existsSync(srcPath)) {
+                results[categoryKey] = 'skipped';
+                continue;
+            }
+            // Close SQLite connections before overwriting
+            if (categoryKey === 'agents')
+                agentStore.closeDb();
+            else if (categoryKey === 'database')
+                databaseStore.closeDb();
+            else if (categoryKey === 'kanban')
+                kanbanStore.closeDb();
+            if (statSync(srcPath).isDirectory()) {
+                if (existsSync(destPath))
+                    rmSync(destPath, { recursive: true, force: true });
+                cpSync(srcPath, destPath, { recursive: true });
+            }
+            else {
+                cpSync(srcPath, destPath);
+            }
+            results[categoryKey] = 'ok';
+        }
+        catch (e) {
+            console.error(`[data-import] error importing ${categoryKey}:`, e);
+            results[categoryKey] = 'error';
+        }
+    }
+    // Cleanup
+    rmSync(session.tempDir, { recursive: true, force: true });
+    activeImportSessions.delete(sessionId);
+    res.json({ results });
+});
+// --- In-memory import sessions with auto-cleanup ---
+const activeImportSessions = new Map();
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, session] of activeImportSessions) {
+        if (now > session.expiresAt) {
+            rmSync(session.tempDir, { recursive: true, force: true });
+            activeImportSessions.delete(id);
+        }
+    }
+}, 10 * 60 * 1000).unref();
+// --- Helpers ---
+function listFilesRecursive(dir) {
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            results.push(...listFilesRecursive(join(dir, entry.name)));
+        }
+        else {
+            results.push(join(dir, entry.name));
+        }
+    }
+    return results;
+}
+function getDirSize(dir) {
+    return listFilesRecursive(dir).reduce((sum, f) => sum + statSync(f).size, 0);
+}
+function countFiles(dir) {
+    return listFilesRecursive(dir).length;
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export default router;
+//# sourceMappingURL=data.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, gitFetch, gitGetRemotes, gitAddRemote, gitCheckoutDetached, gitCherryPick, gitCreateBranch, gitDeleteBranch, gitCreateTag, gitCommitDiff, gitGetRemoteUrl, gitMergeBase, gitGetConfig, gitSetConfig, gitStage, gitUnstage, gitResolveFile } 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, gitReset } from '../adapters/git.js';
 import { logGitOperation, getGitOperations } from '../services/git-operation-log.js';
 const router = Router({ mergeParams: true });
 function withLog(operation, inputFn, handler) {
@@ -201,5 +201,14 @@ router.post('/config', withLog('config.set', (req) => ({ name: req.body?.name, e
 router.get('/operations', (req, res) => {
     res.json(getGitOperations(req.params.id));
 });
+router.post('/reset', withLog('reset', (req) => ({ commitHash: req.body?.commitHash, mode: req.body?.mode }), async (req, res) => {
+    const { commitHash, mode } = req.body;
+    if (!commitHash) {
+        res.status(400).json({ error: 'commitHash is required' });
+        return;
+    }
+    await gitReset(req.params.id, commitHash, mode || 'mixed');
+    res.json({ ok: true });
+}));
 export default router;
 //# sourceMappingURL=git.js.map

package/dist/routes/import.js

@@ -0,0 +1,199 @@
+import { Router } from 'express';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import * as llmStore from '../storage/llm-store.js';
+import { importSkillsBatch } from '../services/skill.js';
+import { importMcps } from '../services/mcp.js';
+const router = Router();
+const CC_SWITCH_DIR = join(homedir(), '.cc-switch');
+const CONFIG_FILE = join(CC_SWITCH_DIR, 'config.json.migrated');
+const SKILLS_DIR = join(CC_SWITCH_DIR, 'skills');
+const MODEL_ENV_KEYS = [
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+];
+function extractModels(env) {
+    const seen = new Set();
+    for (const key of MODEL_ENV_KEYS) {
+        const val = env[key];
+        if (val && !seen.has(val))
+            seen.add(val);
+    }
+    return [...seen];
+}
+function parseProviders(config) {
+    const results = [];
+    const sections = ['claude', 'codex', 'gemini'];
+    const envMappings = {
+        claude: { base: 'ANTHROPIC_BASE_URL', key: 'ANTHROPIC_AUTH_TOKEN' },
+        codex: { base: 'CODEX_BASE_URL', key: 'OPENAI_API_KEY' },
+        gemini: { base: 'GOOGLE_GEMINI_BASE_URL', key: 'GEMINI_API_KEY' },
+    };
+    for (const section of sections) {
+        const providers = config[section]?.providers;
+        if (!providers)
+            continue;
+        const { base: baseKey, key: apiKeyKey } = envMappings[section];
+        for (const [id, p] of Object.entries(providers)) {
+            const env = p.settingsConfig?.env || {};
+            let apiBase = env[baseKey] || '';
+            let apiKey = env[apiKeyKey] || '';
+            if (section === 'codex') {
+                apiKey = apiKey || p.settingsConfig?.auth?.OPENAI_API_KEY || '';
+                if (!apiBase) {
+                    const configStr = p.settingsConfig?.config || '';
+                    const match = configStr.match(/base_url\s*=\s*"([^"]+)"/);
+                    if (match)
+                        apiBase = match[1];
+                }
+            }
+            if (section === 'claude') {
+                apiKey = apiKey || env.ANTHROPIC_API_KEY || '';
+            }
+            if (!apiKey && !apiBase)
+                continue;
+            results.push({
+                sourceId: id,
+                name: p.name || id,
+                apiBase,
+                apiKey,
+                source: section,
+                websiteUrl: p.websiteUrl,
+                category: p.category,
+                models: extractModels(env),
+            });
+        }
+    }
+    return results;
+}
+function parseSkills() {
+    if (!existsSync(SKILLS_DIR))
+        return [];
+    const results = [];
+    const folders = readdirSync(SKILLS_DIR).filter(f => {
+        const p = join(SKILLS_DIR, f);
+        return statSync(p).isDirectory() && !f.startsWith('_');
+    });
+    for (const folder of folders) {
+        const skillFile = join(SKILLS_DIR, folder, 'SKILL.md');
+        if (!existsSync(skillFile))
+            continue;
+        const content = readFileSync(skillFile, 'utf-8');
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        let description = '';
+        if (fmMatch) {
+            const descMatch = fmMatch[1].match(/description:\s*["']?(.+?)["']?\s*$/m);
+            if (descMatch)
+                description = descMatch[1];
+        }
+        results.push({ name: folder, path: skillFile, description });
+    }
+    return results;
+}
+function parseMcps(config) {
+    const servers = config.mcp?.servers;
+    if (!servers)
+        return [];
+    const results = [];
+    for (const [, s] of Object.entries(servers)) {
+        if (!s.server?.command)
+            continue;
+        results.push({
+            name: s.name || s.id,
+            command: s.server.command,
+            args: s.server.args || [],
+            env: s.server.env || {},
+        });
+    }
+    return results;
+}
+// GET /api/import/cc-switch/preview
+router.get('/cc-switch/preview', (_req, res) => {
+    if (!existsSync(CONFIG_FILE)) {
+        res.json({ providers: [], skills: [], mcps: [], error: 'cc-switch config not found' });
+        return;
+    }
+    try {
+        const raw = readFileSync(CONFIG_FILE, 'utf-8');
+        const config = JSON.parse(raw);
+        const providers = parseProviders(config);
+        const skills = parseSkills();
+        const mcps = parseMcps(config);
+        res.json({ providers, skills, mcps });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// POST /api/import/cc-switch/execute
+router.post('/cc-switch/execute', (req, res) => {
+    const { providers: selectedProviders, skills: selectedSkills, mcps: selectedMcps } = req.body;
+    const results = { providers: [], models: [], skills: [], mcps: [] };
+    // Import providers + models
+    if (selectedProviders?.length) {
+        const existingProviders = llmStore.listProviders();
+        const existingModels = llmStore.listModels();
+        for (const p of selectedProviders) {
+            if (!p.name)
+                continue;
+            // skip if provider with same name already exists
+            let provider = existingProviders.find(ep => ep.name === p.name);
+            if (!provider) {
+                provider = llmStore.createProvider({
+                    name: p.name,
+                    apiBase: p.apiBase || '',
+                    apiKey: p.apiKey || '',
+                });
+                results.providers.push(p.name);
+            }
+            else {
+                results.providers.push(`${p.name} (skipped: exists)`);
+            }
+            // import associated models (deduplicated)
+            for (const modelId of p.models) {
+                if (existingModels.some(m => m.modelId === modelId && m.provider === provider.id))
+                    continue;
+                llmStore.createModel({
+                    modelId,
+                    name: modelId,
+                    provider: provider.id,
+                    thinkingEnabled: true,
+                    thinkingEffort: 'medium',
+                    vision: false,
+                    reasoning: false,
+                    embedding: false,
+                });
+                results.models.push(modelId);
+            }
+        }
+    }
+    // Import skills
+    if (selectedSkills?.length) {
+        const items = [];
+        for (const s of selectedSkills) {
+            const skillFile = join(SKILLS_DIR, s.name, 'SKILL.md');
+            if (!existsSync(skillFile))
+                continue;
+            items.push({ name: s.name, content: readFileSync(skillFile, 'utf-8') });
+        }
+        if (items.length) {
+            const imported = importSkillsBatch(items);
+            results.skills = imported.map(s => s.name);
+        }
+    }
+    // Import MCP servers
+    if (selectedMcps?.length) {
+        const mcpServers = {};
+        for (const m of selectedMcps) {
+            mcpServers[m.name] = { command: m.command, args: m.args, env: m.env };
+        }
+        const imported = importMcps(JSON.stringify(mcpServers));
+        results.mcps = imported.map(m => m.name);
+    }
+    res.json(results);
+});
+export default router;
+//# sourceMappingURL=import.js.map

package/dist/routes/issue.js

@@ -10,6 +10,7 @@ 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';
+import { scheduleIssueTitleGeneration } from '../services/generated-title.js';
 const router = Router({ mergeParams: true });
 router.get('/', (req, res) => {
     const status = req.query.status;
@@ -18,13 +19,15 @@ router.get('/', (req, res) => {
 });
 router.post('/', (req, res) => {
     const { title, description, members, workflowId } = req.body;
-    if (!title) {
-        res.status(400).json({ error: 'title is required' });
+    const trimmedTitle = typeof title === 'string' ? title.trim() : '';
+    const trimmedDescription = typeof description === 'string' ? description.trim() : '';
+    if (!trimmedTitle && !trimmedDescription) {
+        res.status(400).json({ error: 'title or description is required' });
         return;
     }
     const issue = issueService.create(req.params.id, {
-        title,
-        description: description || '',
+        title: trimmedTitle,
+        description: trimmedDescription,
         members: mergeWorkflowMembers(members, workflowId),
         workflowId,
     });
@@ -33,6 +36,15 @@ router.post('/', (req, res) => {
         broadcastToWorkspace(req.params.id, 'channel.updated', channel);
     broadcastToWorkspace(req.params.id, 'issue.created', issue);
     res.status(201).json(issue);
+    if (!trimmedTitle) {
+        scheduleIssueTitleGeneration({
+            workspaceId: req.params.id,
+            issueId: issue.id,
+            requirement: trimmedDescription,
+            description: trimmedDescription,
+            broadcast: (event, data) => broadcastToWorkspace(req.params.id, event, data),
+        });
+    }
 });
 router.get('/:issueId', (req, res) => {
     const issue = issueService.getById(req.params.id, req.params.issueId);
@@ -313,7 +325,7 @@ function mergeWorkflowMembers(members, workflowId) {
         return base;
     return Array.from(new Set([
         ...base,
-        ...workflow.nodes.map((node) => node.data.agentConfigId).filter(Boolean),
+        ...workflow.nodes.filter((n) => n.type === 'agent').map((node) => node.data.agentConfigId).filter(Boolean),
     ]));
 }
 //# sourceMappingURL=issue.js.map

package/dist/routes/notification.js

@@ -27,5 +27,15 @@ router.delete('/', (req, res) => {
     nc.clearAll(workspaceId);
     res.json({ ok: true });
 });
+router.delete('/:notificationId', (req, res) => {
+    const workspaceId = req.params.id;
+    const notificationId = req.params.notificationId;
+    const removed = nc.removeNotification(workspaceId, notificationId);
+    if (!removed) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json({ ok: true });
+});
 export default router;
 //# sourceMappingURL=notification.js.map