@agent-spaces/server 0.3.64 → 0.3.65

package/dist/adapters/claude-code-runtime/index.js

@@ -4,7 +4,7 @@ import { summarizeResult } from '../agent-runtime-types.js';
 import { prepareClaudeOutputStyleFile } from '../../services/output-style.js';
 import { normalizeAdditionalDirectories, normalizePermissionMode, normalizeSkillNames, prepareConfigDir, resolveBundledClaudeExecutable, buildEnv, normalizeMcpServers } from './sdk-config.js';
 import { startClaudeAdapterIfNeeded, getClaudeCodeModel } from './adapter-pool.js';
-import { extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
+import { extractClaudeHookEvents, extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
 export class ClaudeCodeRuntime {
     config;
     abortController = null;
@@ -39,7 +39,33 @@ export class ClaudeCodeRuntime {
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
         d(`sdk mcp servers | ${sdkMcpServerNames.join(',') || '-'}`);
         const stderrLines = [];
+        let sessionId = options?.resumeSessionId;
+        const emitHook = (event, matcher = '*', payload) => {
+            options?.onEvent?.({ type: 'hook_event', event, matcher, payload });
+        };
         try {
+            emitHook('SessionStart', '*', {
+                cwd,
+                model,
+                provider: this.config.provider,
+                baseURL,
+                permissionMode,
+                configDir,
+                sandboxDirs: additionalDirectories,
+                resumeSessionId: options?.resumeSessionId,
+            });
+            const hookUserPrompt = options?.userPrompt ?? prompt;
+            emitHook('UserPromptSubmit', '*', {
+                prompt: hookUserPrompt,
+                message: hookUserPrompt,
+                userMessage: hookUserPrompt,
+                fullPrompt: prompt,
+                cwd,
+                configDir,
+            });
+            if (/CLAUDE\.md|AGENTS\.md|\.claude\/rules\//.test(prompt)) {
+                emitHook('InstructionsLoaded', '*', { source: 'prompt', promptPreview: prompt.slice(0, 1000) });
+            }
             const queryOptions = {
                 cwd,
                 model,
@@ -76,11 +102,13 @@ export class ClaudeCodeRuntime {
             let usageLine = null;
             let usage;
             let costUsd;
-            let sessionId = options?.resumeSessionId;
             let sawResult = false;
             const pendingAskUserQuestionToolIds = new Set();
             let waitingForUserAnswer = false;
             for await (const message of this.activeQuery) {
+                for (const hookEvent of extractClaudeHookEvents(message)) {
+                    emitHook(hookEvent.event, hookEvent.matcher, hookEvent.payload);
+                }
                 const nextSessionId = readSessionId(message);
                 if (nextSessionId && nextSessionId !== sessionId) {
                     sessionId = nextSessionId;
@@ -145,6 +173,17 @@ export class ClaudeCodeRuntime {
             const elapsed = Date.now() - startTime;
             if (waitingForUserAnswer) {
                 d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                const message = resultText || output.at(-1) || 'Waiting for user answer';
+                emitHook('Stop', '*', {
+                    status: 'waiting_for_user_answer',
+                    message,
+                    finalMessage: message,
+                    output,
+                    elapsedMs: elapsed,
+                    turns,
+                    tokenCount,
+                    sessionId,
+                });
                 if (usageLine)
                     output.push(usageLine);
                 return {
@@ -161,6 +200,7 @@ export class ClaudeCodeRuntime {
                 const runtimeError = extractRuntimeError([...stderrLines, ...output])
                     || 'Claude Code execution stopped before reporting a final result';
                 d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, turns, tokenCount, sessionId, stderr: stderrLines });
                 appendUnique(output, stderrLines);
                 appendUnique(output, [runtimeError]);
                 return {
@@ -176,6 +216,17 @@ export class ClaudeCodeRuntime {
             }
             if (waitingForUserAnswer && (!error || isAskUserQuestionAutoResult(error))) {
                 d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                const message = resultText || output.at(-1) || 'Waiting for user answer';
+                emitHook('Stop', '*', {
+                    status: 'waiting_for_user_answer',
+                    message,
+                    finalMessage: message,
+                    output,
+                    elapsedMs: elapsed,
+                    turns,
+                    tokenCount,
+                    sessionId,
+                });
                 if (usageLine)
                     output.push(usageLine);
                 return {
@@ -191,6 +242,7 @@ export class ClaudeCodeRuntime {
             if (error) {
                 const runtimeError = extractRuntimeError([error, ...stderrLines, ...output]) || error;
                 d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, turns, tokenCount, sessionId, stderr: stderrLines });
                 appendUnique(output, stderrLines);
                 if (usageLine)
                     output.push(usageLine);
@@ -213,6 +265,18 @@ export class ClaudeCodeRuntime {
             const finalOutput = resultText && !output.includes(resultText) ? [...output, resultText] : output;
             if (usageLine && !finalOutput.includes(usageLine))
                 finalOutput.push(usageLine);
+            emitHook('Stop', '*', {
+                status: 'success',
+                message: text,
+                finalMessage: text,
+                output: finalOutput,
+                elapsedMs: elapsed,
+                turns,
+                tokenCount,
+                sessionId,
+                usage,
+                costUsd,
+            });
             return {
                 success: true,
                 summary: summarizeResult(text),
@@ -230,11 +294,13 @@ export class ClaudeCodeRuntime {
             d(`failed ${elapsed}ms | ${runtimeError}`);
             if (err instanceof Error && err.stack)
                 console.error(err.stack);
+            emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, stderr: stderrLines, stack: err instanceof Error ? err.stack : undefined });
             appendUnique(output, stderrLines);
             appendUnique(output, [runtimeError]);
             return { success: false, summary: 'Claude Code execution failed', artifacts: [], error: runtimeError, output, sessionId: options?.resumeSessionId };
         }
         finally {
+            emitHook('SessionEnd', '*', { cwd, sessionId });
             this.activeQuery?.close();
             this.activeQuery = null;
             await this.adapterRun?.release();

package/dist/adapters/claude-code-runtime/message-format.js

@@ -95,6 +95,32 @@ export function extractToolResultEvent(message) {
     }
     return null;
 }
+export function extractClaudeHookEvents(message) {
+    const events = [];
+    if (message.type === 'system') {
+        if (message.subtype === 'task_started') {
+            events.push({ event: 'SubagentStart', matcher: '*', payload: message });
+        }
+        else if (message.subtype === 'task_notification') {
+            events.push({ event: 'Notification', matcher: '*', payload: message });
+        }
+        else if (message.subtype === 'local_command_output') {
+            events.push({ event: 'Notification', matcher: 'local_command_output', payload: message });
+        }
+    }
+    if (message.type === 'tool_use_summary') {
+        events.push({ event: 'PostToolBatch', matcher: '*', payload: message });
+    }
+    for (const toolUse of extractToolUseEvents(message)) {
+        if (toolUse.name === 'TaskCreate') {
+            events.push({ event: 'TaskCreated', matcher: toolUse.name, payload: toolUse });
+        }
+        if (toolUse.name === 'TaskCompleted') {
+            events.push({ event: 'TaskCompleted', matcher: toolUse.name, payload: toolUse });
+        }
+    }
+    return events;
+}
 export function logToolDebug(message, d, options = {}) {
     switch (message.type) {
         case 'assistant':

package/dist/adapters/claude-code-runtime/sdk-config.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicBridgeProvider } from './types.js';
 const require = createRequire(import.meta.url);
+const CLAUDE_BUILT_IN_DIRS = ['agents', 'commands'];
 export function buildEnv(config, configDir, override) {
     const usesAnthropicBridge = isAnthropicBridgeProvider(config.provider);
     return {
@@ -132,6 +133,7 @@ export function prepareConfigDir(configDir, agentDir) {
     mkdirSync(configDir, { recursive: true });
     if (!agentDir)
         return;
+    copyClaudeBuiltInDirs(agentDir, configDir);
     const sourceSkillsDir = join(agentDir, 'skills');
     const targetSkillsDir = join(configDir, 'skills');
     rmSync(targetSkillsDir, { recursive: true, force: true });
@@ -163,6 +165,16 @@ export function prepareConfigDir(configDir, agentDir) {
         copyFileSync(source, join(targetSkillsDir, `${skillName}.md`));
     }
 }
+function copyClaudeBuiltInDirs(agentDir, configDir) {
+    for (const dir of CLAUDE_BUILT_IN_DIRS) {
+        const sourceDir = join(agentDir, dir);
+        const targetDir = join(configDir, dir);
+        rmSync(targetDir, { recursive: true, force: true });
+        if (!existsSync(sourceDir) || !statSync(sourceDir).isDirectory())
+            continue;
+        cpSync(sourceDir, targetDir, { recursive: true, force: true });
+    }
+}
 function hasSkillContent(skill, configDir) {
     if (!configDir)
         return true;

package/dist/adapters/git.js

@@ -78,18 +78,20 @@ function mapStatus(raw) {
     };
 }
 async function getUpstreamRef(git, branch) {
+    const refExists = async (ref) => {
+        return git.raw(['rev-parse', '--verify', '--quiet', ref])
+            .then(() => true)
+            .catch(() => false);
+    };
     const upstream = await git.raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
         .then(v => v.trim())
         .catch(() => '');
-    if (upstream)
+    if (upstream && await refExists(upstream))
         return upstream;
     if (!branch || branch === 'HEAD')
         return null;
     const originBranch = `origin/${branch}`;
-    const hasOriginBranch = await git.raw(['rev-parse', '--verify', '--quiet', originBranch])
-        .then(() => true)
-        .catch(() => false);
-    return hasOriginBranch ? originBranch : null;
+    return await refExists(originBranch) ? originBranch : null;
 }
 function splitConflictSides(content) {
     const left = [];
@@ -266,7 +268,12 @@ export async function gitLog(workspaceId, maxCount = 50) {
     const upstream = await getUpstreamRef(git, status.current || 'HEAD');
     const refs = upstream ? ['HEAD', upstream] : ['HEAD'];
     const pretty = '%H%x1f%s%x1f%an%x1f%aI%x1e';
-    const raw = await git.raw(['log', `--max-count=${maxCount}`, `--pretty=format:${pretty}`, ...refs]);
+    const logArgs = ['log', `--max-count=${maxCount}`, `--pretty=format:${pretty}`];
+    const raw = await git.raw([...logArgs, ...refs]).catch((err) => {
+        if (!upstream)
+            throw err;
+        return git.raw([...logArgs, 'HEAD']);
+    });
     return raw.split('\x1e')
         .map(record => record.trim())
         .filter(Boolean)

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

@@ -49,8 +49,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: [],
@@ -199,8 +201,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),

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';
@@ -35,6 +35,7 @@ import databaseRouter from './routes/database.js';
 import kanbanRouter from './routes/kanban.js';
 import speechRecognitionRouter, { handleSpeechStream } from './routes/speech-recognition.js';
 import agentCommandsRouter from './routes/agent-commands.js';
+import robotAccountRouter from './routes/robot-account.js';
 import { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
@@ -70,73 +71,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 });
 });
@@ -265,6 +202,7 @@ 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);
 // Serve static web frontend in production (after API routes, before catch-all)
 const webDir = resolveRuntimeDir('web');
 if (existsSync(webDir)) {

package/dist/routes/agent-sse.js

@@ -79,6 +79,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: [],