@agent-spaces/server 0.3.64 → 0.3.65

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/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

package/dist/services/agent.js

@@ -3,7 +3,7 @@ import { copyFileSync, cpSync, existsSync, readFileSync, readdirSync, rmSync, st
 import { basename, extname, isAbsolute, join, normalize, relative } from 'node:path';
 import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
 import { listAgentSessions, getAgentSession, createAgentSession, updateAgentSession, deleteAgentSession, getAgentUsageDashboard, recordAgentUsage, } from '../storage/agent-store.js';
-import { getWorkspace } from '../storage/workspace-store.js';
+import { getWorkspace, listWorkspaces } from '../storage/workspace-store.js';
 import { listIssues, updateIssue } from '../storage/issue-store.js';
 import { listChannels, updateChannel } from './channel.js';
 import { ensureDir, getDataDir } from '../storage/json-store.js';
@@ -13,6 +13,7 @@ export const AGENT_GENERATOR_PRESET_ID = 'agent-generator';
 export const AGENT_COMMIT_PRESET_ID = 'commit-agent';
 const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain'];
 const VALID_TOOL_NAMES = new Set(BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
+const CLAUDE_BUILT_IN_DIRS = ['agents', 'commands'];
 const ANTHROPIC_BRIDGE_PROVIDERS = [
     'openai-responses-to-anthropic-messages',
     'openai-chat-completions-to-anthropic-messages',
@@ -338,6 +339,20 @@ export function getAgentConfigDir(workspaceId, preset) {
     ensureWorkspaceAgentCopy(preset, ws.agentspaceDir);
     return workspaceAgentDir;
 }
+export function syncTemplatesToAllWorkspaces() {
+    const templates = listTemplates().filter((template) => existsSync(getGlobalAgentTemplateDir(template.id)));
+    const workspaces = listWorkspaces();
+    let agents = 0;
+    for (const workspace of workspaces) {
+        if (!workspace.agentspaceDir)
+            continue;
+        for (const template of templates) {
+            writeWorkspaceAgentCopy(template, workspace.agentspaceDir);
+            agents++;
+        }
+    }
+    return { workspaces: workspaces.length, agents };
+}
 export function getAvailableSkillNames(agentDir, skills) {
     if (!agentDir || !Array.isArray(skills))
         return [];
@@ -541,10 +556,29 @@ function writeWorkspaceAgentCopy(preset, agentspaceDir) {
 function ensureWorkspaceAgentCopy(preset, agentspaceDir) {
     const workspaceAgentDir = getWorkspaceAgentDir(agentspaceDir, preset.id);
     const requiredFiles = ['agent.json', 'mcp.json'];
-    if (requiredFiles.every((file) => existsSync(join(workspaceAgentDir, file))))
+    const sourceDir = getGlobalAgentTemplateDir(preset.id);
+    const missingRequiredFile = requiredFiles.some((file) => !existsSync(join(workspaceAgentDir, file)));
+    const missingBuiltInDir = CLAUDE_BUILT_IN_DIRS.some((dir) => {
+        const sourceBuiltInDir = join(sourceDir, dir);
+        const targetBuiltInDir = join(workspaceAgentDir, dir);
+        return existsSync(sourceBuiltInDir)
+            && statSync(sourceBuiltInDir).isDirectory()
+            && countFiles(sourceBuiltInDir) > countFiles(targetBuiltInDir);
+    });
+    if (!missingRequiredFile && !missingBuiltInDir)
         return;
     writeWorkspaceAgentCopy(preset, agentspaceDir);
 }
+function countFiles(dir) {
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+        return 0;
+    return readdirSync(dir, { withFileTypes: true }).reduce((count, entry) => {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory())
+            return count + countFiles(fullPath);
+        return entry.isFile() ? count + 1 : count;
+    }, 0);
+}
 export function readAgentTemplate(agentId) {
     const filePath = join(getGlobalAgentTemplateDir(agentId), 'agent.json');
     if (!existsSync(filePath)) {