@zhin.js/console 1.0.50 → 1.0.52

package/node.tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Zhin Console — 服务端 / Node 插件「src/」推荐基线",
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/console",
-  "version": "1.0.50",
+  "version": "1.0.52",
   "description": "Web console service for Zhin.js with real-time monitoring",
   "type": "module",
   "main": "./lib/index.js",
@@ -35,12 +35,7 @@
       "development": "./src/index.ts",
       "import": "./lib/index.js"
     },
-    "./client": {
-      "types": "./lib/client/index.d.ts",
-      "development": "./client/index.tsx",
-      "import": "./lib/client/index.js"
-    },
-    "./browser.tsconfig.json": "./broswer.tsconfig.json",
+    "./browser.tsconfig.json": "./browser.tsconfig.json",
     "./node.tsconfig.json": "./node.tsconfig.json"
   },
   "dependencies": {
@@ -66,23 +61,27 @@
     "tailwind-merge": "^3.3.1",
     "tailwindcss": "latest",
     "tsup": "^8.5.1",
-    "vite": "^7.0.6",
+    "rolldown": "^1.0.0-rc.9",
+    "vite": "8.0.0",
     "yaml": "^2.8.2",
-    "zhin.js": "1.0.51"
+    "zhin.js": "1.0.52"
   },
   "peerDependencies": {
     "@types/ws": "^8.18.1",
-    "@zhin.js/client": "^1.0.12",
-    "@zhin.js/core": "^1.0.51",
-    "@zhin.js/http": "^1.0.45",
-    "zhin.js": "1.0.51"
+    "@zhin.js/client": "^1.0.13",
+    "@zhin.js/core": "^1.0.52",
+    "@zhin.js/http": "^1.0.46",
+    "zhin.js": "1.0.52"
   },
   "files": [
+    "src",
     "lib",
-    "node",
-    "README.md",
-    "dist",
     "client",
+    "dist",
+    "skills",
+    "README.md",
+    "browser.tsconfig.json",
+    "node.tsconfig.json",
     "CHANGELOG.md"
   ],
   "optionalDependencies": {

package/src/bin.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import { build } from "./build.js";
+import path from "path";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  try {
+    switch (command) {
+      case "build":
+        // 构建当前目录的插件客户端代码
+        console.log("🔨 Building plugin client...");
+        await build(process.cwd());
+        break;
+    }
+  } catch (error) {
+    console.error("❌ Build failed:", error);
+    process.exit(1);
+  }
+}
+
+main();

package/src/bot-db-models.ts

@@ -0,0 +1,74 @@
+/**
+ * 控制台机器人请求/通知的数据库表定义，供 zhin 内置数据库使用
+ */
+import type { Definition } from "@zhin.js/core";
+
+export interface ConsoleBotRequestRow {
+  id?: number;
+  adapter: string;
+  bot_id: string;
+  platform_request_id: string;
+  type: string;
+  sender_id: string;
+  sender_name: string;
+  comment: string;
+  channel_id: string;
+  channel_type: string;
+  created_at: number;
+  consumed: number;
+  consumed_at?: number;
+}
+
+export interface ConsoleBotNoticeRow {
+  id?: number;
+  adapter: string;
+  bot_id: string;
+  notice_type: string;
+  channel_type: string;
+  channel_id: string;
+  payload: string;
+  created_at: number;
+  consumed: number;
+  consumed_at?: number;
+}
+
+export const ConsoleBotRequestDefinition: Definition<ConsoleBotRequestRow> = {
+  id: { type: "integer", primary: true, autoIncrement: true },
+  adapter: { type: "text", nullable: false },
+  bot_id: { type: "text", nullable: false },
+  platform_request_id: { type: "text", nullable: false },
+  type: { type: "text", nullable: false },
+  sender_id: { type: "text", nullable: false },
+  sender_name: { type: "text", nullable: false },
+  comment: { type: "text", nullable: false },
+  channel_id: { type: "text", nullable: false },
+  channel_type: { type: "text", nullable: false },
+  created_at: { type: "integer", nullable: false },
+  consumed: { type: "integer", nullable: false, default: 0 },
+  consumed_at: { type: "integer", nullable: true },
+};
+
+export const ConsoleBotNoticeDefinition: Definition<ConsoleBotNoticeRow> = {
+  id: { type: "integer", primary: true, autoIncrement: true },
+  adapter: { type: "text", nullable: false },
+  bot_id: { type: "text", nullable: false },
+  notice_type: { type: "text", nullable: false },
+  channel_type: { type: "text", nullable: false },
+  channel_id: { type: "text", nullable: false },
+  payload: { type: "text", nullable: false },
+  created_at: { type: "integer", nullable: false },
+  consumed: { type: "integer", nullable: false, default: 0 },
+  consumed_at: { type: "integer", nullable: true },
+};
+
+const TABLE_REQUESTS = "console_bot_requests";
+const TABLE_NOTICES = "console_bot_notices";
+
+export function registerBotModels(root: { defineModel?: (name: string, def: Definition<unknown>) => void }) {
+  const defineModel = root.defineModel;
+  if (typeof defineModel !== "function") return;
+  defineModel(TABLE_REQUESTS, ConsoleBotRequestDefinition as Definition<unknown>);
+  defineModel(TABLE_NOTICES, ConsoleBotNoticeDefinition as Definition<unknown>);
+}
+
+export { TABLE_REQUESTS, TABLE_NOTICES };

package/src/bot-hub.ts

@@ -0,0 +1,240 @@
+/**
+ * 机器人请求/通知：内存 Request 映射 + WS 广播 + 事件注册
+ */
+import type WebSocket from "ws";
+import type { Request as ZhinRequest } from "@zhin.js/core";
+import {
+  insertRequest,
+  insertNotice,
+  listUnconsumedRequests,
+  listUnconsumedNotices,
+  markRequestsConsumed,
+  findRequestRow,
+  type StoredRequestRow,
+} from "./bot-persistence.js";
+
+type WsIterable = { clients?: Set<WebSocket> | WebSocket[] };
+
+let wssRef: WsIterable | null = null;
+let hubInited = false;
+
+export function setBotHubWss(wss: WsIterable) {
+  wssRef = wss;
+}
+
+function broadcast(obj: object) {
+  const msg = JSON.stringify(obj);
+  const clients = wssRef?.clients;
+  if (!clients) return;
+  const list = clients instanceof Set ? [...clients] : clients;
+  for (const ws of list) {
+    if (ws.readyState === 1) ws.send(msg);
+  }
+}
+
+function requestMemoryKey(adapter: string, botId: string, platformId: string) {
+  return `${adapter}:${botId}:${platformId}`;
+}
+
+const pendingRequestObjects = new Map<string, ZhinRequest>();
+
+export async function storePendingRequest(
+  adapter: string,
+  botId: string,
+  req: ZhinRequest
+): Promise<StoredRequestRow> {
+  const platformId = req.$id;
+  const key = requestMemoryKey(adapter, botId, platformId);
+  pendingRequestObjects.set(key, req);
+  const row = await insertRequest({
+    adapter,
+    bot_id: botId,
+    platform_request_id: platformId,
+    type: String(req.$type),
+    sender_id: String(req.$sender?.id ?? ""),
+    sender_name: String(req.$sender?.name ?? ""),
+    comment: String(req.$comment ?? ""),
+    channel_id: String(req.$channel?.id ?? ""),
+    channel_type: String(req.$channel?.type ?? "private"),
+    created_at: typeof req.$timestamp === "number" ? req.$timestamp : Date.now(),
+  });
+  return row;
+}
+
+export function rowToRequestPushData(row: StoredRequestRow, canAct: boolean) {
+  return {
+    id: row.id,
+    adapter: row.adapter,
+    botId: row.bot_id,
+    platformRequestId: row.platform_request_id,
+    type: row.type,
+    sender: { id: row.sender_id, name: row.sender_name },
+    comment: row.comment,
+    channel: { id: row.channel_id, type: row.channel_type },
+    timestamp: row.created_at,
+    canAct,
+  };
+}
+
+export async function onRequestReceived(adapter: string, botId: string, req: ZhinRequest) {
+  const row = await storePendingRequest(adapter, botId, req);
+  const key = requestMemoryKey(adapter, botId, req.$id);
+  const canAct = pendingRequestObjects.has(key);
+  broadcast({ type: "bot:request", data: rowToRequestPushData(row, canAct) });
+}
+
+export async function onNoticeReceived(adapter: string, botId: string, notice: any) {
+  let raw: Record<string, unknown> = {};
+  try {
+    raw = Object.fromEntries(
+      Object.entries(notice).filter(
+        ([k]) => !k.startsWith("$") && k !== "adapter" && k !== "bot"
+      )
+    ) as Record<string, unknown>;
+  } catch {
+    raw = {};
+  }
+  let payload: string;
+  try {
+    payload = JSON.stringify({
+      type: notice.$type,
+      subType: notice.$subType,
+      channel: notice.$channel,
+      raw,
+    });
+  } catch {
+    payload = JSON.stringify({ type: notice.$type, error: "serialize_failed" });
+  }
+  const row = await insertNotice({
+    adapter,
+    bot_id: botId,
+    notice_type: String(notice.$type ?? "unknown"),
+    channel_type: String(notice.$channel?.type ?? ""),
+    channel_id: String(notice.$channel?.id ?? ""),
+    payload,
+    created_at: typeof notice.$timestamp === "number" ? notice.$timestamp : Date.now(),
+  });
+  broadcast({
+    type: "bot:notice",
+    data: {
+      id: row.id,
+      adapter: row.adapter,
+      botId: row.bot_id,
+      noticeType: row.notice_type,
+      channel: { id: row.channel_id, type: row.channel_type },
+      payload: row.payload,
+      timestamp: row.created_at,
+    },
+  });
+}
+
+export function getPendingRequest(
+  adapter: string,
+  botId: string,
+  platformRequestId: string
+): ZhinRequest | undefined {
+  return pendingRequestObjects.get(requestMemoryKey(adapter, botId, platformRequestId));
+}
+
+export function removePendingRequest(adapter: string, botId: string, platformRequestId: string) {
+  pendingRequestObjects.delete(requestMemoryKey(adapter, botId, platformRequestId));
+}
+
+export async function markRequestConsumedByPlatformId(
+  adapter: string,
+  botId: string,
+  platformRequestId: string
+) {
+  const row = await findRequestRow(adapter, botId, platformRequestId);
+  if (row) await markRequestsConsumed([row.id]);
+  removePendingRequest(adapter, botId, platformRequestId);
+}
+
+export async function sendCatchUpToClient(ws: WebSocket) {
+  const reqs = await listUnconsumedRequests();
+  for (const row of reqs) {
+    const canAct = pendingRequestObjects.has(
+      requestMemoryKey(row.adapter, row.bot_id, row.platform_request_id)
+    );
+    if (ws.readyState === 1) {
+      ws.send(
+        JSON.stringify({
+          type: "bot:request",
+          data: rowToRequestPushData(row, canAct),
+        })
+      );
+    }
+  }
+  const notices = await listUnconsumedNotices();
+  for (const row of notices) {
+    if (ws.readyState === 1) {
+      ws.send(
+        JSON.stringify({
+          type: "bot:notice",
+          data: {
+            id: row.id,
+            adapter: row.adapter,
+            botId: row.bot_id,
+            noticeType: row.notice_type,
+            channel: { id: row.channel_id, type: row.channel_type },
+            payload: row.payload,
+            timestamp: row.created_at,
+          },
+        })
+      );
+    }
+  }
+}
+
+export function initBotHub(root: {
+  on: (ev: string, fn: (...a: any[]) => void) => void;
+  adapters?: Iterable<string>;
+  inject?: (key: string) => unknown;
+}) {
+  if (hubInited) return;
+  hubInited = true;
+
+  const handlerReq = (req: ZhinRequest) => {
+    const adapter = String(req.$adapter);
+    const botId = String(req.$bot);
+    onRequestReceived(adapter, botId, req);
+  };
+  const handlerNotice = (notice: any) => {
+    const adapter = String(notice.$adapter);
+    const botId = String(notice.$bot);
+    onNoticeReceived(adapter, botId, notice);
+  };
+
+  root.on("request.receive", handlerReq);
+  root.on("notice.receive", handlerNotice);
+
+  // 收消息推送：向控制台广播机器人收到的消息，供「收消息展示」使用
+  const adapterNames = root.adapters ? [...(root.adapters as Iterable<string>)] : [];
+  const inject = root.inject;
+  if (inject && typeof inject === "function" && adapterNames.length > 0) {
+    for (const name of adapterNames) {
+      try {
+        const ad = inject(name) as { on?: (ev: string, fn: (...a: any[]) => void) => void } | null;
+        if (ad && typeof ad.on === "function") {
+          ad.on("message.receive", (msg: any) => {
+            const payload = {
+              type: "bot:message",
+              data: {
+                adapter: name,
+                botId: msg?.$bot,
+                channelId: msg?.$channel?.id,
+                channelType: msg?.$channel?.type,
+                sender: msg?.$sender,
+                content: msg?.$content ?? [],
+                timestamp: typeof msg?.$timestamp === "number" ? msg.$timestamp : Date.now(),
+              },
+            };
+            broadcast(payload);
+          });
+        }
+      } catch {
+        // 忽略单个适配器注册失败
+      }
+    }
+  }
+}

package/src/bot-persistence.ts

@@ -0,0 +1,270 @@
+/**
+ * 控制台机器人请求/通知持久化
+ * 优先使用 zhin 内置数据库（console_bot_requests / console_bot_notices 表），
+ * 无数据库时回退到 JSON 文件存储。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import type { DatabaseFeature } from "@zhin.js/core";
+import { TABLE_REQUESTS, TABLE_NOTICES } from "./bot-db-models.js";
+
+export interface StoredRequestRow {
+  id: number;
+  adapter: string;
+  bot_id: string;
+  platform_request_id: string;
+  type: string;
+  sender_id: string;
+  sender_name: string;
+  comment: string;
+  channel_id: string;
+  channel_type: string;
+  created_at: number;
+  consumed: 0 | 1;
+  consumed_at?: number;
+}
+
+export interface StoredNoticeRow {
+  id: number;
+  adapter: string;
+  bot_id: string;
+  notice_type: string;
+  channel_type: string;
+  channel_id: string;
+  payload: string;
+  created_at: number;
+  consumed: 0 | 1;
+  consumed_at?: number;
+}
+
+interface StoreFile<T> {
+  nextId: number;
+  rows: T[];
+}
+
+const DATA_DIR = path.join(process.cwd(), "data");
+const REQ_FILE = path.join(DATA_DIR, "console_bot_requests.json");
+const NOTICE_FILE = path.join(DATA_DIR, "console_bot_notices.json");
+
+let dbRef: DatabaseFeature | null = null;
+
+export function initBotPersistence(root: { inject: (key: string) => unknown }) {
+  try {
+    dbRef = root.inject("database") as DatabaseFeature | null;
+  } catch {
+    dbRef = null;
+  }
+}
+
+function getReqModel() {
+  return dbRef?.db?.models?.get(TABLE_REQUESTS) as
+    | {
+        create: (row: Record<string, unknown>) => Promise<{ id: number }>;
+        select: () => { where: (q: Record<string, unknown>) => Promise<StoredRequestRow[]> };
+        update: (row: Record<string, unknown>) => { where: (q: Record<string, unknown>) => Promise<unknown> };
+      }
+    | undefined;
+}
+
+function getNoticeModel() {
+  return dbRef?.db?.models?.get(TABLE_NOTICES) as
+    | {
+        create: (row: Record<string, unknown>) => Promise<{ id: number }>;
+        select: () => { where: (q: Record<string, unknown>) => Promise<StoredNoticeRow[]> };
+        update: (row: Record<string, unknown>) => { where: (q: Record<string, unknown>) => Promise<unknown> };
+      }
+    | undefined;
+}
+
+// --------------- 文件回退 ---------------
+function ensureDir() {
+  if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function loadFile<T>(file: string, empty: StoreFile<T>): StoreFile<T> {
+  try {
+    if (!fs.existsSync(file)) return { ...empty };
+    const raw = fs.readFileSync(file, "utf-8");
+    const j = JSON.parse(raw) as StoreFile<T>;
+    if (!j || !Array.isArray(j.rows)) return { ...empty };
+    return {
+      nextId: typeof j.nextId === "number" ? j.nextId : 1,
+      rows: j.rows,
+    };
+  } catch {
+    return { ...empty };
+  }
+}
+
+function saveFile<T>(file: string, store: StoreFile<T>) {
+  ensureDir();
+  fs.writeFileSync(file, JSON.stringify(store, null, 0), "utf-8");
+}
+
+function normalizeReqRow(r: StoredRequestRow & { consumed?: number }): StoredRequestRow {
+  return {
+    ...r,
+    id: r.id!,
+    consumed: (r.consumed === 1 ? 1 : 0) as 0 | 1,
+  };
+}
+
+function normalizeNoticeRow(r: StoredNoticeRow & { consumed?: number }): StoredNoticeRow {
+  return {
+    ...r,
+    id: r.id!,
+    consumed: (r.consumed === 1 ? 1 : 0) as 0 | 1,
+  };
+}
+
+// --------------- 请求 ---------------
+export async function insertRequest(
+  row: Omit<StoredRequestRow, "id" | "consumed" | "consumed_at">
+): Promise<StoredRequestRow> {
+  const model = getReqModel();
+  if (model) {
+    const created = await model.create({
+      ...row,
+      consumed: 0,
+    });
+    const id = typeof created?.id === "number" ? created.id : (created as unknown as { id: number }).id;
+    return { ...row, id, consumed: 0 };
+  }
+  const store = loadFile<StoredRequestRow>(REQ_FILE, { nextId: 1, rows: [] });
+  const id = store.nextId++;
+  const full: StoredRequestRow = { ...row, id, consumed: 0 };
+  store.rows.push(full);
+  saveFile(REQ_FILE, store);
+  return full;
+}
+
+export async function insertNotice(
+  row: Omit<StoredNoticeRow, "id" | "consumed" | "consumed_at">
+): Promise<StoredNoticeRow> {
+  const model = getNoticeModel();
+  if (model) {
+    const created = await model.create({
+      ...row,
+      consumed: 0,
+    });
+    const id = typeof created?.id === "number" ? created.id : (created as unknown as { id: number }).id;
+    return { ...row, id, consumed: 0 };
+  }
+  const store = loadFile<StoredNoticeRow>(NOTICE_FILE, { nextId: 1, rows: [] });
+  const id = store.nextId++;
+  const full: StoredNoticeRow = { ...row, id, consumed: 0 };
+  store.rows.push(full);
+  saveFile(NOTICE_FILE, store);
+  return full;
+}
+
+export async function listUnconsumedRequests(): Promise<StoredRequestRow[]> {
+  const model = getReqModel();
+  if (model) {
+    const rows = await model.select().where({ consumed: 0 });
+    return (rows || []).map(normalizeReqRow).sort((a, b) => a.created_at - b.created_at);
+  }
+  const store = loadFile<StoredRequestRow>(REQ_FILE, { nextId: 1, rows: [] });
+  return store.rows
+    .filter((r) => r.consumed === 0)
+    .sort((a, b) => a.created_at - b.created_at);
+}
+
+export async function listUnconsumedNotices(): Promise<StoredNoticeRow[]> {
+  const model = getNoticeModel();
+  if (model) {
+    const rows = await model.select().where({ consumed: 0 });
+    return (rows || []).map(normalizeNoticeRow).sort((a, b) => a.created_at - b.created_at);
+  }
+  const store = loadFile<StoredNoticeRow>(NOTICE_FILE, { nextId: 1, rows: [] });
+  return store.rows
+    .filter((r) => r.consumed === 0)
+    .sort((a, b) => a.created_at - b.created_at);
+}
+
+export async function listRequestsForBot(
+  adapter: string,
+  botId: string
+): Promise<StoredRequestRow[]> {
+  const all = await listUnconsumedRequests();
+  return all.filter((r) => r.adapter === adapter && r.bot_id === botId);
+}
+
+export async function markRequestsConsumed(ids: number[]): Promise<void> {
+  if (!ids.length) return;
+  const model = getReqModel();
+  const now = Date.now();
+  if (model) {
+    for (const id of ids) {
+      await model.update({ consumed: 1, consumed_at: now }).where({ id });
+    }
+    return;
+  }
+  const store = loadFile<StoredRequestRow>(REQ_FILE, { nextId: 1, rows: [] });
+  const set = new Set(ids);
+  for (const r of store.rows) {
+    if (set.has(r.id) && r.consumed === 0) {
+      r.consumed = 1;
+      r.consumed_at = now;
+    }
+  }
+  saveFile(REQ_FILE, store);
+}
+
+export async function markNoticesConsumed(ids: number[]): Promise<void> {
+  if (!ids.length) return;
+  const model = getNoticeModel();
+  const now = Date.now();
+  if (model) {
+    for (const id of ids) {
+      await model.update({ consumed: 1, consumed_at: now }).where({ id });
+    }
+    return;
+  }
+  const store = loadFile<StoredNoticeRow>(NOTICE_FILE, { nextId: 1, rows: [] });
+  const set = new Set(ids);
+  for (const r of store.rows) {
+    if (set.has(r.id) && r.consumed === 0) {
+      r.consumed = 1;
+      r.consumed_at = now;
+    }
+  }
+  saveFile(NOTICE_FILE, store);
+}
+
+export async function findRequestRow(
+  adapter: string,
+  botId: string,
+  platformRequestId: string
+): Promise<StoredRequestRow | undefined> {
+  const model = getReqModel();
+  if (model) {
+    const rows = await model.select().where({
+      adapter,
+      bot_id: botId,
+      platform_request_id: platformRequestId,
+      consumed: 0,
+    });
+    return rows?.[0] ? normalizeReqRow(rows[0]) : undefined;
+  }
+  const store = loadFile<StoredRequestRow>(REQ_FILE, { nextId: 1, rows: [] });
+  const r = store.rows.find(
+    (x) =>
+      x.adapter === adapter &&
+      x.bot_id === botId &&
+      x.platform_request_id === platformRequestId &&
+      x.consumed === 0
+  );
+  return r;
+}
+
+export async function getRequestRowById(id: number): Promise<StoredRequestRow | undefined> {
+  const model = getReqModel();
+  if (model) {
+    const rows = await model.select().where({ id });
+    return rows?.[0] ? normalizeReqRow(rows[0]) : undefined;
+  }
+  const store = loadFile<StoredRequestRow>(REQ_FILE, { nextId: 1, rows: [] });
+  const r = store.rows.find((x) => x.id === id);
+  return r;
+}