dsh-hooks 0.2.2 → 0.3.0

package/lib/notify.js

@@ -0,0 +1,226 @@
+/**
+ * Built-in notification channels: webhook (HTTP JSON POST) and desktop
+ * (platform-native balloon/toast). Config-driven — a hook declares
+ * `notify: { channel, url?, slack? }` and needs no external script.
+ * Failures only warn, never block the agent loop.
+ */
+import { spawn } from 'node:child_process';
+import { eventLabel } from './context.js';
+/** Fetch timeout for webhook sends (ms). */
+export const NOTIFY_TIMEOUT_MS = 10000;
+/** One-line summary for Slack-style and desktop notifications. */
+export function summarizeContext(ctx) {
+    const label = ctx.sessionName || ctx.sessionId || '';
+    const where = label ? ` · ${label}` : '';
+    switch (ctx.event) {
+        case 'turn/end':
+            if (ctx.reason === 'completed')
+                return `✅ 任务已完成${where}（回合 #${ctx.turn ?? '?'}）`;
+            if (ctx.error)
+                return `❌ 任务失败${where}: ${ctx.error.slice(0, 200)}`;
+            return `⏸ 任务${ctx.reason ? ` ${ctx.reason}` : '结束'}${where}（回合 #${ctx.turn ?? '?'}）`;
+        case 'tool/call':
+            return `🔧 调用工具 ${ctx.tool ?? ''}${where}`;
+        case 'tool/result':
+            if (ctx.toolError)
+                return `⚠️ 工具 ${ctx.tool ?? ''} 失败${where}: ${ctx.toolError}`;
+            return `✅ 工具 ${ctx.tool ?? ''} 完成${where}`;
+        case 'approval/asked':
+            return `⏳ 需要审批：工具 ${ctx.tool ?? ''}${where}`;
+        case 'user/message':
+            return `💬 新消息${where}${ctx.content ? `：${ctx.content.slice(0, 120)}` : ''}`;
+        case 'session/title':
+            return `🏷 会话改名${where}: ${ctx.sessionName ?? ''}`;
+        case 'session/created':
+            return `✨ 会话开始${where}`;
+        case 'session/disposed':
+            return `🏁 会话结束${where}`;
+        case 'agent/error':
+            return `⚠️ Agent 出错${where}${ctx.error ? `: ${ctx.error.slice(0, 200)}` : ''}`;
+        default:
+            return `🔔 DSH ${ctx.event}${where}`;
+    }
+}
+/** Structured JSON document for the webhook channel (present fields only). */
+export function webhookPayload(ctx) {
+    const payload = { event: ctx.event, timestamp: ctx.timestamp };
+    const session = {};
+    if (ctx.sessionId)
+        session.id = ctx.sessionId;
+    if (ctx.sessionName)
+        session.name = ctx.sessionName;
+    if (ctx.cwd)
+        session.cwd = ctx.cwd;
+    if (Object.keys(session).length > 0)
+        payload.session = session;
+    if (ctx.turn !== undefined)
+        payload.turn = ctx.turn;
+    if (ctx.step !== undefined)
+        payload.step = ctx.step;
+    if (ctx.reason !== undefined)
+        payload.reason = ctx.reason;
+    if (ctx.tool !== undefined)
+        payload.tool = ctx.tool;
+    if (ctx.callId !== undefined)
+        payload.call_id = ctx.callId;
+    if (ctx.toolArgs !== undefined)
+        payload.tool_args = ctx.toolArgs;
+    if (ctx.toolError !== undefined)
+        payload.tool_error = ctx.toolError;
+    if (ctx.source !== undefined)
+        payload.source = ctx.source;
+    if (ctx.durationMs !== undefined)
+        payload.duration_ms = ctx.durationMs;
+    if (ctx.status !== undefined)
+        payload.status = ctx.status;
+    if (ctx.error !== undefined)
+        payload.error = ctx.error;
+    if (ctx.content !== undefined)
+        payload.content = ctx.content;
+    const usage = {};
+    if (ctx.usageInputTokens !== undefined)
+        usage.input_tokens = ctx.usageInputTokens;
+    if (ctx.usageOutputTokens !== undefined)
+        usage.output_tokens = ctx.usageOutputTokens;
+    if (ctx.usageCacheReadTokens !== undefined)
+        usage.cache_read_tokens = ctx.usageCacheReadTokens;
+    if (ctx.usageCacheWriteTokens !== undefined)
+        usage.cache_write_tokens = ctx.usageCacheWriteTokens;
+    if (ctx.usageReasoningTokens !== undefined)
+        usage.reasoning_tokens = ctx.usageReasoningTokens;
+    if (Object.keys(usage).length > 0)
+        payload.usage = usage;
+    return payload;
+}
+/**
+ * POST the context to a webhook endpoint. One retry on transport failure
+ * (webhook endpoints often drop the first request when cold). The URL comes
+ * from `spec.url` or the `DSH_HOOKS_WEBHOOK_URL` environment variable.
+ */
+export async function sendWebhook(spec, ctx, env = process.env) {
+    const url = spec.url || env.DSH_HOOKS_WEBHOOK_URL;
+    if (!url)
+        return { ok: false, error: '缺少 webhook URL（notify.url 或 DSH_HOOKS_WEBHOOK_URL）' };
+    const body = spec.slack ? { text: summarizeContext(ctx) } : webhookPayload(ctx);
+    const attempt = async () => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), NOTIFY_TIMEOUT_MS);
+        try {
+            return await fetch(url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    let response;
+    try {
+        response = await attempt();
+    }
+    catch (error) {
+        try {
+            response = await attempt();
+        }
+        catch (retryError) {
+            const cause = retryError instanceof Error ? retryError.message : String(retryError);
+            return { ok: false, error: `webhook 请求失败（重试后仍失败）: ${cause}` };
+        }
+    }
+    if (!response.ok)
+        return { ok: false, error: `webhook 响应 HTTP ${response.status}` };
+    return { ok: true };
+}
+/**
+ * Desktop balloon/toast notification. The summary travels through an
+ * environment variable (Windows PowerShell) or argv (macOS/Linux), never
+ * through shell-string interpolation.
+ */
+export async function sendDesktop(spec, ctx) {
+    const text = summarizeContext(ctx);
+    const platform = process.platform;
+    try {
+        if (platform === 'win32') {
+            await runAndWait(['powershell', '-NoProfile', '-STA', '-Command', [
+                    'Add-Type -AssemblyName System.Windows.Forms',
+                    '$n = New-Object System.Windows.Forms.NotifyIcon',
+                    '$n.Icon = [System.Drawing.SystemIcons]::Information',
+                    '$n.Visible = $true',
+                    `$n.ShowBalloonTip(8000, 'dsh-hooks', $env:DSH_HOOK_NOTIFY_TEXT, [System.Windows.Forms.ToolTipIcon]::Info)`,
+                    'Start-Sleep -Seconds 9',
+                    '$n.Dispose()',
+                ].join('; ')], { DSH_HOOK_NOTIFY_TEXT: text }, 15000);
+            return { ok: true };
+        }
+        if (platform === 'darwin') {
+            const script = `display notification ${JSON.stringify(text)} with title "dsh-hooks"`;
+            await runAndWait(['osascript', '-e', script], {}, 10000);
+            return { ok: true };
+        }
+        await runAndWait(['notify-send', 'dsh-hooks', text], {}, 10000);
+        return { ok: true };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: `桌面通知失败: ${detail}` };
+    }
+}
+/** Spawn one OS command and wait for its exit code (timeout kills it). */
+function runAndWait(argv, env, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(argv[0], argv.slice(1), { stdio: 'ignore', env: { ...process.env, ...env } });
+        }
+        catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`命令超时（${timeoutMs}ms）`));
+        }, timeoutMs);
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`退出码 ${code}`));
+        });
+    });
+}
+/** Fire a built-in notification; failures only warn. */
+export async function fireNotify(spec, ctx, record) {
+    const startedAt = Date.now();
+    const result = spec.channel === 'webhook' ? await sendWebhook(spec, ctx) : await sendDesktop(spec, ctx);
+    if (!result.ok) {
+        console.warn(`[dsh-hooks] 通知发送失败 (${eventLabel(ctx)}): ${result.error}`);
+        record?.({
+            kind: 'notify',
+            event: ctx.event,
+            command: `notify:${spec.channel}`,
+            sessionId: ctx.sessionId,
+            sessionName: ctx.sessionName,
+            outcome: 'send-failed',
+            durationMs: Date.now() - startedAt,
+            error: result.error,
+        });
+        return;
+    }
+    record?.({
+        kind: 'notify',
+        event: ctx.event,
+        command: `notify:${spec.channel}`,
+        sessionId: ctx.sessionId,
+        sessionName: ctx.sessionName,
+        outcome: 'sent',
+        durationMs: Date.now() - startedAt,
+    });
+}

package/lib/runner.d.ts

@@ -1,6 +1,7 @@
 import { type ChildProcess } from 'node:child_process';
 import type { HookContext } from './context.js';
 import type { HookSpec } from './config.js';
+import type { HookRunRecord } from './history.js';
 export interface RunOutcome {
     ok: boolean;
     reason: 'ran' | 'timeout' | 'spawn-failed' | 'skipped';
@@ -11,7 +12,9 @@ export interface HookRunner {
     run(spec: HookSpec, ctx: HookContext): RunOutcome;
     dispose(): void;
 }
+export type RunRecord = (record: Omit<HookRunRecord, 'ts'>) => void;
 export declare const DEFAULT_TIMEOUT_MS = 10000;
+export declare const DEFAULT_RETRY_DELAY_MS = 500;
 /**
  * Terminate a spawned hook process. With `shell: true` on Windows the direct
  * child is cmd.exe — killing only the shell orphans the actual hook command
@@ -21,9 +24,11 @@ export declare const DEFAULT_TIMEOUT_MS = 10000;
 export declare function terminate(child: ChildProcess): void;
 /**
  * Fire-and-forget command runner. Emissions are irreversible side effects:
- * failures only warn, never retried, never block the agent loop.
- * Context travels through environment variables (no data interpolation into
- * the shell string); `{{var}}` placeholders are substituted from the same
- * map for explicit templating by the user.
+ * failures only warn, never block the agent loop. Context travels through
+ * environment variables (no data interpolation into the shell string);
+ * `{{var}}` placeholders are substituted from the same map for explicit
+ * templating by the user. `input: 'stdin'` additionally writes the full
+ * context as one JSON document to stdin, and `retries` re-spawns commands
+ * whose exit code is non-zero (with exponential backoff, in the background).
  */
-export declare function createHookRunner(log?: (line: string) => void): HookRunner;
+export declare function createHookRunner(log?: (line: string) => void, record?: RunRecord): HookRunner;

package/lib/runner.js

@@ -1,6 +1,14 @@
 import { spawn } from 'node:child_process';
 import { eventLabel, renderTemplate, toEnv } from './context.js';
 export const DEFAULT_TIMEOUT_MS = 10000;
+export const DEFAULT_RETRY_DELAY_MS = 500;
+/**
+ * Per-stream capture cap. The hook's stdout/stderr is only kept for
+ * failure diagnostics, so anything past 64 KiB is drained and dropped
+ * (reading must never stop — a stopped reader would fill the pipe buffer
+ * and wedge the hook process).
+ */
+const MAX_CAPTURE_BYTES = 64 * 1024;
 /**
  * Terminate a spawned hook process. With `shell: true` on Windows the direct
  * child is cmd.exe — killing only the shell orphans the actual hook command
@@ -20,48 +28,116 @@ export function terminate(child) {
 }
 /**
  * Fire-and-forget command runner. Emissions are irreversible side effects:
- * failures only warn, never retried, never block the agent loop.
- * Context travels through environment variables (no data interpolation into
- * the shell string); `{{var}}` placeholders are substituted from the same
- * map for explicit templating by the user.
+ * failures only warn, never block the agent loop. Context travels through
+ * environment variables (no data interpolation into the shell string);
+ * `{{var}}` placeholders are substituted from the same map for explicit
+ * templating by the user. `input: 'stdin'` additionally writes the full
+ * context as one JSON document to stdin, and `retries` re-spawns commands
+ * whose exit code is non-zero (with exponential backoff, in the background).
  */
-export function createHookRunner(log = console.log) {
+export function createHookRunner(log = console.log, record) {
     const children = new Set();
-    function run(spec, ctx) {
+    const pendingRetries = new Set();
+    function spawnOnce(spec, ctx, attempt) {
+        if (!spec.run)
+            return { ok: false, reason: 'skipped', detail: 'no run command' };
         const timeoutMs = spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const retries = spec.retries ?? 0;
+        const retryDelayMs = spec.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
         const env = toEnv(ctx);
         const command = renderTemplate(spec.run, ctx);
+        const useStdin = spec.input === 'stdin';
+        const base = {
+            kind: 'run',
+            event: ctx.event,
+            command,
+            sessionId: ctx.sessionId,
+            sessionName: ctx.sessionName,
+        };
         log(`[dsh-hooks] 触发 ${eventLabel(ctx)} → ${command}`);
         let child;
         try {
             child = spawn(command, {
                 shell: true,
                 env: { ...process.env, ...env },
-                stdio: 'ignore',
+                stdio: [useStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
             });
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
             console.warn(`[dsh-hooks] spawn 失败 (${eventLabel(ctx)}): ${detail}`);
+            record?.({ ...base, outcome: 'spawn-failed', error: detail });
             return { ok: false, reason: 'spawn-failed', detail };
         }
+        const startedAt = Date.now();
+        record?.({ ...base, outcome: 'spawned' });
         children.add(child);
+        let timedOut = false;
         const timer = setTimeout(() => {
+            timedOut = true;
             terminate(child);
             console.warn(`[dsh-hooks] 超时（${timeoutMs}ms），已终止：${eventLabel(ctx)}`);
+            record?.({ ...base, outcome: 'timeout', durationMs: Date.now() - startedAt });
         }, timeoutMs);
         // Never hold the process open for a hook.
         child.unref();
+        if (useStdin && child.stdin) {
+            // The hook may exit before reading stdin (EPIPE on write): the close
+            // handler owns failure reporting, so swallow the stream error.
+            child.stdin.on('error', () => { });
+            child.stdin.write(JSON.stringify(ctx));
+            child.stdin.end();
+        }
+        const captured = { out: '', err: '' };
+        const capture = (target) => (chunk) => {
+            const text = String(chunk);
+            const room = MAX_CAPTURE_BYTES - captured[target].length;
+            if (room > 0)
+                captured[target] += text.slice(0, room);
+        };
+        child.stdout?.on('data', capture('out'));
+        child.stderr?.on('data', capture('err'));
         child.on('error', (error) => {
             console.warn(`[dsh-hooks] 执行出错 (${eventLabel(ctx)}): ${error.message}`);
         });
-        child.on('close', () => {
+        child.on('close', (code) => {
             clearTimeout(timer);
             children.delete(child);
+            // Timeouts and external kills (dispose) never retry; only a command
+            // that actually ran and exited non-zero does.
+            if (timedOut || code === null || code === 0) {
+                if (!timedOut && code !== null) {
+                    record?.({ ...base, outcome: 'exit-0', exitCode: 0, durationMs: Date.now() - startedAt });
+                }
+                return;
+            }
+            if (attempt < retries) {
+                const delay = retryDelayMs * 2 ** attempt;
+                log(`[dsh-hooks] hook 退出码 ${code}，${delay}ms 后重试（${attempt + 1}/${retries}）：${eventLabel(ctx)}`);
+                const retryTimer = setTimeout(() => {
+                    pendingRetries.delete(retryTimer);
+                    spawnOnce(spec, ctx, attempt + 1);
+                }, delay);
+                retryTimer.unref?.();
+                pendingRetries.add(retryTimer);
+                return;
+            }
+            const tail = captured.err.trim();
+            const detail = tail === '' ? '' : `，stderr：${tail.slice(-400)}`;
+            console.warn(`[dsh-hooks] hook 退出码 ${code} (${eventLabel(ctx)})${detail}`);
+            record?.({ ...base, outcome: 'exit-nonzero', exitCode: code, durationMs: Date.now() - startedAt, error: tail.slice(-400) || undefined });
         });
         return { ok: true, reason: 'ran' };
     }
+    function run(spec, ctx) {
+        if (!spec.run)
+            return { ok: false, reason: 'skipped', detail: 'no run command' };
+        return spawnOnce(spec, ctx, 0);
+    }
     function dispose() {
+        for (const timer of pendingRetries)
+            clearTimeout(timer);
+        pendingRetries.clear();
         for (const child of children)
             terminate(child);
         children.clear();

package/lib/server.d.ts

@@ -0,0 +1,32 @@
+/**
+ * /dsh-hooks/* HTTP routes for the web profile: status, execution history,
+ * and a dry-run-style test trigger. Registered only when the shared
+ * webserver service exists (web profile) — CLI/headless environments never
+ * see them. Loopback-only with JSON envelopes; POSTs require an explicit
+ * application/json content-type (CSRF hardening, same posture as
+ * dsh-aionui-panel).
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HookSpec } from './config.js';
+import type { HistorySink } from './history.js';
+/** Minimal structural shape of the shared web server (dsh-host-webserver). */
+export interface WebServerLike {
+    register(spec: {
+        kind: 'prefix' | 'exact';
+        path: string;
+        handler: (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+    }): () => void;
+}
+/** Plugin version, read from package.json (this package ships its own). */
+export declare function pluginVersion(): string;
+/** Loopback fence: never let a LAN client reach /dsh-hooks operations. */
+export declare function isLoopbackRequest(req: IncomingMessage): boolean;
+export interface HookRoutesOptions {
+    hooks: readonly HookSpec[];
+    history: HistorySink;
+    version?: string;
+}
+/** Create the /dsh-hooks route handler (exported for tests). */
+export declare function createHookHandler(options: HookRoutesOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+/** Register the /dsh-hooks prefix route on the shared web server. */
+export declare function registerHookRoutes(webServer: WebServerLike, options: HookRoutesOptions): () => void;

package/lib/server.js

@@ -0,0 +1,128 @@
+import { createRequire } from 'node:module';
+import { describeHook, evaluateHooks, mockContext } from './dry-run.js';
+import { createHookRunner } from './runner.js';
+import { fireNotify } from './notify.js';
+/** Plugin version, read from package.json (this package ships its own). */
+export function pluginVersion() {
+    const require = createRequire(import.meta.url);
+    try {
+        const pkg = require('../package.json');
+        return typeof pkg.version === 'string' ? pkg.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const OK = (value) => ({ ok: true, value });
+const FAIL = (code, message) => ({ ok: false, error: { code, message } });
+function json(res, envelope, status = 200) {
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(envelope));
+}
+/** Loopback fence: never let a LAN client reach /dsh-hooks operations. */
+export function isLoopbackRequest(req) {
+    const address = req.socket.remoteAddress ?? '';
+    return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1';
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buffer = chunk;
+        chunks.push(buffer);
+        total += buffer.length;
+        if (total > 1 << 20)
+            return null;
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    if (text === '')
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/** Create the /dsh-hooks route handler (exported for tests). */
+export function createHookHandler(options) {
+    const { hooks, history } = options;
+    const version = options.version ?? pluginVersion();
+    return async (req, res) => {
+        if (!isLoopbackRequest(req)) {
+            json(res, FAIL('forbidden', 'loopback-only'), 403);
+            return;
+        }
+        const url = new URL(req.url ?? '/', 'http://x');
+        const pathname = url.pathname;
+        if (req.method === 'GET' && pathname === '/dsh-hooks/status') {
+            json(res, OK({ name: 'dsh-hooks', version, hookCount: hooks.length, historyCount: history.recent().length }));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/dsh-hooks/history') {
+            const raw = url.searchParams.get('n');
+            const parsed = raw === null ? 50 : Number(raw);
+            const n = Number.isFinite(parsed) && parsed > 0 ? Math.min(500, Math.floor(parsed)) : 50;
+            const records = history.recent();
+            json(res, OK(records.slice(Math.max(0, records.length - n))));
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/dsh-hooks/test') {
+            const contentType = req.headers['content-type'] ?? '';
+            if (!contentType.toLowerCase().startsWith('application/json')) {
+                json(res, FAIL('bad-request', 'POST 需要 application/json'), 415);
+                return;
+            }
+            const payload = await readJsonBody(req);
+            if (typeof payload !== 'object' || payload === null) {
+                json(res, FAIL('bad-request', 'malformed JSON body'), 400);
+                return;
+            }
+            const body = payload;
+            const event = typeof body.event === 'string' && body.event !== '' ? body.event : null;
+            if (event === null) {
+                json(res, FAIL('bad-request', '缺少 event 字段'), 400);
+                return;
+            }
+            const reason = typeof body.reason === 'string' && body.reason !== '' ? body.reason : undefined;
+            const ctx = mockContext(event, {
+                reason,
+                tool: typeof body.tool === 'string' ? body.tool : undefined,
+                sessionName: typeof body.sessionName === 'string' ? body.sessionName : undefined,
+            });
+            const lines = evaluateHooks(hooks, event, ctx, reason);
+            const matchedHooks = lines.filter((line) => line.matched);
+            const execute = body.execute === true;
+            if (execute) {
+                const runner = createHookRunner();
+                for (const line of matchedHooks) {
+                    const hook = hooks[line.index - 1];
+                    if (hook.run)
+                        runner.run(hook, ctx);
+                    else if (hook.notify)
+                        void fireNotify(hook.notify, ctx);
+                }
+            }
+            json(res, OK({
+                event,
+                reason,
+                executed: execute,
+                total: hooks.length,
+                matched: matchedHooks.length,
+                lines: lines.map((line) => ({
+                    index: line.index,
+                    matched: line.matched,
+                    why: line.why,
+                    summary: line.summary,
+                    action: line.matched ? describeHook(hooks[line.index - 1]) : undefined,
+                })),
+            }));
+            return;
+        }
+        json(res, FAIL('not-found', `unknown route ${pathname}`), 404);
+    };
+}
+/** Register the /dsh-hooks prefix route on the shared web server. */
+export function registerHookRoutes(webServer, options) {
+    return webServer.register({ kind: 'prefix', path: '/dsh-hooks', handler: createHookHandler(options) });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-hooks",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "packageManager": "pnpm@11.21.0",
   "description": "Config-driven lifecycle hooks plugin for DeepSeek Harness: declare event -> command hooks in cordis.patch.yml, no plugin code required.",
   "author": "PeterBon",
@@ -64,9 +64,9 @@
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@types/node": "^22.10.0",
-    "typescript": "^5.6.0",
-    "vitest": "^3.0.0"
+    "@types/node": "^26.2.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   },
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.73.0",