@agent-spaces/server 0.3.65 → 0.4.0

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

@@ -0,0 +1,95 @@
+import { Router } from 'express';
+import { spawn } from 'node:child_process';
+import { writeFileSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { getLocalVersion, getCachedLatest, fetchLatestVersion, isNewerVersion } from '../services/version.js';
+const router = Router();
+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) => {
+    const local = getLocalVersion();
+    if (isDev) {
+        res.json({ local, latest: null, updateAvailable: false, dev: true });
+        return;
+    }
+    let latest = getCachedLatest();
+    if (!latest) {
+        latest = await fetchLatestVersion(false);
+    }
+    res.json({ local, latest, updateAvailable: latest ? isNewerVersion(latest, local) : false });
+});
+// GET /version/check — force npm lookup (openPaths in auth.ts)
+router.get('/version/check', async (_req, res) => {
+    const local = getLocalVersion();
+    if (isDev) {
+        res.json({ local, latest: null, updateAvailable: false, dev: true });
+        return;
+    }
+    const latest = await fetchLatestVersion(true);
+    res.json({
+        local,
+        latest,
+        updateAvailable: latest ? isNewerVersion(latest, local) : false,
+    });
+});
+// POST /version/update — trigger self-update (requires auth)
+router.post('/version/update', (_req, res) => {
+    if (isDev) {
+        res.status(403).json({ error: 'Updates are disabled in development mode' });
+        return;
+    }
+    if (isUpdating) {
+        res.status(409).json({ error: 'Update already in progress' });
+        return;
+    }
+    isUpdating = true;
+    const pid = process.pid;
+    const ppid = process.ppid;
+    const projectRoot = join(import.meta.dirname, '..', '..');
+    const isWin = process.platform === 'win32';
+    let scriptPath;
+    if (isWin) {
+        scriptPath = join(tmpdir(), `agent-spaces-update-${pid}.cmd`);
+        const cmd = [
+            '@echo off',
+            'timeout /t 2 /nobreak >nul',
+            `taskkill /pid ${ppid} /f /t >nul 2>&1`,
+            `taskkill /pid ${pid} /f /t >nul 2>&1`,
+            `cd /d "${projectRoot}"`,
+            'call pnpm install',
+            'call pnpm start',
+        ].join('\r\n');
+        writeFileSync(scriptPath, cmd, 'utf-8');
+    }
+    else {
+        scriptPath = join(tmpdir(), `agent-spaces-update-${pid}.sh`);
+        const sh = [
+            '#!/bin/sh',
+            'sleep 2',
+            `kill -9 ${ppid} 2>/dev/null || true`,
+            `kill -9 ${pid} 2>/dev/null || true`,
+            `cd "${projectRoot}"`,
+            'pnpm install',
+            'pnpm start',
+        ].join('\n');
+        writeFileSync(scriptPath, sh, 'utf-8');
+    }
+    const child = spawn(isWin ? 'cmd' : '/bin/sh', isWin ? ['/c', scriptPath] : [scriptPath], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.unref();
+    setTimeout(() => {
+        try {
+            unlinkSync(scriptPath);
+        }
+        catch { }
+    }, 10_000);
+    res.json({ ok: true });
+});
+export default router;
+//# sourceMappingURL=version.js.map

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

package/dist/routes/workflow.js

@@ -1,18 +1,79 @@
 import { Router } from 'express';
-import * as workflowService from '../services/workflow.js';
+import * as ws from '../services/workflow.js';
 const router = Router();
+// ---- Workflow CRUD ----
 router.get('/', (_req, res) => {
     try {
-        const workflows = workflowService.listWorkflows();
+        const folderId = _req.query.folderId;
+        const workflows = ws.listWorkflows(folderId === 'null' ? null : folderId);
         res.json(workflows);
     }
     catch (error) {
         res.status(500).json({ error: error.message });
     }
 });
+// Static routes must be declared before /:workflowId.
+router.get('/folders', (_req, res) => {
+    try {
+        res.json(ws.listFolders());
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/folders', (req, res) => {
+    try {
+        const folder = ws.createFolder(req.body);
+        res.status(201).json(folder);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.put('/folders/:folderId', (req, res) => {
+    try {
+        ws.updateFolder(req.params.folderId, req.body);
+        const folders = ws.listFolders();
+        res.json(folders.find(f => f.id === req.params.folderId));
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/folders/:folderId', (req, res) => {
+    try {
+        ws.deleteFolder(req.params.folderId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.get('/execution-logs/all', (req, res) => {
+    try {
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 50;
+        res.json(ws.listAllExecutionLogs(limit));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/validate-cron', (req, res) => {
+    try {
+        const { cron } = req.body;
+        if (typeof cron !== 'string') {
+            res.status(400).json({ error: 'cron field is required' });
+            return;
+        }
+        res.json(ws.validateCron(cron));
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
 router.get('/:workflowId', (req, res) => {
     try {
-        const workflow = workflowService.getWorkflow(req.params.workflowId);
+        const workflow = ws.getWorkflow(req.params.workflowId);
         if (!workflow) {
             res.status(404).json({ error: 'Workflow not found' });
             return;
@@ -25,7 +86,7 @@ router.get('/:workflowId', (req, res) => {
 });
 router.post('/', (req, res) => {
     try {
-        const workflow = workflowService.createWorkflow(req.body);
+        const workflow = ws.createWorkflow(req.body);
         res.status(201).json(workflow);
     }
     catch (error) {
@@ -34,7 +95,7 @@ router.post('/', (req, res) => {
 });
 router.put('/:workflowId', (req, res) => {
     try {
-        const workflow = workflowService.updateWorkflow(req.params.workflowId, req.body);
+        const workflow = ws.updateWorkflow(req.params.workflowId, req.body);
         res.json(workflow);
     }
     catch (error) {
@@ -43,7 +104,7 @@ router.put('/:workflowId', (req, res) => {
 });
 router.delete('/:workflowId', (req, res) => {
     try {
-        workflowService.deleteWorkflow(req.params.workflowId);
+        ws.deleteWorkflow(req.params.workflowId);
         res.status(204).send();
     }
     catch (error) {
@@ -52,12 +113,226 @@ router.delete('/:workflowId', (req, res) => {
 });
 router.post('/:workflowId/duplicate', (req, res) => {
     try {
-        const workflow = workflowService.duplicateWorkflow(req.params.workflowId);
+        const workflow = ws.duplicateWorkflow(req.params.workflowId);
         res.status(201).json(workflow);
     }
     catch (error) {
         res.status(400).json({ error: error.message });
     }
 });
+// ---- Versions ----
+router.get('/:workflowId/versions', (req, res) => {
+    try {
+        res.json(ws.listVersions(req.params.workflowId));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/:workflowId/versions', (req, res) => {
+    try {
+        const version = ws.createVersion(req.params.workflowId, req.body?.name);
+        res.status(201).json(version);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.get('/:workflowId/versions/:versionId', (req, res) => {
+    try {
+        const version = ws.getVersion(req.params.workflowId, req.params.versionId);
+        if (!version) {
+            res.status(404).json({ error: 'Version not found' });
+            return;
+        }
+        res.json(version);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/versions/:versionId', (req, res) => {
+    try {
+        ws.deleteVersion(req.params.workflowId, req.params.versionId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/versions', (req, res) => {
+    try {
+        ws.clearVersions(req.params.workflowId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+// ---- Per-Workflow Execution Logs ----
+router.get('/:workflowId/execution-logs', (req, res) => {
+    try {
+        res.json(ws.listExecutionLogs(req.params.workflowId));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/:workflowId/execution-logs/:logId', (req, res) => {
+    try {
+        const log = ws.getExecutionLog(req.params.workflowId, req.params.logId);
+        if (!log) {
+            res.status(404).json({ error: 'Execution log not found' });
+            return;
+        }
+        res.json(log);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/execution-logs/:logId', (req, res) => {
+    try {
+        ws.deleteExecutionLog(req.params.workflowId, req.params.logId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/execution-logs', (req, res) => {
+    try {
+        ws.clearExecutionLogs(req.params.workflowId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+// ---- Staging ----
+router.get('/:workflowId/staging', (req, res) => {
+    try {
+        res.json(ws.loadStaging(req.params.workflowId));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.put('/:workflowId/staging', (req, res) => {
+    try {
+        ws.saveStaging(req.params.workflowId, req.body);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/staging', (req, res) => {
+    try {
+        ws.clearStaging(req.params.workflowId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+// ---- Operation History ----
+router.get('/:workflowId/operation-history', (req, res) => {
+    try {
+        res.json(ws.loadOperationHistory(req.params.workflowId));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.put('/:workflowId/operation-history', (req, res) => {
+    try {
+        ws.saveOperationHistory(req.params.workflowId, req.body);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/operation-history', (req, res) => {
+    try {
+        ws.clearOperationHistory(req.params.workflowId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+// ---- Workflow Agent Chat ----
+router.get('/:workflowId/chat', (req, res) => {
+    try {
+        res.json(ws.loadChat(req.params.workflowId));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.put('/:workflowId/chat', (req, res) => {
+    try {
+        ws.saveChat(req.params.workflowId, Array.isArray(req.body?.messages) ? req.body.messages : []);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/chat', (req, res) => {
+    try {
+        ws.clearChat(req.params.workflowId);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+// ---- Plugin Config Schemes ----
+router.get('/:workflowId/plugin-schemes/:pluginId', (req, res) => {
+    try {
+        res.json(ws.listPluginSchemes(req.params.workflowId, req.params.pluginId));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/:workflowId/plugin-schemes/:pluginId/:schemeName', (req, res) => {
+    try {
+        ws.createPluginScheme(req.params.workflowId, req.params.pluginId, req.params.schemeName);
+        res.status(201).json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.get('/:workflowId/plugin-schemes/:pluginId/:schemeName', (req, res) => {
+    try {
+        res.json(ws.readPluginScheme(req.params.workflowId, req.params.pluginId, req.params.schemeName));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.put('/:workflowId/plugin-schemes/:pluginId/:schemeName', (req, res) => {
+    try {
+        ws.savePluginScheme(req.params.workflowId, req.params.pluginId, req.params.schemeName, req.body || {});
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:workflowId/plugin-schemes/:pluginId/:schemeName', (req, res) => {
+    try {
+        ws.deletePluginScheme(req.params.workflowId, req.params.pluginId, req.params.schemeName);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
 export default router;
 //# sourceMappingURL=workflow.js.map

package/dist/routes/workspace.js

@@ -1,6 +1,8 @@
 import { Router } from 'express';
+import { join } from 'node:path';
 import { exec } from 'child_process';
 import * as wsService from '../services/workspace.js';
+import { getDataDir } from '../storage/json-store.js';
 import * as agentService from '../services/agent.js';
 import { readWorkspacePrompt, writeWorkspacePrompt } from '../services/workspace-prompt.js';
 import { getWeChatLoginQRCode, pollWeChatLoginStatus, sendTestNotification, startWorkspaceNotificationService, stopWorkspaceNotificationService, } from '../services/notification-hub/index.js';
@@ -148,10 +150,17 @@ router.post('/:id/reveal', (req, res) => {
         res.status(404).json({ error: 'Workspace not found' });
         return;
     }
-    const dir = ws.boundDirs?.[0];
-    if (!dir) {
-        res.status(400).json({ error: 'Workspace has no bound directory' });
-        return;
+    const target = req.query.target;
+    let dir;
+    if (target === 'data') {
+        dir = join(getDataDir(), 'workspaces', ws.id);
+    }
+    else {
+        dir = ws.boundDirs?.[0];
+        if (!dir) {
+            res.status(400).json({ error: 'Workspace has no bound directory' });
+            return;
+        }
     }
     console.log('[reveal:workspace] workspace:', ws.id, 'dir:', dir);
     const cmd = process.platform === 'darwin'

package/dist/routes/worktree.js

@@ -0,0 +1,93 @@
+import { Router } from 'express';
+import { z } from 'zod';
+import { listWorkspaceWorktrees, getWorkspaceWorktree, createWorkspaceWorktree, deleteWorkspaceWorktree, getWorktreeDiff, createWorktreePR, mergeWorktreePR, getWorktreePRDraft, } from '../services/worktree.js';
+export const worktreeRouter = Router({ mergeParams: true });
+const createSchema = z.object({
+    name: z.string().min(1),
+    branch: z.string().optional(),
+    agentId: z.string().optional(),
+    issueId: z.string().optional(),
+    taskId: z.string().optional(),
+});
+const prSchema = z.object({
+    title: z.string().optional(),
+    body: z.string().optional(),
+});
+const prDraftSchema = z.object({
+    title: z.string().optional(),
+});
+worktreeRouter.get('/', (req, res) => {
+    const { id } = req.params;
+    res.json(listWorkspaceWorktrees(id));
+});
+worktreeRouter.post('/', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const input = createSchema.parse(req.body);
+        const info = await createWorkspaceWorktree(id, input);
+        res.status(201).json(info);
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.get('/:wtId', (req, res) => {
+    const { id, wtId } = req.params;
+    const info = getWorkspaceWorktree(id, wtId);
+    if (!info)
+        return res.status(404).json({ error: 'Worktree not found' });
+    res.json(info);
+});
+worktreeRouter.delete('/:wtId', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        await deleteWorkspaceWorktree(id, wtId);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.get('/:wtId/diff', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        const diffs = await getWorktreeDiff(id, wtId);
+        res.json(diffs);
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.post('/:wtId/pr', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        const { title, body } = prSchema.parse(req.body);
+        const prUrl = await createWorktreePR(id, wtId, title, body);
+        res.json({ prUrl });
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.post('/:wtId/pr/draft', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        const { title } = prDraftSchema.parse(req.body);
+        const draft = await getWorktreePRDraft(id, wtId, title);
+        res.json(draft);
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.post('/:wtId/merge', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        await mergeWorktreePR(id, wtId);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+//# sourceMappingURL=worktree.js.map