@agent-spaces/server 0.3.62 → 0.3.63

package/dist/routes/issue.js

@@ -8,6 +8,7 @@ import * as agentService from '../services/agent.js';
 import * as taskService from '../services/task.js';
 import { retryIssue } from '../services/issue-retry.js';
 import { hasActiveIssueAutomation, runIssueAutomation } from '../agents/issue-agent-runner.js';
+import { continueIssueTaskScheduling, stopIssueAutomation } from '../agents/issue-task-controller.js';
 import * as workflowService from '../services/workflow.js';
 const router = Router({ mergeParams: true });
 router.get('/', (req, res) => {
@@ -48,13 +49,15 @@ router.put('/:issueId', (req, res) => {
         return;
     }
     const previousStatus = issue.status;
-    const { title, description, status, members, workflowId } = req.body;
+    const { title, description, status, members, workflowId, continuousRun } = req.body;
     if (title)
         issue.title = title;
     if (description !== undefined)
         issue.description = description;
     if (workflowId !== undefined)
         issue.workflowId = workflowId || undefined;
+    if (continuousRun !== undefined)
+        issue.continuousRun = continuousRun !== false;
     if (members !== undefined) {
         issue.members = normalizeIssueMembers(req.params.id, mergeWorkflowMembers(members, issue.workflowId));
     }
@@ -142,6 +145,61 @@ router.post('/:issueId/resume', async (req, res) => {
     }
     res.json(result.issue);
 });
+router.post('/:issueId/continue', (req, res) => {
+    const workspaceId = req.params.id;
+    const { issueId } = req.params;
+    const before = issueService.getById(workspaceId, issueId);
+    if (!before) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    const issue = before.status === 'draft' || before.status === 'planned'
+        ? issueService.updateStatus(workspaceId, issueId, 'in_progress')
+        : before;
+    if (!issue) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    if (issue.status !== before.status) {
+        broadcastToWorkspace(workspaceId, 'issue.status_changed', { issueId, from: before.status, to: issue.status });
+    }
+    broadcastToWorkspace(workspaceId, 'issue.updated', issue);
+    res.json(issue);
+    const ctx = {
+        workspaceId,
+        broadcast: (event, data) => broadcastToWorkspace(workspaceId, event, data),
+        getSession: (sessionId) => agentService.getById(workspaceId, sessionId),
+        updateSessionStatus: (sessionId, status, extra) => agentService.updateStatus(workspaceId, sessionId, status, extra),
+    };
+    continueIssueTaskScheduling(workspaceId, issueId, ctx).catch((err) => {
+        console.error(`[issue-continue] scheduling error for issue ${issueId}:`, err);
+    });
+});
+router.post('/:issueId/interrupt', (req, res) => {
+    const workspaceId = req.params.id;
+    const { issueId } = req.params;
+    const before = issueService.getById(workspaceId, issueId);
+    if (!before) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    const reason = 'Interrupted by user';
+    const failedTasks = stopIssueAutomation(workspaceId, issueId, reason);
+    for (const { task, from } of failedTasks) {
+        broadcastToWorkspace(workspaceId, 'task.status_changed', { taskId: task.id, from, to: task.status });
+        broadcastToWorkspace(workspaceId, 'task.updated', task);
+    }
+    if (before.channelId)
+        stopChannelRuns(workspaceId, before.channelId);
+    const issue = issueService.markError(workspaceId, issueId, reason);
+    if (!issue) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    broadcastToWorkspace(workspaceId, 'issue.status_changed', { issueId, from: before.status, to: 'error' });
+    broadcastToWorkspace(workspaceId, 'issue.updated', issue);
+    res.json(issue);
+});
 router.delete('/:issueId', (req, res) => {
     const { id, issueId } = req.params;
     const issue = issueService.getById(id, issueId);

package/dist/routes/output-style.js

@@ -0,0 +1,48 @@
+import { Router } from 'express';
+import { listOutputStyles, createOutputStyle, updateOutputStyle, deleteOutputStyle, applyOutputStyleToAgents, listOutputStyleAgentCandidates, } from '../services/output-style.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(listOutputStyles());
+});
+router.get('/agents', (_req, res) => {
+    res.json(listOutputStyleAgentCandidates());
+});
+router.post('/', (req, res) => {
+    const { name, content, storeId, description } = req.body;
+    if (!name || !content) {
+        res.status(400).json({ error: 'name and content required' });
+        return;
+    }
+    res.json(createOutputStyle(name, content, storeId, description));
+});
+router.put('/:id', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const data = req.body;
+    const tmpl = updateOutputStyle(id, data);
+    if (!tmpl) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json(tmpl);
+});
+router.delete('/:id', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const ok = deleteOutputStyle(id);
+    if (!ok) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.post('/:id/apply', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const { agentIds } = req.body;
+    if (!agentIds?.length) {
+        res.status(400).json({ error: 'agentIds required' });
+        return;
+    }
+    const applied = applyOutputStyleToAgents(id, agentIds);
+    res.json({ applied });
+});
+export default router;
+//# sourceMappingURL=output-style.js.map

package/dist/routes/prompt-template.js

@@ -5,12 +5,12 @@ router.get('/', (_req, res) => {
     res.json(listPromptTemplates());
 });
 router.post('/', (req, res) => {
-    const { name, content } = req.body;
+    const { name, content, storeId } = req.body;
     if (!name || !content) {
         res.status(400).json({ error: 'name and content required' });
         return;
     }
-    res.json(createPromptTemplate(name, content));
+    res.json(createPromptTemplate(name, content, storeId));
 });
 router.put('/:id', (req, res) => {
     const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];

package/dist/routes/skill.js

@@ -1,5 +1,9 @@
 import { Router } from 'express';
-import { listSkills, importSkill, importSkillsBatch, toggleFavorite, toggleEnabled, toggleAllEnabled, updateSkillContent, deleteSkill, checkSkillSync, syncSkills } from '../services/skill.js';
+import { exec } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { listSkills, importSkill, importSkillsBatch, importSkillFromStore, toggleFavorite, updateSkillContent, deleteSkill, checkSkillSync, syncSkills, importSkillsFromGit, listSkillFiles, readSkillFile, writeSkillFile } from '../services/skill.js';
+import { getDataDir } from '../storage/json-store.js';
 const router = Router();
 router.get('/', (_req, res) => {
     res.json(listSkills());
@@ -34,25 +38,38 @@ router.post('/import-batch', (req, res) => {
     const skills = importSkillsBatch(items);
     res.json(skills);
 });
+router.post('/import-store', (req, res) => {
+    const { path, group } = req.body;
+    if (!path) {
+        res.status(400).json({ error: 'path required' });
+        return;
+    }
+    const skill = importSkillFromStore(path, group || '');
+    if (!skill) {
+        res.status(404).json({ error: 'Store skill not found' });
+        return;
+    }
+    res.json(skill);
+});
+router.post('/import-git', (req, res) => {
+    const { url } = req.body;
+    if (!url) {
+        res.status(400).json({ error: 'url required' });
+        return;
+    }
+    try {
+        const skills = importSkillsFromGit(url);
+        res.json(skills);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message || 'Git clone failed' });
+    }
+});
 router.post('/:name/favorite', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const favorited = toggleFavorite(name);
     res.json({ favorited });
 });
-router.post('/:name/toggle', (req, res) => {
-    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
-    const enabled = toggleEnabled(name);
-    res.json({ enabled });
-});
-router.post('/toggle-all', (req, res) => {
-    const { names, enabled } = req.body;
-    if (!Array.isArray(names) || typeof enabled !== 'boolean') {
-        res.status(400).json({ error: 'names and enabled required' });
-        return;
-    }
-    toggleAllEnabled(names, enabled);
-    res.json({ success: true });
-});
 router.put('/:name', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const { content } = req.body;
@@ -67,6 +84,60 @@ router.put('/:name', (req, res) => {
     }
     res.json({ success: true });
 });
+router.get('/:name/files', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const files = listSkillFiles(name);
+    res.json(files);
+});
+router.get('/:name/files/{*filePath}', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const filePath = Array.isArray(req.params.filePath) ? req.params.filePath.join('/') : req.params.filePath;
+    if (!filePath) {
+        res.status(400).json({ error: 'file path required' });
+        return;
+    }
+    const content = readSkillFile(name, filePath);
+    if (content === null) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+    }
+    res.json({ content });
+});
+router.put('/:name/files/{*filePath}', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const filePath = Array.isArray(req.params.filePath) ? req.params.filePath.join('/') : req.params.filePath;
+    const { content } = req.body;
+    if (!filePath || content === undefined) {
+        res.status(400).json({ error: 'file path and content required' });
+        return;
+    }
+    const ok = writeSkillFile(name, filePath, content);
+    if (!ok) {
+        res.status(400).json({ error: 'Failed to write file' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.post('/:name/reveal', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const skillDir = join(getDataDir(), 'skills', name);
+    if (!existsSync(skillDir)) {
+        res.status(404).json({ error: 'Skill folder not found' });
+        return;
+    }
+    const cmd = process.platform === 'darwin'
+        ? `open "${skillDir}"`
+        : process.platform === 'win32'
+            ? `explorer "${skillDir}"`
+            : `xdg-open "${skillDir}"`;
+    exec(cmd, (err) => {
+        if (err) {
+            res.status(500).json({ error: 'Failed to reveal', detail: err.message });
+            return;
+        }
+        res.json({ ok: true, path: skillDir });
+    });
+});
 router.delete('/:name', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const ok = deleteSkill(name);

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/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/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;