@agent-spaces/server 0.3.64 → 0.3.65

package/dist/services/builtin-tools/kanban-tools.js

@@ -1,5 +1,6 @@
 import { BUILT_IN_AGENT_TOOLS } from '@agent-spaces/shared';
 import * as kanbanStore from '../../storage/kanban-store.js';
+import { broadcastToWorkspace } from '../../ws/connection-manager.js';
 import { assertRecord, readOptionalString, readRequiredString, readString } from './input-helpers.js';
 const kanbanLayoutModes = ['horizontal', 'vertical'];
 const kanbanPriorities = ['low', 'medium', 'high'];
@@ -158,6 +159,7 @@ function createKanbanBoard(workspaceId, input) {
     const created = kanbanStore.getBoard(workspaceId);
     if (!created)
         throw new Error('Failed to create Kanban board.');
+    broadcastToWorkspace(workspaceId, 'kanban.updated', created);
     return created;
 }
 function updateKanbanBoard(workspaceId, input) {
@@ -185,6 +187,7 @@ function updateKanbanBoard(workspaceId, input) {
     const updated = kanbanStore.listBoards(workspaceId).find((item) => item.id === board.id);
     if (!updated)
         throw new Error(`Kanban board not found: ${board.id}`);
+    broadcastToWorkspace(workspaceId, 'kanban.updated', updated);
     return updated;
 }
 function deleteKanbanBoard(workspaceId, input) {
@@ -193,6 +196,7 @@ function deleteKanbanBoard(workspaceId, input) {
     const ok = kanbanStore.deleteBoard(workspaceId, board.id);
     if (!ok)
         throw new Error(`Kanban board not found: ${board.id}`);
+    broadcastToWorkspace(workspaceId, 'kanban.deleted', { boardId: board.id });
     return { ok: true, deletedBoardId: board.id };
 }
 function resolveKanbanBoard(workspaceId, boardId) {

package/dist/services/git-operation-log.js

@@ -0,0 +1,40 @@
+const MAX_ENTRIES = 1000;
+const store = new Map();
+function getList(workspaceId) {
+    let list = store.get(workspaceId);
+    if (!list) {
+        list = [];
+        store.set(workspaceId, list);
+    }
+    return list;
+}
+let counter = 0;
+export function logGitOperation(workspaceId, operation, input, result, error, duration = 0) {
+    const list = getList(workspaceId);
+    const entry = {
+        id: `${Date.now()}-${++counter}`,
+        operation,
+        input,
+        output: truncateOutput(result),
+        error,
+        timestamp: new Date().toISOString(),
+        duration,
+    };
+    list.unshift(entry);
+    if (list.length > MAX_ENTRIES)
+        list.length = MAX_ENTRIES;
+}
+export function getGitOperations(workspaceId) {
+    return getList(workspaceId);
+}
+function truncateOutput(value) {
+    if (value === undefined || value === null)
+        return value;
+    if (typeof value === 'string')
+        return value.length > 5000 ? value.slice(0, 5000) + '...(truncated)' : value;
+    const s = JSON.stringify(value);
+    if (s && s.length > 5000)
+        return JSON.parse(s.slice(0, 5000) + '...(truncated)');
+    return value;
+}
+//# sourceMappingURL=git-operation-log.js.map

package/dist/services/global-wechat-qr.js

@@ -0,0 +1,72 @@
+import { WECHAT_BASE_URL, WECHAT_BOT_TYPE, WECHAT_QR_STATUS_TIMEOUT_MS, } from './notification-hub/types.js';
+import { createAccount } from './robot-account.js';
+const globalSessions = new Map();
+export async function getGlobalWeChatQRCode() {
+    // cleanup old sessions
+    const now = Date.now();
+    for (const [key, s] of globalSessions) {
+        if (now - s.createdAt > 5 * 60_000)
+            globalSessions.delete(key);
+    }
+    const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_bot_qrcode?bot_type=${WECHAT_BOT_TYPE}`);
+    if (!res.ok)
+        throw new Error(`Failed to get WeChat QR code: ${res.status}`);
+    const qr = await res.json();
+    const sessionId = `global-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    globalSessions.set(sessionId, {
+        qrcode: qr.qrcode,
+        qrcodeImgContent: qr.qrcode_img_content,
+        createdAt: now,
+    });
+    return { status: 'wait', qrcodeImgContent: qr.qrcode_img_content, sessionId };
+}
+export async function pollGlobalWeChatQRCode(sessionId) {
+    if (!sessionId)
+        throw new Error('sessionId is required');
+    const session = globalSessions.get(sessionId);
+    if (!session)
+        throw new Error('Session not found or expired');
+    const status = await fetchQRStatus(session.qrcode);
+    if (status.status === 'confirmed') {
+        if (!status.bot_token || !status.ilink_bot_id) {
+            throw new Error('WeChat login confirmed but token or bot id is missing');
+        }
+        globalSessions.delete(sessionId);
+        const account = createAccount({
+            name: `微信 ${status.ilink_bot_id}`,
+            type: 'wechat',
+            wechat: {
+                token: status.bot_token,
+                baseUrl: status.baseurl || WECHAT_BASE_URL,
+                accountId: status.ilink_bot_id,
+                userId: status.ilink_user_id,
+            },
+        });
+        return { status: 'confirmed', account };
+    }
+    if (status.status === 'expired') {
+        globalSessions.delete(sessionId);
+    }
+    return { status: status.status, qrcodeImgContent: session.qrcodeImgContent, sessionId };
+}
+async function fetchQRStatus(qrcode) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), WECHAT_QR_STATUS_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, {
+            headers: { 'iLink-App-ClientVersion': '1' },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            throw new Error(`Failed to poll QR status: ${res.status}`);
+        return await res.json();
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === 'AbortError')
+            return { status: 'wait' };
+        throw err;
+    }
+}
+//# sourceMappingURL=global-wechat-qr.js.map

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-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/workspace.js

@@ -59,6 +59,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;

package/dist/storage/robot-account-store.js

@@ -0,0 +1,39 @@
+import { join } from 'node:path';
+import { readJsonFile, writeJsonFile, getDataDir } from './json-store.js';
+const FILE = () => join(getDataDir(), 'robot-accounts.json');
+function read() {
+    return readJsonFile(FILE()) ?? { accounts: [] };
+}
+function write(data) {
+    writeJsonFile(FILE(), data);
+}
+export function listRobotAccounts() {
+    return read().accounts;
+}
+export function getRobotAccount(id) {
+    return read().accounts.find((a) => a.id === id);
+}
+export function createRobotAccount(account) {
+    const data = read();
+    data.accounts.push(account);
+    write(data);
+}
+export function updateRobotAccount(id, patch) {
+    const data = read();
+    const idx = data.accounts.findIndex((a) => a.id === id);
+    if (idx === -1)
+        return null;
+    data.accounts[idx] = { ...data.accounts[idx], ...patch, id, updatedAt: new Date().toISOString() };
+    write(data);
+    return data.accounts[idx];
+}
+export function deleteRobotAccount(id) {
+    const data = read();
+    const before = data.accounts.length;
+    data.accounts = data.accounts.filter((a) => a.id !== id);
+    if (data.accounts.length === before)
+        return false;
+    write(data);
+    return true;
+}
+//# sourceMappingURL=robot-account-store.js.map