@agent-spaces/server 0.3.64 → 0.3.67

package/dist/routes/version.js

@@ -0,0 +1,94 @@
+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 isDev = !process.env.NODE_ENV || process.env.NODE_ENV === 'development';
+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/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

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';
@@ -11,8 +11,9 @@ import { extractUsageFromOutput } from '../storage/usage.js';
 const DEFAULT_AGENT_ROLE = 'agent';
 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_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain', 'hermes'];
 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)) {

package/dist/services/builtin-tools/kanban-tools.js

@@ -1,5 +1,6 @@
 import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
 import * as kanbanStore from '../../storage/kanban-store.js';
+import { broadcastToWorkspace } from '../../ws/connection-manager.js';
 import { assertRecord, readOptionalString, readRequiredString, readString } from './input-helpers.js';
 const kanbanLayoutModes = ['horizontal', 'vertical'];
 const kanbanPriorities = ['low', 'medium', 'high'];
@@ -158,6 +159,7 @@ function createKanbanBoard(workspaceId, input) {
     const created = kanbanStore.getBoard(workspaceId);
     if (!created)
         throw new Error('Failed to create Kanban board.');
+    broadcastToWorkspace(workspaceId, 'kanban.updated', created);
     return created;
 }
 function updateKanbanBoard(workspaceId, input) {
@@ -185,6 +187,7 @@ function updateKanbanBoard(workspaceId, input) {
     const updated = kanbanStore.listBoards(workspaceId).find((item) => item.id === board.id);
     if (!updated)
         throw new Error(`Kanban board not found: ${board.id}`);
+    broadcastToWorkspace(workspaceId, 'kanban.updated', updated);
     return updated;
 }
 function deleteKanbanBoard(workspaceId, input) {
@@ -193,6 +196,7 @@ function deleteKanbanBoard(workspaceId, input) {
     const ok = kanbanStore.deleteBoard(workspaceId, board.id);
     if (!ok)
         throw new Error(`Kanban board not found: ${board.id}`);
+    broadcastToWorkspace(workspaceId, 'kanban.deleted', { boardId: board.id });
     return { ok: true, deletedBoardId: board.id };
 }
 function resolveKanbanBoard(workspaceId, boardId) {

package/dist/services/git-operation-log.js

@@ -0,0 +1,40 @@
+const MAX_ENTRIES = 1000;
+const store = new Map();
+function getList(workspaceId) {
+    let list = store.get(workspaceId);
+    if (!list) {
+        list = [];
+        store.set(workspaceId, list);
+    }
+    return list;
+}
+let counter = 0;
+export function logGitOperation(workspaceId, operation, input, result, error, duration = 0) {
+    const list = getList(workspaceId);
+    const entry = {
+        id: `${Date.now()}-${++counter}`,
+        operation,
+        input,
+        output: truncateOutput(result),
+        error,
+        timestamp: new Date().toISOString(),
+        duration,
+    };
+    list.unshift(entry);
+    if (list.length > MAX_ENTRIES)
+        list.length = MAX_ENTRIES;
+}
+export function getGitOperations(workspaceId) {
+    return getList(workspaceId);
+}
+function truncateOutput(value) {
+    if (value === undefined || value === null)
+        return value;
+    if (typeof value === 'string')
+        return value.length > 5000 ? value.slice(0, 5000) + '...(truncated)' : value;
+    const s = JSON.stringify(value);
+    if (s && s.length > 5000)
+        return JSON.parse(s.slice(0, 5000) + '...(truncated)');
+    return value;
+}
+//# sourceMappingURL=git-operation-log.js.map

package/dist/services/global-wechat-qr.js

@@ -0,0 +1,72 @@
+import { WECHAT_BASE_URL, WECHAT_BOT_TYPE, WECHAT_QR_STATUS_TIMEOUT_MS, } from './notification-hub/types.js';
+import { createAccount } from './robot-account.js';
+const globalSessions = new Map();
+export async function getGlobalWeChatQRCode() {
+    // cleanup old sessions
+    const now = Date.now();
+    for (const [key, s] of globalSessions) {
+        if (now - s.createdAt > 5 * 60_000)
+            globalSessions.delete(key);
+    }
+    const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_bot_qrcode?bot_type=${WECHAT_BOT_TYPE}`);
+    if (!res.ok)
+        throw new Error(`Failed to get WeChat QR code: ${res.status}`);
+    const qr = await res.json();
+    const sessionId = `global-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    globalSessions.set(sessionId, {
+        qrcode: qr.qrcode,
+        qrcodeImgContent: qr.qrcode_img_content,
+        createdAt: now,
+    });
+    return { status: 'wait', qrcodeImgContent: qr.qrcode_img_content, sessionId };
+}
+export async function pollGlobalWeChatQRCode(sessionId) {
+    if (!sessionId)
+        throw new Error('sessionId is required');
+    const session = globalSessions.get(sessionId);
+    if (!session)
+        throw new Error('Session not found or expired');
+    const status = await fetchQRStatus(session.qrcode);
+    if (status.status === 'confirmed') {
+        if (!status.bot_token || !status.ilink_bot_id) {
+            throw new Error('WeChat login confirmed but token or bot id is missing');
+        }
+        globalSessions.delete(sessionId);
+        const account = createAccount({
+            name: `微信 ${status.ilink_bot_id}`,
+            type: 'wechat',
+            wechat: {
+                token: status.bot_token,
+                baseUrl: status.baseurl || WECHAT_BASE_URL,
+                accountId: status.ilink_bot_id,
+                userId: status.ilink_user_id,
+            },
+        });
+        return { status: 'confirmed', account };
+    }
+    if (status.status === 'expired') {
+        globalSessions.delete(sessionId);
+    }
+    return { status: status.status, qrcodeImgContent: session.qrcodeImgContent, sessionId };
+}
+async function fetchQRStatus(qrcode) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), WECHAT_QR_STATUS_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, {
+            headers: { 'iLink-App-ClientVersion': '1' },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            throw new Error(`Failed to poll QR status: ${res.status}`);
+        return await res.json();
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === 'AbortError')
+            return { status: 'wait' };
+        throw err;
+    }
+}
+//# sourceMappingURL=global-wechat-qr.js.map