@agent-spaces/server 0.3.64 → 0.3.67

package/dist/services/hook-engine.js

@@ -1,5 +1,12 @@
 import { exec } from 'node:child_process';
 import { listHooks } from '../storage/hook-store.js';
+function logDebug(message, details) {
+    if (details) {
+        console.debug(`[HookEngine] ${message}`, details);
+        return;
+    }
+    console.debug(`[HookEngine] ${message}`);
+}
 function matchToolName(matcher, toolName) {
     if (matcher === '*')
         return true;
@@ -8,7 +15,12 @@ function matchToolName(matcher, toolName) {
             const regex = new RegExp(matcher.slice(1, -1));
             return regex.test(toolName);
         }
-        catch {
+        catch (error) {
+            console.warn(`[HookEngine] invalid matcher regex, falling back to exact match`, {
+                matcher,
+                toolName,
+                error: error.message,
+            });
             return matcher === toolName;
         }
     }
@@ -16,7 +28,8 @@ function matchToolName(matcher, toolName) {
 }
 function executeCommand(command, env, timeout) {
     return new Promise((resolve) => {
-        exec(command, { env: { ...process.env, ...env }, timeout: Math.min(timeout, 30000) }, (error) => {
+        const cappedTimeout = Math.min(timeout, 30000);
+        exec(command, { env: { ...process.env, ...env }, timeout: cappedTimeout }, (error) => {
             if (error)
                 console.warn(`[HookEngine] command error: ${error.message}`);
             resolve();
@@ -26,43 +39,101 @@ function executeCommand(command, env, timeout) {
 async function executeWebhook(url, body, timeout) {
     try {
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), Math.min(timeout, 30000));
-        await fetch(url, {
+        const cappedTimeout = Math.min(timeout, 30000);
+        const timer = setTimeout(() => controller.abort(), cappedTimeout);
+        const response = await fetch(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(body),
             signal: controller.signal,
         });
         clearTimeout(timer);
+        if (!response.ok) {
+            console.warn(`[HookEngine] webhook non-2xx response`, {
+                url,
+                status: response.status,
+                statusText: response.statusText,
+            });
+        }
     }
     catch (error) {
         console.warn(`[HookEngine] webhook error: ${error.message}`);
     }
 }
-async function executeRule(rule, phase, toolName, workspaceId, context) {
+async function executeRule(rule, phase, matcherValue, workspaceId, context, hookName) {
     const timeout = rule.timeout ?? 10000;
+    const startedAt = Date.now();
+    logDebug('rule start', {
+        workspaceId,
+        phase,
+        hookName,
+        matcherValue,
+        matcher: rule.matcher,
+        type: rule.type,
+        timeout,
+    });
     if (rule.type === 'command' && rule.command) {
         await executeCommand(rule.command, {
-            HOOK_TOOL_NAME: toolName,
+            HOOK_NAME: hookName ?? '',
+            HOOK_RULE_MATCHER: rule.matcher,
+            HOOK_RULE_TYPE: rule.type,
+            HOOK_RULE_TIMEOUT: String(timeout),
+            HOOK_EVENT_NAME: context.eventName ?? phase,
+            HOOK_EVENT_PAYLOAD: JSON.stringify(context.eventPayload ?? {}),
+            HOOK_MATCHER_VALUE: matcherValue,
+            HOOK_TOOL_NAME: matcherValue,
+            HOOK_TOOL_USE_ID: context.toolUseId ?? '',
             HOOK_TOOL_INPUT: JSON.stringify(context.toolInput ?? {}),
             HOOK_TOOL_RESULT: JSON.stringify(context.toolResult ?? ''),
             HOOK_WORKSPACE_ID: workspaceId,
             HOOK_PHASE: phase,
+            HOOK_TRIGGER_CHECKED_RULES: String(context.checkedRules ?? ''),
+            HOOK_TRIGGER_MATCHED_RULES: String(context.matchedRules ?? ''),
+            HOOK_TRIGGERED_AT: new Date().toISOString(),
         }, timeout);
     }
     else if (rule.type === 'webhook' && rule.url) {
         await executeWebhook(rule.url, {
             event: phase,
-            toolName,
+            toolName: matcherValue,
+            matcherValue,
             toolInput: context.toolInput,
             toolResult: context.toolResult ?? undefined,
+            payload: context.eventPayload,
             timestamp: new Date().toISOString(),
             workspaceId,
         }, timeout);
     }
     else if (rule.type === 'script') {
-        console.warn(`[HookEngine] script type not implemented, skipping rule in ${phase}`);
+        console.warn(`[HookEngine] script type not implemented, skipping rule`, {
+            workspaceId,
+            phase,
+            hookName,
+            matcherValue,
+            matcher: rule.matcher,
+        });
     }
+    else {
+        console.warn(`[HookEngine] invalid rule configuration, skipping rule`, {
+            workspaceId,
+            phase,
+            hookName,
+            matcherValue,
+            matcher: rule.matcher,
+            type: rule.type,
+            hasCommand: Boolean(rule.command),
+            hasUrl: Boolean(rule.url),
+        });
+    }
+    logDebug('rule finished', {
+        workspaceId,
+        phase,
+        hookName,
+        matcherValue,
+        matcher: rule.matcher,
+        type: rule.type,
+        durationMs: Date.now() - startedAt,
+    });
 }
 export class HookEngine {
     hooks = [];
@@ -72,6 +143,12 @@ export class HookEngine {
     }
     load() {
         this.hooks = listHooks(this.workspaceId);
+        logDebug('loaded hooks', {
+            workspaceId: this.workspaceId,
+            totalHooks: this.hooks.length,
+            enabledHooks: this.hooks.filter(h => h.enabled).length,
+            hookNames: this.hooks.map(h => h.name),
+        });
     }
     reload() {
         this.load();
@@ -79,40 +156,121 @@ export class HookEngine {
     getHooks() {
         return this.hooks;
     }
-    async executeHooks(phase, toolName, context) {
+    async executeHooks(phase, matcherValue, context) {
         const enabledHooks = this.hooks.filter(h => h.enabled);
         const promises = [];
+        const matchedRuleEntries = [];
+        let checkedRules = 0;
+        let matchedRules = 0;
+        logDebug('trigger received', {
+            workspaceId: this.workspaceId,
+            phase,
+            matcherValue,
+            totalHooks: this.hooks.length,
+            enabledHooks: enabledHooks.length,
+            hasToolInput: context.toolInput !== undefined,
+            hasToolResult: context.toolResult !== undefined,
+        });
         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));
+                checkedRules += 1;
+                if (matchToolName(rule.matcher, matcherValue)) {
+                    matchedRules += 1;
+                    logDebug('rule matched', {
+                        workspaceId: this.workspaceId,
+                        phase,
+                        hookName: hook.name,
+                        matcherValue,
+                        matcher: rule.matcher,
+                        type: rule.type,
+                    });
+                    matchedRuleEntries.push({ hookName: hook.name, rule });
                 }
             }
         }
-        await Promise.allSettled(promises);
+        for (const { hookName, rule } of matchedRuleEntries) {
+            promises.push(executeRule(rule, phase, matcherValue, this.workspaceId, {
+                ...context,
+                checkedRules,
+                matchedRules,
+            }, hookName));
+        }
+        const results = await Promise.allSettled(promises);
+        const rejectedRules = results.filter(result => result.status === 'rejected').length;
+        logDebug('trigger finished', {
+            workspaceId: this.workspaceId,
+            phase,
+            matcherValue,
+            checkedRules,
+            matchedRules,
+            rejectedRules,
+        });
     }
 }
 export function wrapOnEventWithHooks(onEvent, workspaceId, hooksEnabled) {
-    if (!hooksEnabled)
+    if (!hooksEnabled) {
+        logDebug('hooks disabled for workspace', { workspaceId });
         return onEvent;
+    }
     const engine = new HookEngine(workspaceId);
     engine.load();
     const toolNameById = new Map();
+    let lastToolUse = null;
     return (event) => {
-        onEvent(event);
+        if (event.type !== 'hook_event')
+            onEvent(event);
         if (event.type === 'tool_use') {
             toolNameById.set(event.id, event.name);
-            engine.executeHooks('PreToolUse', event.name, { toolInput: event.input });
+            lastToolUse = { id: event.id, name: event.name };
+            logDebug('tool_use event mapped', {
+                workspaceId,
+                toolUseId: event.id,
+                toolName: event.name,
+            });
+            engine.executeHooks('PreToolUse', event.name, { toolInput: event.input, toolUseId: event.id });
         }
         if (event.type === 'tool_result') {
-            const toolName = event.toolUseId ? (toolNameById.get(event.toolUseId) ?? '') : '';
+            const resolvedToolUseId = event.toolUseId || lastToolUse?.id;
+            const toolName = resolvedToolUseId ? (toolNameById.get(resolvedToolUseId) ?? '') : '';
             if (toolName) {
-                engine.executeHooks('PostToolUse', toolName, { toolResult: event.result });
+                logDebug('tool_result event resolved', {
+                    workspaceId,
+                    toolUseId: resolvedToolUseId,
+                    originalToolUseId: event.toolUseId,
+                    toolName,
+                });
+                engine.executeHooks('PostToolUse', toolName, { toolResult: event.result, toolUseId: resolvedToolUseId });
+                if (isToolFailureResult(event.result)) {
+                    engine.executeHooks('PostToolUseFailure', toolName, { toolResult: event.result, toolUseId: resolvedToolUseId });
+                }
+            }
+            else {
+                logDebug('tool_result event skipped without matching tool_use', {
+                    workspaceId,
+                    toolUseId: event.toolUseId,
+                });
             }
         }
+        if (event.type === 'hook_event') {
+            logDebug('hook_event received', {
+                workspaceId,
+                event: event.event,
+                matcher: event.matcher ?? '*',
+            });
+            engine.executeHooks(event.event, event.matcher ?? '*', {
+                eventName: event.event,
+                eventPayload: event.payload,
+            });
+        }
     };
 }
+function isToolFailureResult(result) {
+    if (!result || typeof result !== 'object')
+        return false;
+    const record = result;
+    return record.error !== undefined || record.is_error === true || record.success === false;
+}
 //# sourceMappingURL=hook-engine.js.map

package/dist/services/notification-center.js

@@ -46,6 +46,15 @@ export function clearAll(workspaceId) {
     writeAll(workspaceId, []);
     broadcastToWorkspace(workspaceId, 'notification.cleared', null);
 }
+export function removeNotification(workspaceId, notificationId) {
+    const all = readAll(workspaceId);
+    const idx = all.findIndex((n) => n.id === notificationId);
+    if (idx === -1)
+        return null;
+    const [removed] = all.splice(idx, 1);
+    writeAll(workspaceId, all);
+    return removed;
+}
 export function unreadCount(workspaceId) {
     return readAll(workspaceId).filter((n) => !n.read).length;
 }

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

@@ -28,7 +28,8 @@ export async function runBotAgent(workspaceId, preset, message) {
     const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
     const workspace = workspaceService.getById(workspaceId);
     try {
-        const result = await runtime.execute(prependPersistentAgentContext(buildBotPrompt(message), {
+        const userPrompt = buildBotPrompt(message);
+        const result = await runtime.execute(prependPersistentAgentContext(userPrompt, {
             workspaceId,
             workingDir,
             boundDirs: workspace?.boundDirs,
@@ -36,6 +37,7 @@ export async function runBotAgent(workspaceId, preset, message) {
             excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
         }), workingDir, {
             maxTurns: 20,
+            userPrompt,
             mcpServers: agentService.getMcpServers(preset.mcps),
             skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, preset), preset.skills),
             configDir: agentService.getAgentConfigDir(workspaceId, preset),

package/dist/services/notification-hub/service.js

@@ -1,4 +1,5 @@
 import * as workspaceService from '../workspace.js';
+import { resolveCredentials } from '../robot-account.js';
 import { adapters } from './types.js';
 import { persistServiceRunning } from './helpers.js';
 import { WeChatNotificationAdapter } from './wechat-adapter.js';
@@ -9,15 +10,24 @@ export async function startWorkspaceNotificationService(workspaceId) {
     if (!workspace || !settings?.enabled)
         return { started: false };
     await stopWorkspaceNotificationService(workspaceId);
+    const credentials = resolveCredentials(settings);
     if (settings.provider === 'lark') {
-        const adapter = new LarkNotificationAdapter(workspace, settings);
+        if (!credentials || credentials.type !== 'lark') {
+            throw new Error('Lark credentials not found. Link a Robot Account or configure appId/appSecret.');
+        }
+        const mergedSettings = { ...settings, lark: { ...settings.lark, appId: credentials.appId, appSecret: credentials.appSecret } };
+        const adapter = new LarkNotificationAdapter(workspace, mergedSettings);
         await adapter.start();
         adapters.set(workspaceId, adapter);
         persistServiceRunning(workspaceId, true);
         return { started: true, provider: 'lark' };
     }
     if (settings.provider === 'wechat') {
-        const adapter = new WeChatNotificationAdapter(workspace, settings);
+        if (!credentials || credentials.type !== 'wechat') {
+            throw new Error('WeChat credentials not found. Link a Robot Account or scan QR code first.');
+        }
+        const mergedSettings = { ...settings, wechat: { ...settings.wechat, token: credentials.token, baseUrl: credentials.baseUrl, accountId: credentials.accountId, userId: credentials.userId } };
+        const adapter = new WeChatNotificationAdapter(workspace, mergedSettings);
         await adapter.start();
         adapters.set(workspaceId, adapter);
         persistServiceRunning(workspaceId, true);

package/dist/services/robot-account.js

@@ -0,0 +1,34 @@
+import { v4 as uuid } from 'uuid';
+import { listRobotAccounts, getRobotAccount, createRobotAccount, updateRobotAccount, deleteRobotAccount } from '../storage/robot-account-store.js';
+export { listRobotAccounts, getRobotAccount, deleteRobotAccount };
+export function createAccount(input) {
+    const now = new Date().toISOString();
+    const account = { id: uuid(), name: input.name, type: input.type, lark: input.lark, wechat: input.wechat, createdAt: now, updatedAt: now };
+    createRobotAccount(account);
+    return account;
+}
+export function updateAccount(id, patch) {
+    return updateRobotAccount(id, patch);
+}
+export function resolveCredentials(settings) {
+    if (settings.robotAccountId) {
+        const account = getRobotAccount(settings.robotAccountId);
+        if (account) {
+            if (account.type === 'lark' && account.lark) {
+                return { type: 'lark', appId: account.lark.appId, appSecret: account.lark.appSecret };
+            }
+            if (account.type === 'wechat' && account.wechat) {
+                return { type: 'wechat', token: account.wechat.token, baseUrl: account.wechat.baseUrl || 'https://qyapi.weixin.qq.com', accountId: account.wechat.accountId, userId: account.wechat.userId };
+            }
+        }
+    }
+    // fallback to inline credentials
+    if (settings.provider === 'lark' && settings.lark?.appId && settings.lark?.appSecret) {
+        return { type: 'lark', appId: settings.lark.appId, appSecret: settings.lark.appSecret };
+    }
+    if (settings.provider === 'wechat' && settings.wechat?.token && settings.wechat?.accountId) {
+        return { type: 'wechat', token: settings.wechat.token, baseUrl: settings.wechat.baseUrl || 'https://qyapi.weixin.qq.com', accountId: settings.wechat.accountId, userId: settings.wechat.userId };
+    }
+    return null;
+}
+//# sourceMappingURL=robot-account.js.map

package/dist/services/version.js

@@ -0,0 +1,59 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let localVersion = '';
+let cachedLatest = null;
+const CACHE_TTL = 3600_000; // 1 hour
+export function getLocalVersion() {
+    if (localVersion !== '')
+        return localVersion;
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+        localVersion = pkg.version || '0.0.0';
+    }
+    catch {
+        localVersion = '0.0.0';
+    }
+    return localVersion;
+}
+export function getCachedLatest() {
+    if (cachedLatest && Date.now() - cachedLatest.ts < CACHE_TTL) {
+        return cachedLatest.version;
+    }
+    return null;
+}
+export async function fetchLatestVersion(forceRefresh = false) {
+    if (!forceRefresh && cachedLatest && Date.now() - cachedLatest.ts < CACHE_TTL) {
+        return cachedLatest.version;
+    }
+    try {
+        const res = await fetch('https://registry.npmjs.org/@agent-spaces/server', {
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok)
+            return cachedLatest?.version ?? null;
+        const data = await res.json();
+        const latest = data?.['dist-tags']?.latest;
+        if (latest) {
+            cachedLatest = { version: latest, ts: Date.now() };
+        }
+        return latest ?? cachedLatest?.version ?? null;
+    }
+    catch {
+        return cachedLatest?.version ?? null;
+    }
+}
+export function isNewerVersion(latest, local) {
+    const parse = (v) => v.replace(/^v/, '').split('.').map(Number);
+    const a = parse(latest);
+    const b = parse(local);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) > (b[i] || 0))
+            return true;
+        if ((a[i] || 0) < (b[i] || 0))
+            return false;
+    }
+    return false;
+}
+//# sourceMappingURL=version.js.map

package/dist/services/workflow-command-runner.js

@@ -0,0 +1,23 @@
+import { exec } from 'child_process';
+import { getWorkspace } from '../storage/workspace-store.js';
+export async function executeCommandNode(workspaceId, node) {
+    const workspace = getWorkspace(workspaceId);
+    const cwd = node.data.cwd || workspace?.boundDirs?.[0] || process.cwd();
+    return new Promise((resolve) => {
+        exec(node.data.script, {
+            cwd,
+            env: { ...process.env, ...node.data.env },
+            shell: node.data.shell || undefined,
+            timeout: 300_000,
+            maxBuffer: 10 * 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            resolve({
+                success: !error,
+                exitCode: error ? (typeof error.code === 'number' ? error.code : 1) : 0,
+                stdout: stdout || '',
+                stderr: stderr || '',
+            });
+        });
+    });
+}
+//# sourceMappingURL=workflow-command-runner.js.map

package/dist/services/workflow.js

@@ -72,6 +72,8 @@ function resolveStaleRoles(nodes) {
     const agentMap = new Map(listTemplates().map(a => [a.id, a]));
     const invalidIds = [];
     const resolved = nodes.map(node => {
+        if (node.type === 'command')
+            return node;
         const agent = agentMap.get(node.data.agentConfigId);
         if (!agent) {
             invalidIds.push(node.id);
@@ -177,19 +179,34 @@ export function mapWorkflowToTaskDrafts(template) {
     for (const edge of template.edges) {
         dependsOn.get(edge.target)?.push(edge.source);
     }
-    return template.nodes.map(node => ({
-        key: node.id,
-        title: node.data.taskTitleTemplate || node.data.label,
-        description: node.data.taskDescriptionTemplate || `Task assigned to ${node.data.label} (${node.data.role})`,
-        agentConfigId: node.data.agentConfigId,
-        dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
-        sandboxDirs: undefined,
-    }));
+    return template.nodes.map(node => {
+        if (node.type === 'command') {
+            return {
+                key: node.id,
+                title: node.data.label,
+                description: `Run command: ${node.data.label}`,
+                agentConfigId: undefined,
+                dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
+                sandboxDirs: undefined,
+                commandNode: node,
+            };
+        }
+        return {
+            key: node.id,
+            title: node.data.taskTitleTemplate || node.data.label,
+            description: node.data.taskDescriptionTemplate || `Task assigned to ${node.data.label} (${node.data.role})`,
+            agentConfigId: node.data.agentConfigId,
+            dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
+            sandboxDirs: undefined,
+        };
+    });
 }
 // --- Run-time Validation ---
 export function validateWorkflowForRun(_workspaceId, template, memberAgentIds) {
     const agentMap = new Map(listTemplates().map((a) => [a.id, a]));
     for (const node of template.nodes) {
+        if (node.type === 'command')
+            continue;
         const agent = agentMap.get(node.data.agentConfigId);
         if (!agent)
             return `Agent "${node.data.label}" (${node.data.agentConfigId}) no longer exists`;

package/dist/services/workspace.js

@@ -1,5 +1,6 @@
 import { v4 as uuid } from 'uuid';
 import { listWorkspaces, getWorkspace, createWorkspace, updateWorkspace, deleteWorkspace } from '../storage/workspace-store.js';
+import { listWorktrees } from '../storage/worktree-store.js';
 import { ensureDir } from '../storage/json-store.js';
 import { join } from 'node:path';
 import { existsSync, writeFileSync } from 'node:fs';
@@ -21,7 +22,14 @@ function initAgentspace(agentspaceDir) {
     }
 }
 export function getAll() {
-    return listWorkspaces();
+    const workspaces = listWorkspaces();
+    const workspaceIds = new Set(workspaces.map((workspace) => workspace.id));
+    const worktreeWorkspaces = workspaces
+        .filter((workspace) => !workspace.isWorktree)
+        .flatMap((workspace) => listWorktrees(workspace.id)
+        .filter((worktree) => worktree.status === 'active' && !workspaceIds.has(worktree.id))
+        .map(worktreeToWorkspace));
+    return [...workspaces, ...worktreeWorkspaces];
 }
 export function getById(id) {
     return getWorkspace(id);
@@ -59,6 +67,8 @@ export function update(id, data) {
         allowed.autoProcessIssues = data.autoProcessIssues;
     if (Object.hasOwn(data, 'notificationSettings'))
         allowed.notificationSettings = data.notificationSettings;
+    if (Object.hasOwn(data, 'hooksEnabled'))
+        allowed.hooksEnabled = data.hooksEnabled;
     Object.assign(ws, allowed, { updatedAt: new Date().toISOString() });
     updateWorkspace(ws);
     return ws;
@@ -70,4 +80,18 @@ export function remove(id) {
     deleteWorkspace(id);
     return true;
 }
+function worktreeToWorkspace(worktree) {
+    return {
+        id: worktree.id,
+        name: `${worktree.name} (Worktree)`,
+        boundDirs: [worktree.path],
+        agentspaceDir: join(worktree.path, '.agentspace'),
+        isWorktree: true,
+        parentWorkspaceId: worktree.workspaceId,
+        createdAt: worktree.createdAt,
+        updatedAt: worktree.updatedAt,
+        activeChannels: [],
+        activeIssues: [],
+    };
+}
 //# sourceMappingURL=workspace.js.map