@agent-spaces/server 0.3.64 → 0.3.67

package/dist/adapters/hermes-runtime.js

@@ -0,0 +1,210 @@
+import { spawn } from 'node:child_process';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
+/**
+ * Runtime backed by the external Hermes CLI.
+ *
+ * Hermes does not currently expose a structured JS SDK here, so this adapter
+ * treats verbose CLI output as the source of truth and streams it as text.
+ */
+export class HermesRuntime {
+    config;
+    child = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async execute(prompt, workingDir, options) {
+        const output = [];
+        const cwd = workingDir || process.cwd();
+        const startTime = Date.now();
+        const d = (message) => console.log(`[hermes] ${message}`);
+        const agentDir = options?.configDir;
+        const hermesHome = agentDir ? join(agentDir, '.hermes') : undefined;
+        if (hermesHome)
+            prepareHermesHome(hermesHome, agentDir);
+        const args = buildHermesArgs(appendOutputStyleToPrompt(prompt, options?.outputStyle), this.config, options);
+        d(`starting | cwd=${cwd} model=${this.config.model ?? 'profile-default'} provider=${this.config.provider ?? 'profile-default'} hermesHome=${hermesHome ?? 'default'} skills=${options?.skills?.join(',') || '-'}`);
+        return new Promise((resolve) => {
+            let settled = false;
+            let stdoutBuffer = '';
+            let stderrBuffer = '';
+            let sessionId = options?.resumeSessionId;
+            let emittedSessionId = sessionId;
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.child = null;
+                resolve(result);
+            };
+            try {
+                this.child = spawn('hermes', args, {
+                    cwd,
+                    env: buildEnv(this.config, hermesHome),
+                    windowsHide: true,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                d(`failed to start | ${message}`);
+                finish({
+                    success: false,
+                    summary: 'Hermes execution failed',
+                    artifacts: [],
+                    error: message,
+                    output,
+                    sessionId,
+                });
+                return;
+            }
+            this.child.stdout.setEncoding('utf-8');
+            this.child.stderr.setEncoding('utf-8');
+            this.child.stdout.on('data', (chunk) => {
+                stdoutBuffer = consumeLines(stdoutBuffer + chunk, (line) => {
+                    if (!line)
+                        return;
+                    output.push(line);
+                    const parsedSessionId = extractSessionId(line);
+                    if (parsedSessionId && parsedSessionId !== emittedSessionId) {
+                        sessionId = parsedSessionId;
+                        emittedSessionId = parsedSessionId;
+                        options?.onEvent?.({ type: 'session', sessionId });
+                    }
+                    options?.onEvent?.({ type: 'output', line });
+                });
+            });
+            this.child.stderr.on('data', (chunk) => {
+                stderrBuffer = consumeLines(stderrBuffer + chunk, (line) => {
+                    if (!line)
+                        return;
+                    const formatted = `[stderr] ${line}`;
+                    output.push(formatted);
+                    options?.onEvent?.({ type: 'output', line: formatted });
+                });
+            });
+            this.child.on('error', (err) => {
+                const message = err.message.includes('ENOENT')
+                    ? 'Hermes CLI was not found. Install Hermes and ensure the `hermes` command is available on PATH.'
+                    : err.message;
+                d(`failed ${Date.now() - startTime}ms | ${message}`);
+                finish({
+                    success: false,
+                    summary: 'Hermes execution failed',
+                    artifacts: [],
+                    error: message,
+                    output,
+                    sessionId,
+                });
+            });
+            this.child.on('close', (code, signal) => {
+                stdoutBuffer = flushLine(stdoutBuffer, output, options);
+                stderrBuffer = flushLine(stderrBuffer, output, options, '[stderr] ');
+                const elapsed = Date.now() - startTime;
+                if (code === 0) {
+                    const text = lastMeaningfulLine(output);
+                    d(`done ${elapsed}ms`);
+                    finish({
+                        success: true,
+                        summary: summarizeResult(text),
+                        artifacts: [],
+                        output,
+                        sessionId,
+                    });
+                    return;
+                }
+                const error = signal
+                    ? `Hermes execution stopped by signal ${signal}`
+                    : `Hermes execution failed with exit code ${code ?? 'unknown'}`;
+                d(`failed ${elapsed}ms | ${error}`);
+                finish({
+                    success: false,
+                    summary: 'Hermes execution failed',
+                    artifacts: [],
+                    error,
+                    output,
+                    sessionId,
+                });
+            });
+        });
+    }
+    stop() {
+        this.child?.kill();
+    }
+}
+function buildHermesArgs(prompt, config, options) {
+    const args = ['chat', '-q', prompt, '--verbose'];
+    for (const skill of normalizeSkillNames(options?.skills))
+        args.push('-s', skill);
+    if (config.model)
+        args.push('--model', config.model);
+    if (config.provider)
+        args.push('--provider', String(config.provider));
+    return args;
+}
+function buildEnv(config, hermesHome) {
+    const apiKey = config.apiKey || process.env.HERMES_API_KEY || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY;
+    return {
+        ...process.env,
+        HERMES_HOME: hermesHome || process.env.HERMES_HOME,
+        HERMES_API_KEY: apiKey,
+        HERMES_BASE_URL: config.baseURL || process.env.HERMES_BASE_URL,
+        OPENAI_API_KEY: config.apiKey || process.env.OPENAI_API_KEY,
+        OPENAI_BASE_URL: config.baseURL || process.env.OPENAI_BASE_URL,
+        ANTHROPIC_API_KEY: config.apiKey || process.env.ANTHROPIC_API_KEY,
+        NO_COLOR: process.env.NO_COLOR || '1',
+    };
+}
+function prepareHermesHome(hermesHome, agentDir) {
+    mkdirSync(hermesHome, { recursive: true });
+    const skillsDir = join(hermesHome, 'skills');
+    rmSync(skillsDir, { recursive: true, force: true });
+    mkdirSync(skillsDir, { recursive: true });
+    if (!agentDir)
+        return;
+    const sourceSkillsDir = join(agentDir, 'skills');
+    if (!existsSync(sourceSkillsDir))
+        return;
+    for (const file of readdirSync(sourceSkillsDir)) {
+        if (extname(file).toLowerCase() !== '.md')
+            continue;
+        const sourceFile = join(sourceSkillsDir, file);
+        if (!statSync(sourceFile).isFile())
+            continue;
+        copyFileSync(sourceFile, join(skillsDir, basename(file)));
+    }
+}
+function consumeLines(buffer, onLine) {
+    const lines = buffer.split(/\r?\n/);
+    const remainder = lines.pop() ?? '';
+    for (const line of lines)
+        onLine(stripAnsi(line).trimEnd());
+    return remainder;
+}
+function flushLine(buffer, output, options, prefix = '') {
+    const line = stripAnsi(buffer).trimEnd();
+    if (line) {
+        const formatted = `${prefix}${line}`;
+        output.push(formatted);
+        options?.onEvent?.({ type: 'output', line: formatted });
+    }
+    return '';
+}
+function extractSessionId(line) {
+    const match = line.match(/\bsession(?:\s+id)?\s*[:=]\s*([a-zA-Z0-9._:-]+)/i);
+    return match?.[1];
+}
+function normalizeSkillNames(skills) {
+    if (!Array.isArray(skills))
+        return [];
+    return skills
+        .map((skill) => basename(skill).replace(/\.md$/i, '').trim())
+        .filter(Boolean);
+}
+function lastMeaningfulLine(output) {
+    return [...output].reverse().find((line) => line.trim() && !line.startsWith('[stderr]')) ?? '';
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, '');
+}
+//# sourceMappingURL=hermes-runtime.js.map

package/dist/agents/agent-message-parts.js

@@ -41,7 +41,7 @@ export function createAgentMessagePartsTracker(input) {
                 }
                 return;
             }
-            if (event.type === 'session')
+            if (event.type === 'session' || event.type === 'hook_event')
                 return;
             output.push(event.line);
             input.onOutput?.(event.line);

package/dist/agents/commit-agent.js

@@ -27,13 +27,14 @@ export async function runCommitAgent(workspaceId) {
     const workingDir = agentService.resolveWorkingDir(workspaceId, commitAgent);
     const systemPrompt = commitAgent.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
     const truncatedDiff = diff.length > 8000 ? diff.substring(0, 8000) + '\n... (truncated)' : diff;
-    const result = await runtime.execute(prependPersistentAgentContext([
+    const userPrompt = [
         'Generate exactly one commit message for these changes.',
         'Do not inspect files or run commands. Use only this diff.',
         'Output only the commit message.',
         '',
         truncatedDiff,
-    ].join('\n'), {
+    ].join('\n');
+    const result = await runtime.execute(prependPersistentAgentContext(userPrompt, {
         workspaceId,
         workingDir,
         boundDirs: ws.boundDirs,
@@ -41,6 +42,7 @@ export async function runCommitAgent(workspaceId) {
         excludeNativeClaudeMd: commitAgent.runtimeKind === 'claude-code',
     }), workingDir, {
         maxTurns: 1,
+        userPrompt,
         systemPrompt,
         outputStyle: commitAgent.outputStyle,
     });

package/dist/agents/issue-task-controller.js

@@ -4,12 +4,13 @@ import * as channelService from '../services/channel.js';
 import * as issueService from '../services/issue.js';
 import * as taskService from '../services/task.js';
 import * as workspaceService from '../services/workspace.js';
-import { mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
+import { getWorkflow, mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
 import { createIssueFunctionTools } from '../services/builtin-tools/index.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
 import { wrapOnEventWithHooks } from '../services/hook-engine.js';
+import { executeCommandNode } from '../services/workflow-command-runner.js';
 const ACTIVE_TASK_STATUSES = ['running', 'reviewing', 'retrying', 'waiting_review'];
 const activeIssueRuntimes = new Map();
 export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, ctx) {
@@ -49,8 +50,10 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
         },
     });
     const runtime = createRuntimeForPreset(taskSyncPreset);
-    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskSyncPrompt(issue, input, taskSyncWorkingDir), taskSyncWorkingDir, taskSyncPreset), taskSyncWorkingDir, {
+    const taskSyncUserPrompt = buildTaskSyncPrompt(issue, input, taskSyncWorkingDir);
+    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, taskSyncUserPrompt, taskSyncWorkingDir, taskSyncPreset), taskSyncWorkingDir, {
         maxTurns: 20,
+        userPrompt: taskSyncUserPrompt,
         mcpServers: undefined,
         functionTools: createTaskSyncTools(workspaceId, issue, taskSyncPreset, ctx),
         skills: [],
@@ -135,6 +138,13 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     if (task.status !== 'pending') {
         return;
     }
+    // Check if this task came from a command workflow node
+    const workflow = findWorkflowForIssue(workspaceId, issue);
+    const commandNode = findCommandNodeForTask(workflow, task);
+    if (commandNode) {
+        await runCommandTask(workspaceId, issueId, taskId, commandNode, ctx);
+        return;
+    }
     const taskAgentPreset = findAgentForTask(workspaceId, issue, task);
     if (!taskAgentPreset) {
         if (issueService.getById(workspaceId, issueId)?.status === 'error')
@@ -199,8 +209,10 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     });
     let result;
     try {
-        result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
+        const taskUserPrompt = buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir);
+        result = await runtime.execute(buildIssueAgentPrompt(workspaceId, taskUserPrompt, agentWorkingDir, taskAgentPreset), agentWorkingDir, {
             maxTurns: 100,
+            userPrompt: taskUserPrompt,
             mcpServers: agentService.getMcpServers(taskAgentPreset.mcps),
             functionTools: createCurrentIssueTools(workspaceId, issue, taskAgentPreset),
             skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, taskAgentPreset), taskAgentPreset.skills),
@@ -270,6 +282,48 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
     }
 }
+async function runCommandTask(workspaceId, issueId, taskId, commandNode, ctx) {
+    const task = taskService.getById(workspaceId, taskId);
+    if (!task || task.status !== 'pending')
+        return;
+    const runningTask = taskService.updateStatus(workspaceId, taskId, 'running');
+    if (!runningTask)
+        return;
+    broadcastTaskUpdate(ctx, runningTask, 'pending');
+    ctx.broadcast('task.output', { taskId, data: `$ ${commandNode.data.script.split('\n')[0]}${commandNode.data.script.includes('\n') ? ' ...' : ''}` });
+    const result = await executeCommandNode(workspaceId, commandNode);
+    ctx.broadcast('task.output', { taskId, data: result.stdout });
+    if (result.stderr) {
+        ctx.broadcast('task.output', { taskId, data: result.stderr });
+    }
+    if (!result.success) {
+        const failedTask = taskService.updateStatus(workspaceId, taskId, 'failed', {
+            result: {
+                success: false,
+                summary: `Command failed with exit code ${result.exitCode}`,
+                artifacts: [],
+                error: result.stderr || `Exit code: ${result.exitCode}`,
+            },
+        });
+        broadcastTaskUpdate(ctx, failedTask, 'running');
+        await handleTaskFailure(workspaceId, issueId, taskId, {
+            success: false,
+            summary: `Command failed with exit code ${result.exitCode}`,
+            artifacts: [],
+            error: result.stderr || `Exit code: ${result.exitCode}`,
+        }, ctx);
+        return;
+    }
+    const completedTask = taskService.complete(workspaceId, taskId, {
+        success: true,
+        summary: result.stdout.slice(-500) || 'Command completed',
+        artifacts: [],
+    });
+    broadcastTaskUpdate(ctx, completedTask, 'running');
+    if (issueService.getById(workspaceId, issueId)?.continuousRun !== false) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    }
+}
 export async function continueIssueTaskScheduling(workspaceId, issueId, ctx) {
     await scheduleRunnableIssueTasks(workspaceId, issueId, ctx, { force: true });
 }
@@ -398,7 +452,7 @@ export function createTasksFromWorkflow(workspaceId, issueId, template, ctx) {
     });
 }
 function ensureWorkflowAgentsForRun(workspaceId, issue, template, ctx) {
-    const workflowAgentIds = [...new Set(template.nodes.map((node) => node.data.agentConfigId).filter(Boolean))];
+    const workflowAgentIds = [...new Set(template.nodes.filter((n) => n.type === 'agent').map((node) => node.data.agentConfigId).filter(Boolean))];
     const mergedMembers = [...new Set([...(issue.members ?? []), ...workflowAgentIds])];
     const membersChanged = mergedMembers.length !== (issue.members ?? []).length
         || mergedMembers.some((member, index) => member !== issue.members?.[index]);
@@ -498,6 +552,23 @@ function unregisterActiveIssueRuntime(workspaceId, issueId, agentId) {
 function issueRunKey(workspaceId, issueId) {
     return `${workspaceId}:${issueId}`;
 }
+function findWorkflowForIssue(workspaceId, issue) {
+    if (!issue.workflowId)
+        return null;
+    return getWorkflow(issue.workflowId);
+}
+function findCommandNodeForTask(workflow, task) {
+    if (!workflow)
+        return null;
+    if (task.agentConfigId)
+        return null;
+    for (const node of workflow.nodes) {
+        if (node.type === 'command' && (task.title === node.data.label || task.description?.startsWith('Command:'))) {
+            return node;
+        }
+    }
+    return null;
+}
 function broadcastTaskUpdate(ctx, task, from) {
     if (!task)
         return;

package/dist/agents/pull-request-agent.js

@@ -0,0 +1,115 @@
+import * as agentService from '../services/agent.js';
+import { AGENT_GENERATOR_PRESET_ID } from '../services/agent.js';
+import { createAgentRuntime } from '../adapters/agent-runtime.js';
+import { getWorkspace } from '../storage/workspace-store.js';
+import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
+const DEFAULT_SYSTEM_PROMPT = [
+    'You are a pull request description generator.',
+    'Return a concise, useful PR body based only on the provided commits and diff.',
+    'Use Markdown with these sections: Summary and Changes.',
+    'Keep it short. Do not greet, explain your process, ask questions, provide options, or wrap the response in code fences.',
+    'Output only the final PR body text.',
+].join(' ');
+export async function runPullRequestAgent(workspaceId, input) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    if (!input.diff.trim() && input.commits.length === 0)
+        throw new Error('No changes found');
+    const agent = findPullRequestAgent(workspaceId);
+    const session = agentService.getOrCreateSessionForConfig(workspaceId, agent);
+    agentService.updateStatus(workspaceId, session.id, 'active');
+    const runtime = createAgentRuntime({
+        kind: agent.runtimeKind,
+        provider: agent.modelProvider,
+        model: agent.modelId,
+        apiKey: agent.apiKey,
+        baseURL: agent.apiBase,
+        ...getThinkingRuntimeConfig(agent),
+    });
+    const workingDir = agentService.resolveWorkingDir(workspaceId, agent);
+    const systemPrompt = DEFAULT_SYSTEM_PROMPT;
+    const truncatedDiff = input.diff.length > 12000
+        ? `${input.diff.substring(0, 12000)}\n... (truncated)`
+        : input.diff;
+    const userPrompt = [
+        `Generate a pull request body for branch ${input.worktree.branch} targeting ${input.baseBranch}.`,
+        '',
+        'Commits:',
+        input.commits.length > 0 ? input.commits.map((commit) => `- ${commit}`).join('\n') : '- No commit messages available',
+        '',
+        'Diff:',
+        truncatedDiff,
+    ].join('\n');
+    const result = await runtime.execute(prependPersistentAgentContext(userPrompt, {
+        workspaceId,
+        workingDir,
+        boundDirs: ws.boundDirs,
+        includeWorkspacePrompt: false,
+        excludeNativeClaudeMd: agent.runtimeKind === 'claude-code',
+    }), workingDir, {
+        maxTurns: 1,
+        userPrompt,
+        systemPrompt,
+        outputStyle: agent.outputStyle,
+    });
+    agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
+        runtime: agent.runtimeKind,
+        model: agent.modelId,
+        summary: result.summary,
+        output: result.output,
+        usage: result.usage,
+        costUsd: result.costUsd,
+    });
+    if (!result.success) {
+        throw new Error(result.error || 'Pull request agent failed');
+    }
+    const body = sanitizePullRequestBody(result.output);
+    if (!body)
+        throw new Error('Empty response from pull request agent');
+    return body;
+}
+function findPullRequestAgent(workspaceId) {
+    const presets = agentService.listPresets(workspaceId);
+    const preset = presets?.find((a) => a.id === AGENT_GENERATOR_PRESET_ID);
+    if (preset)
+        return preset;
+    const template = agentService.readAgentTemplate(AGENT_GENERATOR_PRESET_ID);
+    if (template)
+        return template;
+    return agentService.listTemplates().find((a) => a.id === AGENT_GENERATOR_PRESET_ID) ?? agentService.listTemplates()[0];
+}
+function sanitizePullRequestBody(output) {
+    const chunks = (Array.isArray(output) ? output : [output])
+        .map((chunk) => cleanOutputChunk(chunk))
+        .filter(Boolean);
+    const uniqueChunks = dedupeAdjacentChunks(chunks);
+    return (uniqueChunks.at(-1) || uniqueChunks.join('\n\n')).trim();
+}
+function cleanOutputChunk(chunk) {
+    return chunk
+        .split('\n')
+        .filter((line) => !isRuntimeNoise(line))
+        .join('\n')
+        .replace(/```(?:\w+)?\n([\s\S]*?)```/g, '$1')
+        .trim();
+}
+function dedupeAdjacentChunks(chunks) {
+    const result = [];
+    for (const chunk of chunks) {
+        if (result.at(-1)?.trim() === chunk.trim())
+            continue;
+        result.push(chunk);
+    }
+    return result;
+}
+function isRuntimeNoise(line) {
+    const trimmed = line.trim();
+    return /^\[Usage\]/.test(trimmed)
+        || /^Claude Code initialized\b/i.test(trimmed)
+        || /^Codex initialized\b/i.test(trimmed)
+        || /^Tool:/i.test(trimmed)
+        || /^Todo:/i.test(trimmed);
+}
+//# sourceMappingURL=pull-request-agent.js.map

package/dist/agents/scheduler-agent.js

@@ -16,7 +16,7 @@ export function startScheduler(workspaceId, ctx) {
     const tick = async () => {
         // 检查 workspace 是否关闭了自动处理
         const workspace = workspaceService.getById(workspaceId);
-        if (workspace && workspace.autoProcessIssues === false) {
+        if (workspace && workspace.autoProcessIssues !== true) {
             console.log(`[scheduler:${workspaceId}] auto-processing disabled for this workspace, skip`);
             return;
         }

package/dist/app.js

@@ -5,7 +5,7 @@ import express from 'express';
 import cors from 'cors';
 import { createServer } from 'node:http';
 import { WebSocketServer } from 'ws';
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import { join, dirname, extname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -33,15 +33,18 @@ import searchRouter from './routes/search.js';
 import notificationRouter from './routes/notification.js';
 import databaseRouter from './routes/database.js';
 import kanbanRouter from './routes/kanban.js';
+import { worktreeRouter } from './routes/worktree.js';
 import speechRecognitionRouter, { handleSpeechStream } from './routes/speech-recognition.js';
 import agentCommandsRouter from './routes/agent-commands.js';
+import robotAccountRouter from './routes/robot-account.js';
+import versionRouter from './routes/version.js';
 import { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
 import { handleTypeScriptLspConnection } from './ws/typescript-lsp.js';
 import { broadcastToAll } from './ws/connection-manager.js';
 import { startScheduler, stopScheduler } from './agents/scheduler-agent.js';
-import { recoverRunningWorkOnStartup } from './services/issue-retry.js';
+// import { recoverRunningWorkOnStartup } from './services/issue-retry.js';
 import { startPersistedNotificationServices } from './services/notification-hub/index.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PORT = parseInt(process.env.PORT || '3100', 10);
@@ -70,73 +73,9 @@ app.use('/api', authMiddleware);
 // Serve static files from public/
 const publicDir = resolveRuntimeDir('public');
 app.use('/public', express.static(publicDir));
-// Scan public/prompt/ and generate index.json for the prompt store
-function scanPromptStore() {
-    const promptDir = join(publicDir, 'prompt');
-    if (!existsSync(promptDir))
-        return;
-    const files = readdirSync(promptDir).filter((f) => f.endsWith('.md'));
-    const index = files.map((filename) => {
-        const id = basename(filename, '.md');
-        const content = readFileSync(join(promptDir, filename), 'utf-8');
-        const firstHeading = content.split('\n').find((l) => /^#\s+/.test(l));
-        const name = firstHeading ? firstHeading.replace(/^#\s+/, '').trim() : id.replace(/[-_]/g, ' ');
-        return { id, name, filename };
-    });
-    writeFileSync(join(promptDir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
-    console.log(`[prompt-store] scanned ${index.length} templates`);
-}
-scanPromptStore();
-// Scan public/output-styles/ and generate index.json
-function scanOutputStyleStore() {
-    const dir = join(publicDir, 'output-styles');
-    if (!existsSync(dir))
-        return;
-    const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
-    const index = files.map((filename) => {
-        const id = basename(filename, '.md');
-        const content = readFileSync(join(dir, filename), 'utf-8');
-        const firstHeading = content.split('\n').find((l) => /^#\s+/.test(l));
-        const name = firstHeading ? firstHeading.replace(/^#\s+/, '').trim() : id.replace(/[-_]/g, ' ');
-        return { id, name, filename };
-    });
-    writeFileSync(join(dir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
-    console.log(`[output-style-store] scanned ${index.length} templates`);
-}
-scanOutputStyleStore();
-// Scan public/skills/{group}/{skill-name}/SKILL.md and generate index.json
-function scanSkillStore() {
-    const dir = join(publicDir, 'skills');
-    if (!existsSync(dir))
-        return;
-    const index = [];
-    for (const groupEntry of readdirSync(dir, { withFileTypes: true })) {
-        if (!groupEntry.isDirectory())
-            continue;
-        const group = groupEntry.name;
-        const groupDir = join(dir, group);
-        for (const skillEntry of readdirSync(groupDir, { withFileTypes: true })) {
-            if (!skillEntry.isDirectory())
-                continue;
-            const skillName = skillEntry.name;
-            const skillFile = join(groupDir, skillName, 'SKILL.md');
-            if (!existsSync(skillFile))
-                continue;
-            const content = readFileSync(skillFile, 'utf-8');
-            const fm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-            let name = skillName;
-            if (fm) {
-                const nameLine = fm[1].split(/\r?\n/).find((l) => /^\s*name\s*:/i.test(l));
-                if (nameLine)
-                    name = nameLine.split(':', 2)[1].trim() || skillName;
-            }
-            index.push({ id: skillName, name, group, path: `${group}/${skillName}` });
-        }
-    }
-    writeFileSync(join(dir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
-    console.log(`[skill-store] scanned ${index.length} skills`);
-}
-scanSkillStore();
+// Serve agents store from packages/agents/
+const agentsDir = resolveRuntimeDir('../agents');
+app.use('/agents-store', express.static(agentsDir));
 app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', timestamp: new Date().toISOString(), platform: process.platform });
 });
@@ -254,6 +193,7 @@ app.post('/api/git-config', async (req, res) => {
 app.use('/api/workspaces/:id/search', searchRouter);
 app.use('/api/workspaces/:id/database', databaseRouter);
 app.use('/api/workspaces/:id/kanban', kanbanRouter);
+app.use('/api/workspaces/:id/worktrees', worktreeRouter);
 app.use('/api/workspaces/:id/notifications', notificationRouter);
 app.use('/api/agents', agentRouter);
 app.use('/api', llmRouter);
@@ -265,6 +205,8 @@ app.use('/api/mcps', mcpRouter);
 app.use('/api/subscriptions', subscriptionRouter);
 app.use('/api/speech-recognition', speechRecognitionRouter);
 app.use('/api/agent-commands', agentCommandsRouter);
+app.use('/api/robot-accounts', robotAccountRouter);
+app.use('/api', versionRouter);
 // Serve static web frontend in production (after API routes, before catch-all)
 const webDir = resolveRuntimeDir('web');
 if (existsSync(webDir)) {
@@ -358,7 +300,7 @@ const HOST = process.env.HOST || '0.0.0.0';
 server.listen(PORT, HOST, () => {
     console.log(`[server] listening on http://${HOST}:${PORT}`);
     console.log(`[server] websocket on ws://${HOST}:${PORT}/ws?workspaceId=...`);
-    recoverRunningWorkOnStartup();
+    // recoverRunningWorkOnStartup();
     startPersistedNotificationServices().catch((err) => {
         console.error('[notification] failed to restore persisted services:', err);
     });

package/dist/middleware/auth.js

@@ -1,7 +1,7 @@
 import { getSecret } from '../services/auth-store.js';
 export function authMiddleware(req, res, next) {
     const secret = getSecret();
-    const openPaths = ['/api/health', '/api/auth/login', '/api/auth/check'];
+    const openPaths = ['/api/health', '/api/auth/login', '/api/auth/check', '/api/version', '/api/version/check'];
     if (openPaths.includes(req.path))
         return next();
     const auth = req.headers.authorization;

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.3.64",
+  "version": "0.3.66",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",
@@ -16,6 +16,7 @@
     "@langchain/google-genai": "^2.1.30",
     "@langchain/openai": "^1.4.5",
     "@larksuiteoapi/node-sdk": "^1.62.1",
+    "@modelcontextprotocol/sdk": "1.29.0",
     "@openai/codex-sdk": "^0.128.0",
     "cors": "^2.8.5",
     "dotenv": "^17.4.2",