dsh-hooks 0.3.0 → 0.5.0

package/lib/history.js

@@ -2,8 +2,14 @@
  * Hook execution history: an in-memory ring buffer plus a best-effort
  * JSONL append log under ~/.dsh/dsh-hooks/ (0600, owner-only). History is
  * strictly best-effort — a failed write never breaks a hook.
+ *
+ * The buffer is not process-private memory only: it seeds from the JSONL at
+ * startup and `sync()` incrementally ingests bytes appended since the last
+ * read, so records written before a restart (or by another dsh process
+ * sharing the file, e.g. a task-board Host) surface in the web GUI instead
+ * of vanishing with the process.
  */
-import { appendFileSync, chmodSync, mkdirSync } from 'node:fs';
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 export const DEFAULT_HISTORY_PATH = join(homedir(), '.dsh', 'dsh-hooks', 'history.jsonl');
@@ -15,11 +21,101 @@ export function createHistorySink(options = {}) {
     const buffer = [];
     let dirReady = false;
     let chmodded = false;
-    function record(partial) {
-        const entry = { ...partial, ts: Date.now() };
+    /** Bytes of `file` already ingested into the buffer. */
+    let syncedBytes = 0;
+    /** Trailing fragment of the last read that did not end with a newline. */
+    let pending = '';
+    function push(entry) {
         buffer.push(entry);
         if (buffer.length > max)
             buffer.splice(0, buffer.length - max);
+    }
+    /** Parse complete JSONL lines into the ring buffer; incomplete tails stay pending. */
+    function ingest(text) {
+        pending += text;
+        const lines = pending.split('\n');
+        pending = lines.pop() ?? '';
+        for (const line of lines) {
+            if (line === '')
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (typeof entry !== 'object' || entry === null || typeof entry.ts !== 'number')
+                    continue;
+                push(entry);
+            }
+            catch {
+                // Broken line (mid-write or foreign content): skip, never fail.
+            }
+        }
+    }
+    /** Rebuild the buffer from the whole file (startup seed / truncated file). */
+    function rebuild() {
+        buffer.length = 0;
+        pending = '';
+        syncedBytes = 0;
+        const text = readFileSync(file, 'utf8');
+        syncedBytes = Buffer.byteLength(text, 'utf8');
+        ingest(text);
+    }
+    /** Seed the ring buffer from an existing JSONL log (best-effort). */
+    function seed() {
+        if (!enabled)
+            return;
+        try {
+            if (!existsSync(file))
+                return;
+            rebuild();
+        }
+        catch {
+            // Seeding is best-effort; recording starts from an empty buffer.
+        }
+    }
+    /** Ingest every byte appended since the last read (own writes included). */
+    function sync() {
+        if (!enabled)
+            return;
+        try {
+            if (!existsSync(file))
+                return;
+            const size = statSync(file).size;
+            if (size === syncedBytes)
+                return;
+            if (size < syncedBytes) {
+                // The file shrank (rotation/truncation): rebuild from its tail.
+                rebuild();
+                return;
+            }
+            const deltaBytes = size - syncedBytes;
+            const fd = openSync(file, 'r');
+            try {
+                const chunk = Buffer.allocUnsafe(deltaBytes);
+                let total = 0;
+                while (total < deltaBytes) {
+                    const n = readSync(fd, chunk, total, deltaBytes - total, syncedBytes + total);
+                    if (n <= 0)
+                        break;
+                    total += n;
+                }
+                ingest(chunk.subarray(0, total).toString('utf8'));
+            }
+            finally {
+                closeSync(fd);
+            }
+            syncedBytes = size;
+        }
+        catch {
+            // Sync is best-effort; the next call retries.
+        }
+    }
+    function record(partial) {
+        const entry = { ...partial, ts: Date.now() };
+        // Ingest other processes' appends BEFORE our own entry so the buffer
+        // stays in file order, and `syncedBytes` stays a true prefix of the
+        // file (otherwise our own advance would skip the foreign appends).
+        if (enabled)
+            sync();
+        push(entry);
         if (!enabled)
             return;
         try {
@@ -28,6 +124,7 @@ export function createHistorySink(options = {}) {
                 dirReady = true;
             }
             appendFileSync(file, JSON.stringify(entry) + '\n', 'utf8');
+            syncedBytes = statSync(file).size;
             if (!chmodded) {
                 try {
                     chmodSync(file, 0o600);
@@ -42,9 +139,11 @@ export function createHistorySink(options = {}) {
             // History is best-effort: a failed write never breaks a hook.
         }
     }
+    seed();
     return {
         record,
         recent: () => buffer,
+        sync,
         dispose: () => { },
     };
 }

package/lib/index.js

@@ -5,6 +5,7 @@ import { eventLabel } from './context.js';
 import { createHookRunner } from './runner.js';
 import { fireNotify } from './notify.js';
 import { createHistorySink } from './history.js';
+import { createFeishuSetupManager } from './feishu-session.js';
 import { registerHookRoutes } from './server.js';
 export const name = 'dsh-hooks';
 // Dependency on the session service: `session/event` only exists once a
@@ -22,12 +23,20 @@ export function apply(ctx, config = {}) {
     const hooks = config.hooks ?? [];
     const history = createHistorySink(config.history ?? undefined);
     const runner = createHookRunner((line) => ctx.logger?.info(line), (record) => history.record(record));
-    // Web-profile extras: /dsh-hooks routes and the agent announcement. Both
-    // services are optional — CLI/headless profiles provide neither, and the
-    // plugin keeps working there untouched.
+    // Web-profile extras: /dsh-hooks routes (incl. the Feishu connect flow)
+    // and the agent announcement. Both services are optional — CLI/headless
+    // profiles provide neither, and the plugin keeps working there untouched.
     const webServer = ctx.get('webServer', false);
     if (webServer !== undefined) {
-        ctx.effect(() => registerHookRoutes(webServer, { hooks, history }), 'dsh-hooks: /dsh-hooks routes');
+        const feishu = createFeishuSetupManager();
+        ctx.effect(() => {
+            const unregister = registerHookRoutes(webServer, { hooks, history, feishu: { manager: feishu } });
+            return () => {
+                unregister();
+                // Abort an in-flight QR scan so it never outlives the plugin.
+                feishu.dispose();
+            };
+        }, 'dsh-hooks: /dsh-hooks routes');
     }
     const systemPrompt = ctx.get('systemPrompt', false);
     if (systemPrompt !== undefined) {

package/lib/server.d.ts

@@ -1,14 +1,17 @@
 /**
  * /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
+ * a dry-run-style test trigger, and the Feishu connect flow (QR setup /
+ * cancel / test card). 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';
+import { type FeishuSetupManager } from './feishu-session.js';
+import { runFeishuTest } from './feishu.js';
 /** Minimal structural shape of the shared web server (dsh-host-webserver). */
 export interface WebServerLike {
     register(spec: {
@@ -21,10 +24,19 @@ export interface WebServerLike {
 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 FeishuRouteDeps {
+    /** QR-scan session manager (one in-flight flow at a time). */
+    manager: FeishuSetupManager;
+    /** Test-card sender, injectable for tests. */
+    runTest?: typeof runFeishuTest;
+    /** Credential file the status route summarizes. */
+    configPath?: string;
+}
 export interface HookRoutesOptions {
     hooks: readonly HookSpec[];
     history: HistorySink;
     version?: string;
+    feishu?: FeishuRouteDeps;
 }
 /** Create the /dsh-hooks route handler (exported for tests). */
 export declare function createHookHandler(options: HookRoutesOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/lib/server.js

@@ -2,6 +2,8 @@ import { createRequire } from 'node:module';
 import { describeHook, evaluateHooks, mockContext } from './dry-run.js';
 import { createHookRunner } from './runner.js';
 import { fireNotify } from './notify.js';
+import { FEISHU_SETUP_BUSY } from './feishu-session.js';
+import { readFeishuSummary, runFeishuTest, updateFeishuResultMaxChars } from './feishu.js';
 /** Plugin version, read from package.json (this package ships its own). */
 export function pluginVersion() {
     const require = createRequire(import.meta.url);
@@ -48,6 +50,9 @@ async function readJsonBody(req) {
 export function createHookHandler(options) {
     const { hooks, history } = options;
     const version = options.version ?? pluginVersion();
+    const feishu = options.feishu;
+    const runFeishuTestCard = feishu?.runTest ?? runFeishuTest;
+    const feishuConfigPath = feishu?.configPath;
     return async (req, res) => {
         if (!isLoopbackRequest(req)) {
             json(res, FAIL('forbidden', 'loopback-only'), 403);
@@ -56,6 +61,9 @@ export function createHookHandler(options) {
         const url = new URL(req.url ?? '/', 'http://x');
         const pathname = url.pathname;
         if (req.method === 'GET' && pathname === '/dsh-hooks/status') {
+            // Pull in disk records (pre-restart and other-process appends) so the
+            // badge reflects the durable log, not just this process's memory.
+            history.sync();
             json(res, OK({ name: 'dsh-hooks', version, hookCount: hooks.length, historyCount: history.recent().length }));
             return;
         }
@@ -63,6 +71,7 @@ export function createHookHandler(options) {
             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;
+            history.sync();
             const records = history.recent();
             json(res, OK(records.slice(Math.max(0, records.length - n))));
             return;
@@ -119,6 +128,90 @@ export function createHookHandler(options) {
             }));
             return;
         }
+        if (feishu !== undefined && req.method === 'GET' && pathname === '/dsh-hooks/feishu/status') {
+            const summary = readFeishuSummary(feishuConfigPath);
+            json(res, OK({ ...summary, setup: feishu.manager.status() }));
+            return;
+        }
+        if (feishu !== undefined && req.method === 'POST' && pathname === '/dsh-hooks/feishu/setup') {
+            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 profile = typeof body.profile === 'string' && body.profile.trim() !== '' ? body.profile.trim() : 'web';
+            const resultMaxChars = typeof body.resultMaxChars === 'number' && Number.isFinite(body.resultMaxChars)
+                ? body.resultMaxChars
+                : undefined;
+            try {
+                const setup = resultMaxChars === undefined
+                    ? await feishu.manager.start(profile)
+                    : await feishu.manager.start(profile, { resultMaxChars });
+                json(res, OK({ setup }));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                json(res, FAIL('pending', message), message === FEISHU_SETUP_BUSY ? 409 : 500);
+            }
+            return;
+        }
+        if (feishu !== undefined && req.method === 'POST' && pathname === '/dsh-hooks/feishu/config') {
+            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 value = payload.resultMaxChars;
+            if (typeof value !== 'number') {
+                json(res, FAIL('bad-request', '缺少数字字段 resultMaxChars'), 400);
+                return;
+            }
+            try {
+                const resultMaxChars = updateFeishuResultMaxChars(feishuConfigPath, value);
+                json(res, OK({ resultMaxChars }));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                json(res, FAIL('bad-request', message), 400);
+            }
+            return;
+        }
+        if (feishu !== undefined && req.method === 'POST' && pathname === '/dsh-hooks/feishu/cancel') {
+            const contentType = req.headers['content-type'] ?? '';
+            if (!contentType.toLowerCase().startsWith('application/json')) {
+                json(res, FAIL('bad-request', 'POST 需要 application/json'), 415);
+                return;
+            }
+            json(res, OK({ cancelled: feishu.manager.cancel() }));
+            return;
+        }
+        if (feishu !== undefined && req.method === 'POST' && pathname === '/dsh-hooks/feishu/test') {
+            const contentType = req.headers['content-type'] ?? '';
+            if (!contentType.toLowerCase().startsWith('application/json')) {
+                json(res, FAIL('bad-request', 'POST 需要 application/json'), 415);
+                return;
+            }
+            try {
+                const message = await runFeishuTestCard();
+                json(res, OK({ message }));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                json(res, FAIL('send-failed', message), 500);
+            }
+            return;
+        }
         json(res, FAIL('not-found', `unknown route ${pathname}`), 404);
     };
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dsh-hooks",
-  "version": "0.3.0",
+  "version": "0.5.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.",
+  "description": "Config-driven lifecycle hooks plugin for DeepSeek Harness: declare event -> command hooks in cordis.patch.yml, no plugin code required. Includes a Hooks section in the Web GUI settings (history timeline + manual tester + Feishu connect).",
   "author": "PeterBon",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,11 @@
     "dsh-hooks": "./bin/dsh-hooks.mjs"
   },
   "exports": {
-    ".": "./lib/index.js",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": "./lib/client.js",
     "./package.json": "./package.json"
   },
   "files": [
@@ -41,8 +45,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build": "tsc -p tsconfig.json && tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
     "typecheck:test": "tsc -p tsconfig.test.json --noEmit",
     "test": "vitest run",
     "check": "pnpm run typecheck && pnpm run typecheck:test && pnpm run test && pnpm run build"
@@ -53,18 +57,34 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime"
+      ],
+      "platform": "web"
     }
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "react": "^18.2.0"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1",
+    "@tsdown/css": "^0.22.14",
     "@types/node": "^26.2.0",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "^18.3.5",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tsdown": "^0.22.2",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },