@agent-spaces/server 0.3.64 → 0.3.67

package/dist/routes/agent-sse.js

@@ -67,6 +67,7 @@ router.post('/run', async (req, res) => {
         agentService.updateStatus(workspaceId, session.id, 'active');
         writeSse(res, 'status', { agentId: session.id, status: 'active' });
         const result = await runtime.execute(buildAgentPrompt(workspaceId, body.systemPrompt ?? preset.systemPrompt, userPrompt, normalizeMessages(body.messages), {
+            runtimeKind: preset.runtimeKind,
             mcpServers: Object.keys(mcpServers ?? {}),
             skills,
             boundDirs: workspace.boundDirs,
@@ -79,6 +80,7 @@ router.post('/run', async (req, res) => {
             skills,
             configDir,
             sandboxDirs: preset.sandboxDirs,
+            userPrompt,
             outputStyle: body.outputStyle ?? preset.outputStyle,
             onEvent: wrapOnEventWithHooks((event) => {
                 if (event.type === 'output')

package/dist/routes/agent.js

@@ -22,6 +22,9 @@ router.post('/presets', (req, res) => {
     const preset = agentService.createPreset(req.params.id, body);
     res.status(201).json(preset);
 });
+router.post('/presets/sync-workspaces', (_req, res) => {
+    res.json(agentService.syncTemplatesToAllWorkspaces());
+});
 router.post('/presets/generate', async (req, res) => {
     const { prompt } = req.body;
     if (!prompt?.trim()) {

package/dist/routes/database.js

@@ -84,6 +84,7 @@ router.post('/chat', async (req, res) => {
     });
     const result = await runtime.execute(buildDatabaseAgentPrompt(workspaceId, agent, prompt, history ?? []), workingDir, {
         maxTurns: 60,
+        userPrompt: prompt,
         functionTools,
         mcpServers: {},
         skills: [],

package/dist/routes/git.js

@@ -1,325 +1,205 @@
 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 { logGitOperation, getGitOperations } from '../services/git-operation-log.js';
 const router = Router({ mergeParams: true });
-router.get('/status', async (req, res) => {
-    try {
-        const result = await gitStatus(req.params.id);
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.get('/diff', async (req, res) => {
-    try {
-        const filePath = req.query.path;
-        const result = await gitDiff(req.params.id, filePath);
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.get('/log', async (req, res) => {
-    try {
-        const maxCount = parseInt(req.query.maxCount) || 50;
-        const result = await gitLog(req.params.id, maxCount);
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/commit', async (req, res) => {
-    try {
-        const { message } = req.body;
-        if (!message) {
-            res.status(400).json({ error: 'message is required' });
-            return;
-        }
-        const result = await gitCommit(req.params.id, message);
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/discard', async (req, res) => {
-    try {
-        const { path } = req.body;
-        if (!path) {
-            res.status(400).json({ error: 'path is required' });
-            return;
-        }
-        await gitDiscard(req.params.id, path);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/discard-all', async (req, res) => {
-    try {
-        await gitDiscardAll(req.params.id);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        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);
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/checkout', async (req, res) => {
-    try {
-        const { branch } = req.body;
-        if (!branch) {
-            res.status(400).json({ error: 'branch is required' });
-            return;
-        }
-        await gitCheckout(req.params.id, branch);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/init', async (req, res) => {
-    try {
-        await gitInit(req.params.id);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/generate-commit-message', async (req, res) => {
-    try {
-        const message = await gitGenerateCommitMsg(req.params.id);
-        res.json({ message });
-    }
-    catch (err) {
-        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);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/pull', async (req, res) => {
-    try {
-        await gitPull(req.params.id);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.get('/remotes', async (req, res) => {
-    try {
-        const remotes = await gitGetRemotes(req.params.id);
-        res.json(remotes);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/remotes', async (req, res) => {
-    try {
-        const { name, url } = req.body;
-        if (!name || !url) {
-            res.status(400).json({ error: 'name and url are required' });
-            return;
-        }
-        await gitAddRemote(req.params.id, name, url);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/checkout-detached', async (req, res) => {
-    try {
-        const { commitHash } = req.body;
-        if (!commitHash) {
-            res.status(400).json({ error: 'commitHash is required' });
-            return;
-        }
-        await gitCheckoutDetached(req.params.id, commitHash);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/cherry-pick', async (req, res) => {
-    try {
-        const { commitHash } = req.body;
-        if (!commitHash) {
-            res.status(400).json({ error: 'commitHash is required' });
-            return;
+function withLog(operation, inputFn, handler) {
+    return async (req, res) => {
+        const input = inputFn(req);
+        const start = Date.now();
+        try {
+            await handler(req, res);
+            const ok = res.statusCode < 400;
+            logGitOperation(req.params.id, operation, input, ok ? { ok: true } : { statusCode: res.statusCode }, ok ? undefined : 'request validation failed', Date.now() - start);
         }
-        await gitCherryPick(req.params.id, commitHash);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/create-branch', async (req, res) => {
-    try {
-        const { name, startPoint } = req.body;
-        if (!name) {
-            res.status(400).json({ error: 'name is required' });
-            return;
+        catch (err) {
+            logGitOperation(req.params.id, operation, input, undefined, err.message, Date.now() - start);
+            if (!res.headersSent)
+                res.status(500).json({ error: err.message });
         }
-        await gitCreateBranch(req.params.id, name, startPoint);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/delete-branch', async (req, res) => {
-    try {
-        const { name, force } = req.body;
-        if (!name) {
-            res.status(400).json({ error: 'name is required' });
-            return;
-        }
-        await gitDeleteBranch(req.params.id, name, force);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/create-tag', async (req, res) => {
-    try {
-        const { name, commitHash } = req.body;
-        if (!name) {
-            res.status(400).json({ error: 'name is required' });
-            return;
-        }
-        await gitCreateTag(req.params.id, name, commitHash);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.get('/commit-diff', async (req, res) => {
-    try {
-        const hash = req.query.hash;
-        if (!hash) {
-            res.status(400).json({ error: 'hash is required' });
-            return;
-        }
-        const diffs = await gitCommitDiff(req.params.id, hash);
-        res.json(diffs);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.get('/remote-url', async (req, res) => {
-    try {
-        const url = await gitGetRemoteUrl(req.params.id);
-        res.json({ url });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.get('/merge-base', async (req, res) => {
-    try {
-        const hash = await gitMergeBase(req.params.id);
-        res.json({ hash });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.get('/config', async (req, res) => {
-    try {
-        const config = await gitGetConfig('local', req.params.id);
-        res.json(config);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-router.post('/config', async (req, res) => {
-    try {
-        const { name, email, proxy } = req.body;
-        await gitSetConfig('local', { name, email, proxy }, req.params.id);
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    };
+}
+router.get('/status', withLog('status', () => ({}), async (req, res) => {
+    const result = await gitStatus(req.params.id);
+    res.json(result);
+}));
+router.get('/diff', withLog('diff', (req) => ({ path: req.query.path }), async (req, res) => {
+    const filePath = req.query.path;
+    const result = await gitDiff(req.params.id, filePath);
+    res.json(result);
+}));
+router.get('/log', withLog('log', (req) => ({ maxCount: req.query.maxCount }), async (req, res) => {
+    const maxCount = parseInt(req.query.maxCount) || 50;
+    const result = await gitLog(req.params.id, maxCount);
+    res.json(result);
+}));
+router.post('/commit', withLog('commit', (req) => ({ message: req.body?.message }), async (req, res) => {
+    const { message } = req.body;
+    if (!message) {
+        res.status(400).json({ error: 'message is required' });
+        return;
+    }
+    const result = await gitCommit(req.params.id, message);
+    res.json(result);
+}));
+router.post('/discard', withLog('discard', (req) => ({ path: req.body?.path }), async (req, res) => {
+    const { path } = req.body;
+    if (!path) {
+        res.status(400).json({ error: 'path is required' });
+        return;
+    }
+    await gitDiscard(req.params.id, path);
+    res.json({ ok: true });
+}));
+router.post('/discard-all', withLog('discard-all', () => ({}), async (req, res) => {
+    await gitDiscardAll(req.params.id);
+    res.json({ ok: true });
+}));
+router.post('/stage', withLog('stage', (req) => ({ path: req.body?.path }), async (req, res) => {
+    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 });
+}));
+router.post('/unstage', withLog('unstage', (req) => ({ path: req.body?.path }), async (req, res) => {
+    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 });
+}));
+router.post('/resolve-file', withLog('resolve-file', (req) => ({ path: req.body?.path }), async (req, res) => {
+    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 });
+}));
+router.get('/branches', withLog('branches', () => ({}), async (req, res) => {
+    const result = await gitBranches(req.params.id);
+    res.json(result);
+}));
+router.post('/checkout', withLog('checkout', (req) => ({ branch: req.body?.branch }), async (req, res) => {
+    const { branch } = req.body;
+    if (!branch) {
+        res.status(400).json({ error: 'branch is required' });
+        return;
+    }
+    await gitCheckout(req.params.id, branch);
+    res.json({ ok: true });
+}));
+router.post('/init', withLog('init', () => ({}), async (req, res) => {
+    await gitInit(req.params.id);
+    res.json({ ok: true });
+}));
+router.post('/generate-commit-message', withLog('generate-commit-message', () => ({}), async (req, res) => {
+    const message = await gitGenerateCommitMsg(req.params.id);
+    res.json({ message });
+}));
+router.post('/fetch', withLog('fetch', () => ({}), async (req, res) => {
+    await gitFetch(req.params.id);
+    res.json({ ok: true });
+}));
+router.post('/push', withLog('push', () => ({}), async (req, res) => {
+    await gitPush(req.params.id);
+    res.json({ ok: true });
+}));
+router.post('/pull', withLog('pull', () => ({}), async (req, res) => {
+    await gitPull(req.params.id);
+    res.json({ ok: true });
+}));
+router.get('/remotes', withLog('remotes', () => ({}), async (req, res) => {
+    const remotes = await gitGetRemotes(req.params.id);
+    res.json(remotes);
+}));
+router.post('/remotes', withLog('add-remote', (req) => ({ name: req.body?.name, url: req.body?.url }), async (req, res) => {
+    const { name, url } = req.body;
+    if (!name || !url) {
+        res.status(400).json({ error: 'name and url are required' });
+        return;
+    }
+    await gitAddRemote(req.params.id, name, url);
+    res.json({ ok: true });
+}));
+router.post('/checkout-detached', withLog('checkout-detached', (req) => ({ commitHash: req.body?.commitHash }), async (req, res) => {
+    const { commitHash } = req.body;
+    if (!commitHash) {
+        res.status(400).json({ error: 'commitHash is required' });
+        return;
+    }
+    await gitCheckoutDetached(req.params.id, commitHash);
+    res.json({ ok: true });
+}));
+router.post('/cherry-pick', withLog('cherry-pick', (req) => ({ commitHash: req.body?.commitHash }), async (req, res) => {
+    const { commitHash } = req.body;
+    if (!commitHash) {
+        res.status(400).json({ error: 'commitHash is required' });
+        return;
+    }
+    await gitCherryPick(req.params.id, commitHash);
+    res.json({ ok: true });
+}));
+router.post('/create-branch', withLog('create-branch', (req) => ({ name: req.body?.name, startPoint: req.body?.startPoint }), async (req, res) => {
+    const { name, startPoint } = req.body;
+    if (!name) {
+        res.status(400).json({ error: 'name is required' });
+        return;
+    }
+    await gitCreateBranch(req.params.id, name, startPoint);
+    res.json({ ok: true });
+}));
+router.post('/delete-branch', withLog('delete-branch', (req) => ({ name: req.body?.name, force: req.body?.force }), async (req, res) => {
+    const { name, force } = req.body;
+    if (!name) {
+        res.status(400).json({ error: 'name is required' });
+        return;
+    }
+    await gitDeleteBranch(req.params.id, name, force);
+    res.json({ ok: true });
+}));
+router.post('/create-tag', withLog('create-tag', (req) => ({ name: req.body?.name, commitHash: req.body?.commitHash }), async (req, res) => {
+    const { name, commitHash } = req.body;
+    if (!name) {
+        res.status(400).json({ error: 'name is required' });
+        return;
+    }
+    await gitCreateTag(req.params.id, name, commitHash);
+    res.json({ ok: true });
+}));
+router.get('/commit-diff', withLog('commit-diff', (req) => ({ hash: req.query.hash }), async (req, res) => {
+    const hash = req.query.hash;
+    if (!hash) {
+        res.status(400).json({ error: 'hash is required' });
+        return;
+    }
+    const diffs = await gitCommitDiff(req.params.id, hash);
+    res.json(diffs);
+}));
+router.get('/remote-url', withLog('remote-url', () => ({}), async (req, res) => {
+    const url = await gitGetRemoteUrl(req.params.id);
+    res.json({ url });
+}));
+router.get('/merge-base', withLog('merge-base', () => ({}), async (req, res) => {
+    const hash = await gitMergeBase(req.params.id);
+    res.json({ hash });
+}));
+router.get('/config', withLog('config.get', () => ({}), async (req, res) => {
+    const config = await gitGetConfig('local', req.params.id);
+    res.json(config);
+}));
+router.post('/config', withLog('config.set', (req) => ({ name: req.body?.name, email: req.body?.email, proxy: req.body?.proxy }), async (req, res) => {
+    const { name, email, proxy } = req.body;
+    await gitSetConfig('local', { name, email, proxy }, req.params.id);
+    res.json({ ok: true });
+}));
+router.get('/operations', (req, res) => {
+    res.json(getGitOperations(req.params.id));
 });
 export default router;
 //# sourceMappingURL=git.js.map

package/dist/routes/issue.js

@@ -313,7 +313,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

package/dist/routes/robot-account.js

@@ -0,0 +1,68 @@
+import { Router } from 'express';
+import { listRobotAccounts, createAccount, updateAccount, deleteRobotAccount } from '../services/robot-account.js';
+import { getGlobalWeChatQRCode, pollGlobalWeChatQRCode } from '../services/global-wechat-qr.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(listRobotAccounts());
+});
+router.post('/', (req, res) => {
+    const { name, type, lark, wechat } = req.body;
+    if (!name || !type) {
+        res.status(400).json({ error: 'name and type are required' });
+        return;
+    }
+    if (!['lark', 'wechat'].includes(type)) {
+        res.status(400).json({ error: 'type must be lark or wechat' });
+        return;
+    }
+    if (type === 'lark' && (!lark?.appId || !lark?.appSecret)) {
+        res.status(400).json({ error: 'lark.appId and lark.appSecret are required' });
+        return;
+    }
+    if (type === 'wechat' && (!wechat?.token || !wechat?.accountId)) {
+        res.status(400).json({ error: 'wechat.token and wechat.accountId are required' });
+        return;
+    }
+    const account = createAccount({ name, type, lark, wechat });
+    res.status(201).json(account);
+});
+router.put('/:id', (req, res) => {
+    const { id } = req.params;
+    const { name, lark, wechat } = req.body;
+    const updated = updateAccount(id, { name, lark, wechat });
+    if (!updated) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json(updated);
+});
+router.delete('/:id', (req, res) => {
+    const deleted = deleteRobotAccount(req.params.id);
+    if (!deleted) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json({ ok: true });
+});
+// Global WeChat QR login (not bound to a workspace)
+router.post('/wechat/qr', async (_req, res) => {
+    try {
+        const result = await getGlobalWeChatQRCode();
+        res.json(result);
+    }
+    catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : 'Failed to get WeChat QR code' });
+    }
+});
+router.post('/wechat/qr/poll', async (req, res) => {
+    try {
+        const { sessionId } = req.body;
+        const result = await pollGlobalWeChatQRCode(sessionId);
+        res.json(result);
+    }
+    catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : 'Failed to poll WeChat QR status' });
+    }
+});
+export default router;
+//# sourceMappingURL=robot-account.js.map