@agent-spaces/server 0.3.62 → 0.3.63

package/dist/adapters/agent-runtime-types.js

@@ -1,7 +1,19 @@
+import { resolveOutputStyleContent } from '../services/output-style.js';
 export function summarizeResult(text) {
     const normalized = text.trim().replace(/\s+/g, ' ');
     if (!normalized)
         return 'Completed agent execution';
     return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
 }
+export function appendOutputStyleToPrompt(prompt, outputStyle) {
+    const style = resolveOutputStyleContent(outputStyle)?.trim();
+    if (!style)
+        return prompt;
+    return [
+        prompt.trimEnd(),
+        '',
+        'Output style instructions:',
+        style,
+    ].join('\n');
+}
 //# sourceMappingURL=agent-runtime-types.js.map

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

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 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';
@@ -25,6 +26,7 @@ export class ClaudeCodeRuntime {
         if (configDir)
             prepareConfigDir(configDir, agentDir);
         const skillNames = normalizeSkillNames(options?.skills, configDir);
+        const outputStyleFile = configDir ? prepareClaudeOutputStyleFile(configDir, options?.outputStyle) : undefined;
         const claudeExecutable = resolveBundledClaudeExecutable();
         this.adapterRun = await startClaudeAdapterIfNeeded(this.config);
         const baseURL = this.adapterRun?.url ?? this.config.baseURL;
@@ -46,6 +48,7 @@ export class ClaudeCodeRuntime {
                 tools: { type: 'preset', preset: 'claude_code' },
                 mcpServers: sdkMcpServers,
                 skills: skillNames,
+                outputStyle: outputStyleFile,
                 managedSettings: {
                     strictPluginOnlyCustomization: ['mcp'],
                 },

package/dist/adapters/codex-runtime.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { basename, extname, join } from 'node:path';
 import { Codex } from '@openai/codex-sdk';
-import { summarizeResult } from './agent-runtime-types.js';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
 /**
  * Runtime backed by OpenAI's Codex SDK.
  * Spawns the bundled Codex CLI and consumes its structured JSONL event stream.
@@ -48,7 +48,7 @@ export class CodexRuntime {
             const thread = options?.resumeSessionId
                 ? codex.resumeThread(options.resumeSessionId, threadOptions)
                 : codex.startThread(threadOptions);
-            const { events } = await thread.runStreamed(prompt, {
+            const { events } = await thread.runStreamed(appendOutputStyleToPrompt(prompt, options?.outputStyle), {
                 signal: this.abortController.signal,
             });
             let resultText = '';

package/dist/adapters/langchain-runtime.js

@@ -1,6 +1,6 @@
 import { createAgent, initChatModel, tool } from 'langchain';
 import { z } from 'zod';
-import { summarizeResult } from './agent-runtime-types.js';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
 /**
  * Runtime backed by LangChain.js.
  * Uses LangChain's provider-neutral createAgent API and adapts Agent Spaces tools.
@@ -27,7 +27,7 @@ export class LangChainRuntime {
                 tools: buildLangChainTools(options?.functionTools, output, options),
                 systemPrompt: options?.systemPrompt,
             });
-            const result = await agent.invoke({ messages: [{ role: 'user', content: prompt }] }, {
+            const result = await agent.invoke({ messages: [{ role: 'user', content: appendOutputStyleToPrompt(prompt, options?.outputStyle) }] }, {
                 signal: this.abortController?.signal,
                 recursionLimit: options?.maxTurns ? Math.max(2, options.maxTurns * 2 + 1) : undefined,
             });

package/dist/adapters/open-agent-sdk-runtime.js

@@ -1,5 +1,5 @@
 import { createAgent } from '@codeany/open-agent-sdk';
-import { summarizeResult } from './agent-runtime-types.js';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
 /**
  * Runtime backed by @codeany/open-agent-sdk.
  * Runs the agent loop in-process with the SDK's built-in tools.
@@ -35,7 +35,7 @@ export class OpenAgentSdkRuntime {
             });
             d('agent created, sending prompt...');
             d('tool debug | open-agent-sdk runtime does not expose per-tool stream events through prompt(); only final text/usage is available here');
-            const result = await this.agent.prompt(prompt);
+            const result = await this.agent.prompt(appendOutputStyleToPrompt(prompt, options?.outputStyle));
             const elapsed = Date.now() - startTime;
             const inputTokens = result.usage.input_tokens;
             const outputTokens = result.usage.output_tokens;

package/dist/agents/commit-agent.js

@@ -42,6 +42,7 @@ export async function runCommitAgent(workspaceId) {
     }), workingDir, {
         maxTurns: 1,
         systemPrompt,
+        outputStyle: commitAgent.outputStyle,
     });
     agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
         runtime: commitAgent.runtimeKind,

package/dist/agents/issue-agent-progress.js

@@ -74,7 +74,9 @@ export function createIssueAgentProgress(workspaceId, issue, preset, agentSessio
     return { message, comment };
 }
 export function completeIssueAgentProgress(workspaceId, issue, progress, summary, output, metadata) {
-    const content = output.join('\n').trim() || summary;
+    const parts = metadata.parts;
+    const finalText = [...(parts ?? [])].reverse().find((part) => part.type === 'text')?.text.trim();
+    const content = finalText || summary.trim() || output.join('\n').trim();
     if (!content.trim())
         return;
     const message = messageService.updateMessage(workspaceId, issue.channelId, progress.message.id, {
@@ -88,7 +90,7 @@ export function completeIssueAgentProgress(workspaceId, issue, progress, summary
             summary,
             duration: metadata.duration,
         },
-        parts: metadata.parts,
+        parts,
     });
     if (message)
         broadcastToWorkspace(workspaceId, 'channel.message.updated', message);

package/dist/agents/issue-agent-runner.js

@@ -9,6 +9,11 @@ export async function runIssueAutomation(workspaceId, issueId, ctx) {
         console.warn(`[issue-runner] issue not found workspaceId=${workspaceId} issueId=${issueId}`);
         return;
     }
+    const tasks = taskService.list(workspaceId, issueId);
+    if (tasks.length > 0) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+        return;
+    }
     // Workflow template branch
     if (issue.workflowId) {
         const template = workflowService.getWorkflow(issue.workflowId);
@@ -29,11 +34,6 @@ export async function runIssueAutomation(workspaceId, issueId, ctx) {
             return;
         }
     }
-    const tasks = taskService.list(workspaceId, issueId);
-    if (tasks.length > 0) {
-        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
-        return;
-    }
     console.warn(`[issue-runner] no workflow configured for issue workspaceId=${workspaceId} issueId=${issueId}`);
 }
 export function hasActiveIssueAutomation(workspaceId) {

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

@@ -9,7 +9,9 @@ import { createIssueFunctionTools } from '../services/builtin-tools.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';
 const ACTIVE_TASK_STATUSES = ['running', 'reviewing', 'retrying', 'waiting_review'];
+const activeIssueRuntimes = new Map();
 export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, ctx) {
     const issue = issueService.getById(workspaceId, issueId);
     if (!issue) {
@@ -31,6 +33,7 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
     ctx.broadcast('agent.output', { agentId: taskSyncAgent.id, data: `Syncing issue tasks: ${issueId}` });
     const startTime = Date.now();
     const taskSyncWorkingDir = resolveIssueWorkspaceRoot(workspaceId);
+    const workspace = workspaceService.getById(workspaceId);
     const progress = createIssueAgentProgress(workspaceId, issue, taskSyncPreset, taskSyncAgent.id, {
         runtime: taskSyncPreset.runtimeKind,
         model: taskSyncPreset.modelId,
@@ -53,7 +56,8 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
         skills: [],
         configDir: agentService.getAgentConfigDir(workspaceId, taskSyncPreset),
         sandboxDirs: taskSyncPreset.sandboxDirs,
-        onEvent: taskSyncTracker.handleEvent,
+        outputStyle: taskSyncPreset.outputStyle,
+        onEvent: wrapOnEventWithHooks(taskSyncTracker.handleEvent.bind(taskSyncTracker), workspaceId, workspace?.hooksEnabled),
     });
     if (taskSyncTracker.output.length === 0) {
         for (const line of result.output) {
@@ -101,7 +105,10 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
     updateIssueStatus(workspaceId, issueId, 'in_progress', ctx);
     await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
 }
-export async function scheduleRunnableIssueTasks(workspaceId, issueId, ctx) {
+export async function scheduleRunnableIssueTasks(workspaceId, issueId, ctx, _options = {}) {
+    const issue = issueService.getById(workspaceId, issueId);
+    if (!issue)
+        return;
     const tasks = taskService.list(workspaceId, issueId);
     const doneIds = new Set(tasks.filter((task) => task.status === 'done').map((task) => task.id));
     const hasActive = tasks.some((task) => ACTIVE_TASK_STATUSES.includes(task.status));
@@ -113,7 +120,8 @@ export async function scheduleRunnableIssueTasks(workspaceId, issueId, ctx) {
         }
         return;
     }
-    for (const task of runnable) {
+    const tasksToRun = issue.continuousRun === false ? runnable.slice(0, 1) : runnable;
+    for (const task of tasksToRun) {
         await runIssueTask(workspaceId, issueId, task.id, ctx);
     }
 }
@@ -129,6 +137,8 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     }
     const taskAgentPreset = findAgentForTask(workspaceId, issue, task);
     if (!taskAgentPreset) {
+        if (issueService.getById(workspaceId, issueId)?.status === 'error')
+            return;
         const missingExecutorResult = {
             success: false,
             summary: 'No runnable agent configured in issue channel members',
@@ -161,6 +171,7 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     broadcastTaskUpdate(ctx, runningTask, task.status);
     agentService.assignTask(workspaceId, taskAgent.id, taskId);
     const runtime = createRuntimeForPreset(taskAgentPreset);
+    registerActiveIssueRuntime(workspaceId, issueId, taskAgent.id, runtime);
     const agentWorkingDir = resolveIssueWorkspaceRoot(workspaceId);
     const startTime = Date.now();
     const progress = createIssueAgentProgress(workspaceId, issue, taskAgentPreset, taskAgent.id, {
@@ -180,20 +191,40 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
             ctx.broadcast('task.output', { taskId, data: line });
         },
     });
+    const workspace = workspaceService.getById(workspaceId);
     ctx.broadcast('agent.output', { agentId: taskAgent.id, data: `Executing task: ${runningTask.title}` });
     ctx.broadcast('agent.output', {
         agentId: taskAgent.id,
         data: `[debug] workflow agentConfigId=${taskAgentPreset.id} role=${taskAgentPreset.role} taskAgentConfigId=${runningTask.agentConfigId || '(fallback)'} runtime=${taskAgentPreset.runtimeKind ?? 'open-agent-sdk'}`,
     });
-    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
-        maxTurns: 100,
-        mcpServers: agentService.getMcpServers(taskAgentPreset.mcps),
-        functionTools: createCurrentIssueTools(workspaceId, issue, taskAgentPreset),
-        skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, taskAgentPreset), taskAgentPreset.skills),
-        configDir: agentService.getAgentConfigDir(workspaceId, taskAgentPreset),
-        sandboxDirs: runningTask.sandboxDirs ?? taskAgentPreset.sandboxDirs,
-        onEvent: agentTracker.handleEvent,
-    });
+    let result;
+    try {
+        result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
+            maxTurns: 100,
+            mcpServers: agentService.getMcpServers(taskAgentPreset.mcps),
+            functionTools: createCurrentIssueTools(workspaceId, issue, taskAgentPreset),
+            skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, taskAgentPreset), taskAgentPreset.skills),
+            configDir: agentService.getAgentConfigDir(workspaceId, taskAgentPreset),
+            sandboxDirs: runningTask.sandboxDirs ?? taskAgentPreset.sandboxDirs,
+            outputStyle: taskAgentPreset.outputStyle,
+            onEvent: wrapOnEventWithHooks(agentTracker.handleEvent.bind(agentTracker), workspaceId, workspace?.hooksEnabled),
+        });
+    }
+    finally {
+        unregisterActiveIssueRuntime(workspaceId, issueId, taskAgent.id);
+    }
+    if (issueService.getById(workspaceId, issueId)?.status === 'error') {
+        const failedTask = taskService.updateStatus(workspaceId, taskId, 'failed', {
+            result: {
+                success: false,
+                summary: 'Interrupted by user',
+                artifacts: [],
+                error: 'Interrupted by user',
+            },
+        });
+        broadcastTaskUpdate(ctx, failedTask, 'running');
+        return;
+    }
     if (agentTracker.output.length === 0) {
         for (const line of result.output) {
             agentTracker.output.push(line);
@@ -235,10 +266,42 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     }
     const completedTask = taskService.complete(workspaceId, taskId, result);
     broadcastTaskUpdate(ctx, completedTask, 'running');
-    await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    if (issueService.getById(workspaceId, issueId)?.continuousRun !== false) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    }
 }
 export async function continueIssueTaskScheduling(workspaceId, issueId, ctx) {
-    await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    await scheduleRunnableIssueTasks(workspaceId, issueId, ctx, { force: true });
+}
+export function stopIssueAutomation(workspaceId, issueId, reason = 'Interrupted by user') {
+    const key = issueRunKey(workspaceId, issueId);
+    const runtimes = activeIssueRuntimes.get(key);
+    if (runtimes) {
+        for (const [agentId, runtime] of runtimes.entries()) {
+            try {
+                runtime.stop();
+            }
+            catch {
+                // Runtime may already be unwinding.
+            }
+            agentService.complete(workspaceId, agentId, reason);
+        }
+        activeIssueRuntimes.delete(key);
+    }
+    const activeTasks = taskService.list(workspaceId, issueId)
+        .filter((task) => ACTIVE_TASK_STATUSES.includes(task.status));
+    return activeTasks.map((task) => {
+        const from = task.status;
+        const failed = taskService.updateStatus(workspaceId, task.id, 'failed', {
+            result: {
+                success: false,
+                summary: reason,
+                artifacts: [],
+                error: reason,
+            },
+        });
+        return failed ? { task: failed, from } : null;
+    }).filter((item) => Boolean(item));
 }
 function createTaskSyncTools(workspaceId, issue, preset, ctx) {
     return [
@@ -417,6 +480,24 @@ async function handleTaskFailure(workspaceId, issueId, taskId, result, ctx) {
     ctx.broadcast('issue.status_changed', { issueId, from: issue?.status ?? 'in_progress', to: 'error' });
     ctx.broadcast('issue.updated', updated);
 }
+function registerActiveIssueRuntime(workspaceId, issueId, agentId, runtime) {
+    const key = issueRunKey(workspaceId, issueId);
+    const runtimes = activeIssueRuntimes.get(key) ?? new Map();
+    runtimes.set(agentId, runtime);
+    activeIssueRuntimes.set(key, runtimes);
+}
+function unregisterActiveIssueRuntime(workspaceId, issueId, agentId) {
+    const key = issueRunKey(workspaceId, issueId);
+    const runtimes = activeIssueRuntimes.get(key);
+    if (!runtimes)
+        return;
+    runtimes.delete(agentId);
+    if (runtimes.size === 0)
+        activeIssueRuntimes.delete(key);
+}
+function issueRunKey(workspaceId, issueId) {
+    return `${workspaceId}:${issueId}`;
+}
 function broadcastTaskUpdate(ctx, task, from) {
     if (!task)
         return;

package/dist/app.js

@@ -5,9 +5,9 @@ import express from 'express';
 import cors from 'cors';
 import { createServer } from 'node:http';
 import { WebSocketServer } from 'ws';
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { join, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import workspaceRouter from './routes/workspace.js';
 import fileRouter from './routes/file.js';
@@ -22,8 +22,10 @@ import authRouter from './routes/auth.js';
 import folderRouter from './routes/folder.js';
 import commandRouter from './routes/command.js';
 import codeFavoritesRouter from './routes/code-favorites.js';
+import hooksRouter from './routes/hooks.js';
 import skillRouter from './routes/skill.js';
 import promptTemplateRouter from './routes/prompt-template.js';
+import outputStyleRouter from './routes/output-style.js';
 import mcpRouter from './routes/mcp.js';
 import subscriptionRouter from './routes/subscription.js';
 import agentSseRouter from './routes/agent-sse.js';
@@ -65,6 +67,73 @@ 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();
 app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', timestamp: new Date().toISOString(), platform: process.platform });
 });
@@ -82,9 +151,7 @@ app.post('/api/upload/avatar', async (req, res) => {
         return;
     }
     const [, mime, base64] = match;
-    const ext = mime === 'image/png' ? 'png' : mime === 'image/webp' ? 'webp' : 'jpg';
-    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const name = filename ? `${id}-${filename.replace(/[^a-zA-Z0-9._-]/g, '_')}` : `${id}.${ext}`;
+    const name = 'user.jpg';
     const avatarsDir = join(publicDir, 'avatars');
     if (!existsSync(avatarsDir))
         mkdirSync(avatarsDir, { recursive: true });
@@ -113,6 +180,7 @@ app.use('/api/workspaces/:id/issues', issueRouter);
 app.use('/api/workflows', workflowRouter);
 app.use('/api/workspaces/:id/commands', commandRouter);
 app.use('/api/workspaces/:id/code-favorites', codeFavoritesRouter);
+app.use('/api/workspaces/:id/hooks', hooksRouter);
 app.use('/api/workspaces/:id/agents', agentRouter);
 app.use('/api/workspaces/:id/tasks', taskRouter);
 app.use('/api/workspaces/:id/git', gitRouter);
@@ -144,6 +212,7 @@ app.use('/api', llmRouter);
 app.use('/api/folder', folderRouter);
 app.use('/api/skills', skillRouter);
 app.use('/api/prompt-templates', promptTemplateRouter);
+app.use('/api/output-styles', outputStyleRouter);
 app.use('/api/mcps', mcpRouter);
 app.use('/api/subscriptions', subscriptionRouter);
 app.use('/api/speech-recognition', speechRecognitionRouter);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.3.62",
+  "version": "0.3.63",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",

package/dist/routes/agent-sse.js

@@ -5,6 +5,7 @@ import * as agentService from '../services/agent.js';
 import * as workspaceService from '../services/workspace.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { buildAgentPrompt } from '../ws/agent-prompt.js';
+import { wrapOnEventWithHooks } from '../services/hook-engine.js';
 const router = Router();
 router.post('/run', async (req, res) => {
     const body = req.body;
@@ -78,11 +79,12 @@ router.post('/run', async (req, res) => {
             skills,
             configDir,
             sandboxDirs: preset.sandboxDirs,
-            onEvent: (event) => {
+            outputStyle: body.outputStyle ?? preset.outputStyle,
+            onEvent: wrapOnEventWithHooks((event) => {
                 if (event.type === 'output')
                     output.push(event.line);
                 writeSse(res, event.type, serializeRuntimeEvent(event));
-            },
+            }, workspaceId, workspace?.hooksEnabled),
         });
         completed = true;
         const displayOutput = output.length ? output : result.output;

package/dist/routes/hooks.js

@@ -0,0 +1,88 @@
+import { Router } from 'express';
+import * as store from '../storage/hook-store.js';
+const router = Router({ mergeParams: true });
+router.get('/', (req, res) => {
+    try {
+        res.json(store.listHooks(req.params.id));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/:name', (req, res) => {
+    try {
+        const hook = store.getHook(req.params.id, req.params.name);
+        if (!hook) {
+            res.status(404).json({ error: 'Hook not found' });
+            return;
+        }
+        res.json(hook);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/', (req, res) => {
+    try {
+        const config = req.body;
+        if (!config.name) {
+            res.status(400).json({ error: 'name required' });
+            return;
+        }
+        store.saveHook(req.params.id, config);
+        res.status(201).json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.put('/:name', (req, res) => {
+    try {
+        const config = req.body;
+        config.name = req.params.name;
+        store.saveHook(req.params.id, config);
+        res.json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:name', (req, res) => {
+    try {
+        store.deleteHook(req.params.id, req.params.name);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/upload', (req, res) => {
+    try {
+        const { content } = req.body;
+        if (!content || typeof content !== 'string') {
+            res.status(400).json({ error: 'content (string) required' });
+            return;
+        }
+        const config = store.uploadHook(req.params.id, content);
+        res.status(201).json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:name/apply', (req, res) => {
+    try {
+        const { targetWorkspaceId } = req.body;
+        if (!targetWorkspaceId) {
+            res.status(400).json({ error: 'targetWorkspaceId required' });
+            return;
+        }
+        store.applyToWorkspace(req.params.id, req.params.name, targetWorkspaceId);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+export default router;
+//# sourceMappingURL=hooks.js.map