@agent-spaces/server 0.3.67 → 0.4.0

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

package/dist/routes/plugin.js

@@ -0,0 +1,69 @@
+import { Router } from 'express';
+import * as pluginService from '../services/plugin.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    try {
+        res.json(pluginService.listPlugins());
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/workflow', (_req, res) => {
+    try {
+        res.json(pluginService.listWorkflowPlugins());
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/store/:pluginId/install', (req, res) => {
+    try {
+        res.json(pluginService.installTemplatePlugin(req.params.pluginId));
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:pluginId/enable', (req, res) => {
+    try {
+        res.json(pluginService.setPluginEnabled(req.params.pluginId, true));
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:pluginId/disable', (req, res) => {
+    try {
+        res.json(pluginService.setPluginEnabled(req.params.pluginId, false));
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.get('/:pluginId/config', (req, res) => {
+    try {
+        res.json(pluginService.getPluginConfig(req.params.pluginId));
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.put('/:pluginId/config', (req, res) => {
+    try {
+        res.json(pluginService.savePluginConfig(req.params.pluginId, req.body || {}));
+    }
+    catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+});
+router.get('/:pluginId/workflow-nodes', (req, res) => {
+    try {
+        res.json({ pluginId: req.params.pluginId, nodes: pluginService.getWorkflowNodes(req.params.pluginId) });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+export default router;
+//# sourceMappingURL=plugin.js.map

package/dist/routes/version.js

@@ -5,7 +5,8 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { getLocalVersion, getCachedLatest, fetchLatestVersion, isNewerVersion } from '../services/version.js';
 const router = Router();
-const isDev = !process.env.NODE_ENV || process.env.NODE_ENV === 'development';
+const isSourceRuntime = /[\\/]src[\\/]routes$/.test(import.meta.dirname);
+const isDev = process.env.NODE_ENV === 'development' || (!process.env.NODE_ENV && isSourceRuntime);
 let isUpdating = false;
 // GET /version — cached version info (openPaths in auth.ts)
 router.get('/version', async (_req, res) => {

package/dist/routes/workflow-hook.js

@@ -0,0 +1,71 @@
+// Workflow webhook hook handler — SSE streaming of execution results
+import { Router } from 'express';
+const SSE_TIMEOUT_MS = 5 * 60_000;
+export function createWorkflowHookRouter(triggerService, executionManager) {
+    const router = Router();
+    router.post('/hook/:hookName', (req, res) => {
+        const hookName = req.params.hookName;
+        const bindings = triggerService.getHookBindings(hookName);
+        if (bindings.length === 0) {
+            res.status(404).json({ error: `No workflows bound to hook "${hookName}"` });
+            return;
+        }
+        const body = req.body || {};
+        let targets = bindings;
+        if (body.workflowId) {
+            targets = bindings.filter(b => b.workflowId === body.workflowId);
+            if (targets.length === 0) {
+                res.status(404).json({ error: `Workflow ${body.workflowId} not bound to hook "${hookName}"` });
+                return;
+            }
+        }
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        let completed = 0;
+        let closed = false;
+        const sse = (event, payload) => {
+            if (closed)
+                return;
+            res.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+        };
+        const timeoutId = setTimeout(() => {
+            if (!closed) {
+                sse('timeout', { message: 'SSE timeout, closing' });
+                res.write('event: done\ndata: {}\n\n');
+                closed = true;
+                res.end();
+            }
+        }, SSE_TIMEOUT_MS);
+        res.on('close', () => {
+            closed = true;
+            clearTimeout(timeoutId);
+        });
+        const total = targets.length;
+        for (const binding of targets) {
+            executionManager.execute({ workflowId: binding.workflowId, input: body.input || {} }, '__hook__', (channel, payload) => sse(channel, payload)).then(() => {
+                completed++;
+                if (completed === total && !closed) {
+                    clearTimeout(timeoutId);
+                    res.write('event: done\ndata: {}\n\n');
+                    closed = true;
+                    res.end();
+                }
+            }).catch((err) => {
+                sse('workflow:error', { workflowId: binding.workflowId, error: err.message });
+                completed++;
+                if (completed === total && !closed) {
+                    clearTimeout(timeoutId);
+                    res.write('event: done\ndata: {}\n\n');
+                    closed = true;
+                    res.end();
+                }
+            });
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=workflow-hook.js.map