@agent-spaces/server 0.3.61 → 0.3.63

package/dist/routes/task.js

@@ -11,15 +11,23 @@ router.post('/', (req, res) => {
         res.status(400).json({ error: 'issueId and title are required' });
         return;
     }
+    if (typeof agentConfigId !== 'string' || !agentConfigId.trim()) {
+        res.status(400).json({ error: 'agentConfigId is required' });
+        return;
+    }
     const issue = issueService.getById(req.params.id, issueId);
     if (!issue) {
         res.status(404).json({ error: 'issue not found' });
         return;
     }
+    if (!issue.members.includes(agentConfigId)) {
+        res.status(400).json({ error: 'agentConfigId must be an issue member' });
+        return;
+    }
     const task = taskService.create(req.params.id, issueId, {
         title,
         description: description || '',
-        agentConfigId,
+        agentConfigId: agentConfigId.trim(),
         dependsOnTaskIds,
         sandboxDirs,
     });
@@ -60,6 +68,10 @@ router.put('/:taskId', (req, res) => {
         res.status(400).json({ error: 'title, description, agentConfigId, dependsOnTaskIds, or sandboxDirs is required' });
         return;
     }
+    if (agentConfigId !== undefined && (typeof agentConfigId !== 'string' || !agentConfigId.trim())) {
+        res.status(400).json({ error: 'agentConfigId cannot be empty' });
+        return;
+    }
     const task = taskService.update(req.params.id, req.params.taskId, { title, description, agentConfigId, dependsOnTaskIds, sandboxDirs });
     if (!task) {
         res.status(404).json({ error: 'task not found or not editable (must be pending)' });

package/dist/services/agent.js

@@ -346,7 +346,13 @@ export function getAvailableSkillNames(agentDir, skills) {
         .filter((skill) => {
         if (!skill)
             return false;
-        const skillFile = join(agentDir, 'skills', `${skill}.md`);
+        const skillsBase = join(agentDir, 'skills');
+        // Check folder structure first, then flat .md
+        const skillFolder = join(skillsBase, skill);
+        if (existsSync(skillFolder) && statSync(skillFolder).isDirectory()) {
+            return readdirSync(skillFolder).some((f) => f.endsWith('.md'));
+        }
+        const skillFile = join(skillsBase, `${skill}.md`);
         return existsSync(skillFile) && statSync(skillFile).size > 0;
     });
 }
@@ -448,25 +454,43 @@ function writeAgentTemplate(preset, skillInputs) {
     else if (preset.skills?.length) {
         const globalSkillsDir = join(getDataDir(), 'skills');
         const keepFiles = new Set(preset.skills.map((s) => s.endsWith('.md') ? s : `${s}.md`));
-        // Remove skill files no longer in the list
+        const keepNames = new Set(preset.skills.map((s) => s.replace(/\.md$/i, '')));
+        // Remove skill entries no longer in the list (flat .md files and folders)
         if (existsSync(skillsDir)) {
             for (const existing of readdirSync(skillsDir)) {
-                if (existing.endsWith('.md') && !keepFiles.has(existing)) {
-                    rmSync(join(skillsDir, existing), { force: true });
+                const name = existing.endsWith('.md') ? existing.replace(/\.md$/i, '') : existing;
+                if (!keepNames.has(name)) {
+                    rmSync(join(skillsDir, existing), { recursive: true, force: true });
                     console.log('[writeAgentTemplate] removed stale skill:', existing);
                 }
             }
         }
-        // Copy / ensure skill files
-        for (const filename of keepFiles) {
-            const target = join(skillsDir, filename);
-            const globalSource = join(globalSkillsDir, filename);
-            console.log('[writeAgentTemplate] skill:', filename, 'globalExists:', existsSync(globalSource), 'targetExists:', existsSync(target));
-            if (existsSync(globalSource)) {
-                copyFileSync(globalSource, target);
+        // Copy / ensure skill files (global skills are folders: skills/{name}/SKILL.md)
+        for (const skillName of keepNames) {
+            const globalFolder = join(globalSkillsDir, skillName);
+            const flatTarget = join(skillsDir, `${skillName}.md`);
+            const folderTarget = join(skillsDir, skillName);
+            console.log('[writeAgentTemplate] skill:', skillName, 'globalFolder:', globalFolder, 'globalExists:', existsSync(globalFolder) && statSync(globalFolder).isDirectory());
+            if (existsSync(globalFolder) && statSync(globalFolder).isDirectory()) {
+                // Copy entire skill folder
+                if (existsSync(folderTarget)) {
+                    rmSync(folderTarget, { recursive: true, force: true });
+                }
+                cpSync(globalFolder, folderTarget, { recursive: true, force: true });
+                // Remove stale flat .md if it exists
+                if (existsSync(flatTarget)) {
+                    rmSync(flatTarget, { force: true });
+                }
             }
-            else if (!existsSync(target)) {
-                writeFileSync(target, '', 'utf-8');
+            else {
+                // Fallback: single SKILL.md or legacy flat file
+                const globalSkillFile = join(globalFolder, 'SKILL.md');
+                if (existsSync(globalSkillFile)) {
+                    copyFileSync(globalSkillFile, flatTarget);
+                }
+                else if (!existsSync(flatTarget) && !existsSync(folderTarget)) {
+                    writeFileSync(flatTarget, '', 'utf-8');
+                }
             }
         }
     }
@@ -492,9 +516,14 @@ function copyAgentTemplateToWorkspace(agentId, agentspaceDir) {
     if (existsSync(skillsDir)) {
         const workspaceSkillsDir = join(agentspaceDir, 'skills');
         ensureDir(workspaceSkillsDir);
-        for (const file of readdirSync(skillsDir)) {
-            if (extname(file).toLowerCase() === '.md') {
-                copyFileSync(join(skillsDir, file), join(workspaceSkillsDir, file));
+        for (const entry of readdirSync(skillsDir)) {
+            const source = join(skillsDir, entry);
+            const sourceStat = statSync(source);
+            if (sourceStat.isDirectory()) {
+                cpSync(source, join(workspaceSkillsDir, entry), { recursive: true, force: true });
+            }
+            else if (sourceStat.isFile() && extname(entry).toLowerCase() === '.md') {
+                copyFileSync(source, join(workspaceSkillsDir, entry));
             }
         }
     }

package/dist/services/hook-engine.js

@@ -0,0 +1,118 @@
+import { exec } from 'node:child_process';
+import { listHooks } from '../storage/hook-store.js';
+function matchToolName(matcher, toolName) {
+    if (matcher === '*')
+        return true;
+    if (matcher.startsWith('/') && matcher.endsWith('/')) {
+        try {
+            const regex = new RegExp(matcher.slice(1, -1));
+            return regex.test(toolName);
+        }
+        catch {
+            return matcher === toolName;
+        }
+    }
+    return matcher === toolName;
+}
+function executeCommand(command, env, timeout) {
+    return new Promise((resolve) => {
+        exec(command, { env: { ...process.env, ...env }, timeout: Math.min(timeout, 30000) }, (error) => {
+            if (error)
+                console.warn(`[HookEngine] command error: ${error.message}`);
+            resolve();
+        });
+    });
+}
+async function executeWebhook(url, body, timeout) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), Math.min(timeout, 30000));
+        await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+    }
+    catch (error) {
+        console.warn(`[HookEngine] webhook error: ${error.message}`);
+    }
+}
+async function executeRule(rule, phase, toolName, workspaceId, context) {
+    const timeout = rule.timeout ?? 10000;
+    if (rule.type === 'command' && rule.command) {
+        await executeCommand(rule.command, {
+            HOOK_TOOL_NAME: toolName,
+            HOOK_TOOL_INPUT: JSON.stringify(context.toolInput ?? {}),
+            HOOK_TOOL_RESULT: JSON.stringify(context.toolResult ?? ''),
+            HOOK_WORKSPACE_ID: workspaceId,
+            HOOK_PHASE: phase,
+        }, timeout);
+    }
+    else if (rule.type === 'webhook' && rule.url) {
+        await executeWebhook(rule.url, {
+            event: phase,
+            toolName,
+            toolInput: context.toolInput,
+            toolResult: context.toolResult ?? undefined,
+            timestamp: new Date().toISOString(),
+            workspaceId,
+        }, timeout);
+    }
+    else if (rule.type === 'script') {
+        console.warn(`[HookEngine] script type not implemented, skipping rule in ${phase}`);
+    }
+}
+export class HookEngine {
+    hooks = [];
+    workspaceId;
+    constructor(workspaceId) {
+        this.workspaceId = workspaceId;
+    }
+    load() {
+        this.hooks = listHooks(this.workspaceId);
+    }
+    reload() {
+        this.load();
+    }
+    getHooks() {
+        return this.hooks;
+    }
+    async executeHooks(phase, toolName, context) {
+        const enabledHooks = this.hooks.filter(h => h.enabled);
+        const promises = [];
+        for (const hook of enabledHooks) {
+            const rules = hook.hooks[phase];
+            if (!rules)
+                continue;
+            for (const rule of rules) {
+                if (matchToolName(rule.matcher, toolName)) {
+                    promises.push(executeRule(rule, phase, toolName, this.workspaceId, context));
+                }
+            }
+        }
+        await Promise.allSettled(promises);
+    }
+}
+export function wrapOnEventWithHooks(onEvent, workspaceId, hooksEnabled) {
+    if (!hooksEnabled)
+        return onEvent;
+    const engine = new HookEngine(workspaceId);
+    engine.load();
+    const toolNameById = new Map();
+    return (event) => {
+        onEvent(event);
+        if (event.type === 'tool_use') {
+            toolNameById.set(event.id, event.name);
+            engine.executeHooks('PreToolUse', event.name, { toolInput: event.input });
+        }
+        if (event.type === 'tool_result') {
+            const toolName = event.toolUseId ? (toolNameById.get(event.toolUseId) ?? '') : '';
+            if (toolName) {
+                engine.executeHooks('PostToolUse', toolName, { toolResult: event.result });
+            }
+        }
+    };
+}
+//# sourceMappingURL=hook-engine.js.map

package/dist/services/issue.js

@@ -35,6 +35,10 @@ function ensureRetryDefaults(workspaceId, issue) {
         issue.maxRetries = 3;
         changed = true;
     }
+    if (issue.continuousRun === undefined) {
+        issue.continuousRun = true;
+        changed = true;
+    }
     if (changed)
         updateIssue({ ...issue, workspaceId });
 }
@@ -70,6 +74,7 @@ export function create(workspaceId, input) {
         tasks: [],
         members: input.members || [],
         workflowId: input.workflowId,
+        continuousRun: true,
         retryCount: 0,
         maxRetries: 3,
         createdAt: now,
@@ -94,6 +99,7 @@ export function createForChannel(workspaceId, channelId, input) {
         status: input.status ?? 'draft',
         tasks: [],
         members: [...issueMembers],
+        continuousRun: true,
         retryCount: 0,
         maxRetries: 3,
         createdAt: now,

package/dist/services/notification-hub/bot-agent.js

@@ -41,6 +41,7 @@ export async function runBotAgent(workspaceId, preset, message) {
             configDir: agentService.getAgentConfigDir(workspaceId, preset),
             sandboxDirs: preset.sandboxDirs,
             systemPrompt: preset.systemPrompt,
+            outputStyle: preset.outputStyle,
         });
         agentService.complete(workspaceId, session.id, result.success ? undefined : result.error || result.summary, {
             runtime: preset.runtimeKind,

package/dist/services/output-style.js

@@ -0,0 +1,134 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { ensureDir, getDataDir } from '../storage/json-store.js';
+import { listTemplates } from './agent.js';
+function getDir() {
+    return join(getDataDir(), 'output-styles');
+}
+function getMetaPath() {
+    return join(getDir(), 'meta.json');
+}
+function readMeta() {
+    const path = getMetaPath();
+    if (!existsSync(path))
+        return { templates: [] };
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { templates: [] };
+    }
+}
+function writeMeta(meta) {
+    ensureDir(getDir());
+    writeFileSync(getMetaPath(), JSON.stringify(meta, null, 2), 'utf-8');
+}
+export function listOutputStyles() {
+    return readMeta().templates;
+}
+export function resolveOutputStyleTemplate(ref) {
+    const needle = sanitizeOutputStyleName(ref);
+    if (!needle)
+        return null;
+    return listOutputStyles().find((template) => template.id === ref?.trim()
+        || template.name === ref?.trim()
+        || sanitizeOutputStyleName(template.name) === needle) ?? null;
+}
+export function resolveOutputStyleContent(ref) {
+    const raw = ref?.trim();
+    if (!raw)
+        return undefined;
+    return resolveOutputStyleTemplate(raw)?.content ?? raw;
+}
+export function prepareClaudeOutputStyleFile(configDir, ref) {
+    const raw = ref?.trim();
+    if (!raw)
+        return undefined;
+    const template = resolveOutputStyleTemplate(raw);
+    const content = template?.content ?? raw;
+    const fileStem = sanitizeOutputStyleName(template?.name) || `output-style-${shortHash(content)}`;
+    if (!fileStem)
+        return undefined;
+    const dir = join(configDir, 'output_styles');
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${fileStem}.md`), `${content.trimEnd()}\n`, 'utf-8');
+    return fileStem;
+}
+export function createOutputStyle(name, content, storeId, description) {
+    const meta = readMeta();
+    const now = new Date().toISOString();
+    const id = `os-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const tmpl = { id, name, description, content, storeId, createdAt: now, updatedAt: now };
+    meta.templates.push(tmpl);
+    writeMeta(meta);
+    return tmpl;
+}
+export function updateOutputStyle(id, data) {
+    const meta = readMeta();
+    const tmpl = meta.templates.find((t) => t.id === id);
+    if (!tmpl)
+        return null;
+    if (data.name !== undefined)
+        tmpl.name = data.name;
+    if (data.description !== undefined)
+        tmpl.description = data.description;
+    if (data.content !== undefined)
+        tmpl.content = data.content;
+    tmpl.updatedAt = new Date().toISOString();
+    writeMeta(meta);
+    return tmpl;
+}
+export function deleteOutputStyle(id) {
+    const meta = readMeta();
+    const idx = meta.templates.findIndex((t) => t.id === id);
+    if (idx < 0)
+        return false;
+    meta.templates.splice(idx, 1);
+    writeMeta(meta);
+    return true;
+}
+export function applyOutputStyleToAgents(styleId, agentIds) {
+    const meta = readMeta();
+    const tmpl = meta.templates.find((t) => t.id === styleId);
+    if (!tmpl)
+        return 0;
+    const agents = listTemplates();
+    let applied = 0;
+    for (const agentId of agentIds) {
+        const agent = agents.find((a) => a.id === agentId);
+        if (!agent)
+            continue;
+        const agentDir = join(getDataDir(), 'agent-templates', agent.id);
+        const agentPath = join(agentDir, 'agent.json');
+        if (!existsSync(agentPath))
+            continue;
+        const config = JSON.parse(readFileSync(agentPath, 'utf-8'));
+        config.outputStyle = tmpl.name;
+        writeFileSync(agentPath, JSON.stringify(config, null, 2), 'utf-8');
+        applied++;
+    }
+    return applied;
+}
+export function listOutputStyleAgentCandidates() {
+    return listTemplates()
+        .filter((a) => a.id !== 'agent-generator')
+        .map((a) => ({
+        id: a.id,
+        name: a.name || a.id,
+        avatarUrl: a.avatarUrl,
+        description: a.description,
+        hasOutputStyle: !!a.outputStyle,
+    }));
+}
+function sanitizeOutputStyleName(name) {
+    const raw = name?.trim();
+    if (!raw)
+        return '';
+    return basename(raw).replace(/\.md$/i, '').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function shortHash(text) {
+    return createHash('sha1').update(text).digest('hex').slice(0, 8);
+}
+//# sourceMappingURL=output-style.js.map

package/dist/services/persistent-agent-context.js

@@ -1,6 +1,6 @@
 import { existsSync, realpathSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { getDataDir } from '../storage/json-store.js';
 import { readWorkspacePrompt } from './workspace-prompt.js';
 const INSTRUCTION_FILENAMES = ['CLAUDE.md', 'claude.md', 'AGENTS.md', 'agents.md'];
@@ -13,10 +13,8 @@ export function prependPersistentAgentContext(prompt, options) {
     return `${context}\n\n${prompt}`;
 }
 export function buildPersistentAgentContext(options) {
+    const { instructionContext } = buildPersistentAgentContextDetails(options);
     const sections = [];
-    const instructionContext = buildInstructionFileContext(options.workingDir, options.boundDirs, {
-        excludeNativeClaudeMd: options.excludeNativeClaudeMd,
-    });
     if (instructionContext)
         sections.push(instructionContext);
     if (options.includeWorkspacePrompt !== false) {
@@ -30,8 +28,20 @@ export function buildPersistentAgentContext(options) {
     }
     return sections.join('\n\n');
 }
+export function buildPersistentAgentContextDetails(options) {
+    const instructionFiles = collectInstructionFiles(options.workingDir, options.boundDirs, {
+        excludeNativeClaudeMd: options.excludeNativeClaudeMd,
+    });
+    return {
+        instructionContext: buildInstructionFileContextFromFiles(instructionFiles),
+        summary: buildPersistentAgentContextSummary(instructionFiles),
+    };
+}
 function buildInstructionFileContext(workingDir, boundDirs, options = {}) {
     const files = collectInstructionFiles(workingDir, boundDirs, options);
+    return buildInstructionFileContextFromFiles(files);
+}
+function buildInstructionFileContextFromFiles(files) {
     if (files.length === 0)
         return '';
     const lines = [
@@ -51,6 +61,28 @@ function buildInstructionFileContext(workingDir, boundDirs, options = {}) {
     }
     return lines.join('\n').trim();
 }
+function buildPersistentAgentContextSummary(files) {
+    const instructionFiles = files.map((file) => ({
+        path: file.path,
+        label: file.label,
+        filename: file.filename,
+    }));
+    const counts = instructionFiles.reduce((acc, file) => {
+        acc.total += 1;
+        if (file.filename === 'CLAUDE.md' || file.filename === 'claude.md') {
+            acc.claudeMd += 1;
+        }
+        if (file.filename === 'AGENTS.md' || file.filename === 'agents.md') {
+            acc.agentsMd += 1;
+        }
+        return acc;
+    }, {
+        claudeMd: 0,
+        agentsMd: 0,
+        total: 0,
+    });
+    return { instructionFiles, counts };
+}
 function collectInstructionFiles(workingDir, boundDirs, options = {}) {
     const cwd = resolve(workingDir || process.cwd());
     const seen = new Set();
@@ -125,6 +157,7 @@ function addInstructionFile(files, seen, path, label) {
     files.push({
         path: realPath,
         label,
+        filename: basename(realPath),
         content: readFileSync(path, 'utf-8').trim(),
     });
 }

package/dist/services/prompt-template.js

@@ -26,11 +26,11 @@ function writeMeta(meta) {
 export function listPromptTemplates() {
     return readMeta().templates;
 }
-export function createPromptTemplate(name, content) {
+export function createPromptTemplate(name, content, storeId) {
     const meta = readMeta();
     const now = new Date().toISOString();
     const id = `prompt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const tmpl = { id, name, content, createdAt: now, updatedAt: now };
+    const tmpl = { id, name, content, storeId, createdAt: now, updatedAt: now };
     meta.templates.push(tmpl);
     writeMeta(meta);
     return tmpl;