@zhin.js/adapter-weixin-ilink 1.1.0 → 1.1.2

package/lib/weixin-inbound.js

@@ -1,224 +1,61 @@
-import fs from "node:fs";
-import path from "node:path";
-import { logger } from "./ilink-logger.js";
-import { generateId } from "./ilink-random.js";
+import { generateId } from './ilink-random.js';
 import { MessageItemType } from './ilink-types.js';
-import { resolveStateDir } from "./credentials.js";
-// ---------------------------------------------------------------------------
-// Context token store (in-process cache + disk persistence)
-// ---------------------------------------------------------------------------
-/**
- * contextToken is issued per-message by the Weixin getupdates API and must
- * be echoed verbatim in every outbound send. The in-memory map is the primary
- * lookup; a disk-backed file per account ensures tokens survive gateway restarts.
- */
-const contextTokenStore = new Map();
-function contextTokenKey(accountId, userId) {
-    return `${accountId}:${userId}`;
-}
-// ---------------------------------------------------------------------------
-// Disk persistence helpers
-// ---------------------------------------------------------------------------
-function resolveContextTokenFilePath(accountId) {
-    return path.join(resolveStateDir(), "context-tokens", `${accountId}.context-tokens.json`);
-}
-/** Persist all context tokens for a given account to disk. */
-function persistContextTokens(accountId) {
-    const prefix = `${accountId}:`;
-    const tokens = {};
-    for (const [k, v] of contextTokenStore) {
-        if (k.startsWith(prefix)) {
-            tokens[k.slice(prefix.length)] = v;
-        }
-    }
-    const filePath = resolveContextTokenFilePath(accountId);
-    try {
-        const dir = path.dirname(filePath);
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(filePath, JSON.stringify(tokens, null, 0), "utf-8");
-    }
-    catch (err) {
-        logger.warn(`persistContextTokens: failed to write ${filePath}: ${String(err)}`);
-    }
-}
-/**
- * 每条入站消息都会 setContextToken；全量同步写盘在消息高峰时是纯浪费。
- * 按 account 防抖合并，500ms 内多次写入只落盘一次。
- */
-const PERSIST_DEBOUNCE_MS = 500;
-const persistTimers = new Map();
-function schedulePersistContextTokens(accountId) {
-    const existing = persistTimers.get(accountId);
-    if (existing)
-        clearTimeout(existing);
-    const timer = setTimeout(() => {
-        persistTimers.delete(accountId);
-        persistContextTokens(accountId);
-    }, PERSIST_DEBOUNCE_MS);
-    // 不让防抖定时器拖住进程退出
-    timer.unref?.();
-    persistTimers.set(accountId, timer);
-}
-/** 立即落盘所有待写（endpoint stop / 测试用）。 */
-export function flushContextTokenPersist(accountId) {
-    for (const [id, timer] of [...persistTimers]) {
-        if (accountId !== undefined && id !== accountId)
-            continue;
-        clearTimeout(timer);
-        persistTimers.delete(id);
-        persistContextTokens(id);
-    }
-}
-/**
- * Restore persisted context tokens for an account into the in-memory map.
- * Called once during gateway startAccount to survive restarts.
- */
-export function restoreContextTokens(accountId) {
-    const filePath = resolveContextTokenFilePath(accountId);
-    try {
-        if (!fs.existsSync(filePath))
-            return;
-        const raw = fs.readFileSync(filePath, "utf-8");
-        const tokens = JSON.parse(raw);
-        let count = 0;
-        for (const [userId, token] of Object.entries(tokens)) {
-            if (typeof token === "string" && token) {
-                contextTokenStore.set(contextTokenKey(accountId, userId), token);
-                count++;
-            }
-        }
-        logger.info(`restoreContextTokens: restored ${count} tokens for account=${accountId}`);
-    }
-    catch (err) {
-        logger.warn(`restoreContextTokens: failed to read ${filePath}: ${String(err)}`);
-    }
-}
-/** Remove all context tokens for a given account (memory + disk). */
-export function clearContextTokensForAccount(accountId) {
-    const prefix = `${accountId}:`;
-    for (const k of [...contextTokenStore.keys()]) {
-        if (k.startsWith(prefix)) {
-            contextTokenStore.delete(k);
-        }
-    }
-    const filePath = resolveContextTokenFilePath(accountId);
-    try {
-        if (fs.existsSync(filePath))
-            fs.unlinkSync(filePath);
-    }
-    catch (err) {
-        logger.warn(`clearContextTokensForAccount: failed to remove ${filePath}: ${String(err)}`);
-    }
-    logger.info(`clearContextTokensForAccount: cleared tokens for account=${accountId}`);
-}
-/** Store a context token for a given account+user pair (memory + debounced disk). */
-export function setContextToken(accountId, userId, token) {
-    const k = contextTokenKey(accountId, userId);
-    logger.debug(`setContextToken: key=${k}`);
-    contextTokenStore.set(k, token);
-    schedulePersistContextTokens(accountId);
-}
-/** Retrieve the cached context token for a given account+user pair. */
-export function getContextToken(accountId, userId) {
-    const k = contextTokenKey(accountId, userId);
-    const val = contextTokenStore.get(k);
-    logger.debug(`getContextToken: key=${k} found=${val !== undefined} storeSize=${contextTokenStore.size}`);
-    return val;
-}
-/**
- * List all peer userIds that hold a context token for the given account
- * (memory map, already merged with the disk-backed file on restore).
- * Personal WeChat has no contact/profile API; this is the only peer catalog.
- */
-export function listContextTokenUserIds(accountId) {
-    const prefix = `${accountId}:`;
-    const ids = [];
-    for (const k of contextTokenStore.keys()) {
-        if (k.startsWith(prefix))
-            ids.push(k.slice(prefix.length));
-    }
-    return ids;
-}
-/**
- * Find all accountIds that have an active contextToken for the given userId.
- * Used to infer the sending bot account from the recipient address when
- * accountId is not explicitly provided (e.g. cron delivery).
- *
- * Returns all matching accountIds (not just the first) so the caller can
- * detect ambiguity when multiple accounts have sessions with the same user.
- */
-export function findAccountIdsByContextToken(accountIds, userId) {
-    return accountIds.filter((id) => contextTokenStore.has(contextTokenKey(id, userId)));
-}
-// ---------------------------------------------------------------------------
-// Message ID generation
-// ---------------------------------------------------------------------------
 function generateMessageSid() {
-    return generateId("openclaw-weixin");
+    return generateId('openclaw-weixin');
 }
-/** Returns true if the message item is a media type (image, video, file, or voice). */
 export function isMediaItem(item) {
-    return (item.type === MessageItemType.IMAGE ||
-        item.type === MessageItemType.VIDEO ||
-        item.type === MessageItemType.FILE ||
-        item.type === MessageItemType.VOICE);
+    return item.type === MessageItemType.IMAGE
+        || item.type === MessageItemType.VIDEO
+        || item.type === MessageItemType.FILE
+        || item.type === MessageItemType.VOICE;
 }
 export function bodyFromItemList(itemList) {
     if (!itemList?.length)
-        return "";
+        return '';
     for (const item of itemList) {
         if (item.type === MessageItemType.TEXT && item.text_item?.text != null) {
             return String(item.text_item.text);
         }
-        // 语音转文字：如果语音消息有 text 字段，直接使用文字内容
         if (item.type === MessageItemType.VOICE && item.voice_item?.text) {
             return item.voice_item.text;
         }
     }
-    return "";
+    return '';
 }
-/**
- * Convert a WeixinMessage from getUpdates to the inbound MsgContext for the core pipeline.
- * Media: only pass MediaPath (local file, after CDN download + decrypt).
- * We never pass MediaUrl — the upstream CDN URL is encrypted/auth-only.
- * Priority when multiple media types present: image > video > file > voice.
- */
 export function weixinMessageToMsgContext(msg, accountId, opts) {
-    const from_user_id = msg.from_user_id ?? "";
+    const fromUserId = msg.from_user_id ?? '';
     const ctx = {
         Body: bodyFromItemList(msg.item_list),
-        From: from_user_id,
-        To: from_user_id,
+        From: fromUserId,
+        To: fromUserId,
         AccountId: accountId,
-        OriginatingChannel: "openclaw-weixin",
-        OriginatingTo: from_user_id,
+        OriginatingChannel: 'openclaw-weixin',
+        OriginatingTo: fromUserId,
         MessageSid: generateMessageSid(),
         Timestamp: msg.create_time_ms,
-        Provider: "openclaw-weixin",
-        ChatType: "direct",
+        Provider: 'openclaw-weixin',
+        ChatType: 'direct',
     };
-    if (msg.context_token) {
+    if (msg.context_token)
         ctx.context_token = msg.context_token;
-    }
     if (opts?.decryptedPicPath) {
         ctx.MediaPath = opts.decryptedPicPath;
-        ctx.MediaType = "image/*";
+        ctx.MediaType = 'image/*';
     }
     else if (opts?.decryptedVideoPath) {
         ctx.MediaPath = opts.decryptedVideoPath;
-        ctx.MediaType = "video/mp4";
+        ctx.MediaType = 'video/mp4';
     }
     else if (opts?.decryptedFilePath) {
         ctx.MediaPath = opts.decryptedFilePath;
-        ctx.MediaType = opts.fileMediaType ?? "application/octet-stream";
+        ctx.MediaType = opts.fileMediaType ?? 'application/octet-stream';
     }
     else if (opts?.decryptedVoicePath) {
         ctx.MediaPath = opts.decryptedVoicePath;
-        ctx.MediaType = opts.voiceMediaType ?? "audio/wav";
+        ctx.MediaType = opts.voiceMediaType ?? 'audio/wav';
     }
     return ctx;
 }
-/** Extract the context_token from an inbound WeixinMsgContext. */
 export function getContextTokenFromMsgContext(ctx) {
     return ctx.context_token;
 }

package/lib/weixin-send-media.js

@@ -15,7 +15,11 @@ import { uploadFileAttachmentToWeixin, uploadFileToWeixin, uploadVideoToWeixin }
 export async function sendWeixinMediaFile(params) {
     const { filePath, to, text, opts, cdnBaseUrl } = params;
     const mime = getMimeFromFilename(filePath);
-    const uploadOpts = { baseUrl: opts.baseUrl, token: opts.token };
+    const uploadOpts = {
+        baseUrl: opts.baseUrl,
+        metadata: opts.metadata,
+        token: opts.token,
+    };
     if (mime.startsWith("video/")) {
         logger.info(`[weixin] sendWeixinMediaFile: uploading video filePath=${filePath} to=${to}`);
         const uploaded = await uploadVideoToWeixin({

package/lib/weixin-send.js

@@ -51,6 +51,7 @@ export async function sendMessageWeixin(params) {
     try {
         await sendMessageApi({
             baseUrl: opts.baseUrl,
+            metadata: opts.metadata,
             token: opts.token,
             timeoutMs: opts.timeoutMs,
             body: req,
@@ -90,6 +91,7 @@ async function sendMediaItems(params) {
         try {
             await sendMessageApi({
                 baseUrl: opts.baseUrl,
+                metadata: opts.metadata,
                 token: opts.token,
                 timeoutMs: opts.timeoutMs,
                 body: req,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/adapter-weixin-ilink",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "description": "Zhin.js Weixin iLink (ClawBot) adapter for Plugin Runtime (long-poll)",
   "main": "./lib/index.js",
@@ -48,17 +48,17 @@
     }
   },
   "dependencies": {
-    "@zhin.js/adapter": "1.1.12",
-    "@zhin.js/core": "1.1.35",
-    "@zhin.js/feature-kit": "1.1.0",
-    "@zhin.js/im-contract": "1.1.0",
-    "@zhin.js/logger": "1.1.0"
+    "@zhin.js/adapter": "1.1.14",
+    "@zhin.js/core": "1.1.37",
+    "@zhin.js/feature-kit": "1.1.1",
+    "@zhin.js/im-contract": "1.1.1",
+    "@zhin.js/logger": "1.1.1"
   },
   "peerDependencies": {
-    "@zhin.js/adapter": "^1.1.12",
-    "@zhin.js/command": "^1.1.0",
-    "@zhin.js/core": "^1.1.35",
-    "zhin.js": "^1.1.0"
+    "@zhin.js/adapter": "^1.1.14",
+    "@zhin.js/command": "^1.1.1",
+    "@zhin.js/core": "^1.1.37",
+    "zhin.js": "^1.1.2"
   },
   "peerDependenciesMeta": {
     "@zhin.js/command": {
@@ -72,7 +72,7 @@
     "@types/node": "^26.1.2",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
-    "zhin.js": "1.1.0"
+    "zhin.js": "1.1.2"
   },
   "ilink_appid": "bot",
   "engines": {

package/plugin.js

@@ -8,7 +8,7 @@ export default definePlugin({
         displayName: 'Weixin iLink Adapter',
     },
     setup(context) {
-        // 运行中 endpoint 注册表（weixin-ilink.endpoint list 的"运行中"数据源）
+        // 运行中 endpoint 注册表（weixin-ilink endpoint list 的"运行中"数据源）
         context.resources.provide(weixinIlinkRuntimeStateToken, createEndpointRuntimeState());
     },
 });

package/schema.json

@@ -18,6 +18,12 @@
       "type": "number",
       "default": 35000
     },
+    "dataDir": {
+      "type": "string",
+      "minLength": 1,
+      "default": "data/weixin-ilink",
+      "description": "Endpoint state root for credentials, cursors, context tokens, and media"
+    },
     "master": {
       "type": [
         "string",
@@ -38,10 +44,11 @@
     },
     "endpoints": {
       "type": "array",
+      "minItems": 1,
       "description": "多账号：一个插件实例挂多个 endpoint。每项与顶层字段同构（id 必填，其余覆盖顶层）",
       "items": {
         "type": "object",
-        "additionalProperties": true,
+        "additionalProperties": false,
         "properties": {
           "master": {
             "type": [
@@ -63,16 +70,37 @@
           },
           "botToken": {
             "type": "string",
-            "description": "iLink bot token (prefer env WEIXIN_ILINK_TOKEN or sidecar credential file)"
+            "description": "iLink bot token; omit to load endpoint state or start QR login"
           },
           "id": {
             "type": "string",
+            "pattern": "^[A-Za-z0-9_.-]+$",
             "description": "Weixin iLink bot name"
+          },
+          "botAgent": {
+            "type": "string"
+          },
+          "baseUrl": {
+            "type": "string"
+          },
+          "cdnBaseUrl": {
+            "type": "string"
+          },
+          "longPollTimeoutMs": {
+            "type": "number"
+          },
+          "dataDir": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Endpoint state root"
+          },
+          "commandPrefix": {
+            "type": "string",
+            "description": "本 endpoint 的命令前缀"
           }
         },
         "required": [
-          "id",
-          "botToken"
+          "id"
         ]
       }
     },

package/src/client.ts

@@ -1,7 +1,8 @@
-import { getContextToken } from './context-store.js';
+import type { WeixinContextTokenStore } from './context-store.js';
 import type { WeixinIlinkCredentials } from './credentials.js';
 import { sendTyping } from './ilink-api.js';
 import type { WeixinConfigManager } from './ilink-config-cache.js';
+import type { IlinkClientMetadata } from './ilink-meta.js';
 import type { ResolvedWeixinIlinkConfig } from './protocol.js';
 import { sendMessageWeixin } from './weixin-send.js';
 import { sendWeixinMediaFile } from './weixin-send-media.js';
@@ -9,25 +10,41 @@ import { defineEndpointClient } from 'zhin.js/adapter';
 
 /** Direct iLink API client backed by the Endpoint's live authenticated session. */
 export class WeixinIlinkClient {
+  readonly config: ResolvedWeixinIlinkConfig;
+  readonly #metadata: IlinkClientMetadata;
+  readonly #resolveCredentials: () => WeixinIlinkCredentials | null;
+  readonly #resolveConfigManager: () => WeixinConfigManager | undefined;
+  readonly #sendTextImpl: typeof sendMessageWeixin;
+  readonly #contextTokens: WeixinContextTokenStore;
+
   constructor(
-    readonly config: ResolvedWeixinIlinkConfig,
-    private readonly resolveCredentials: () => WeixinIlinkCredentials | null,
-    private readonly resolveConfigManager: () => WeixinConfigManager | undefined,
-    private readonly sendTextImpl: typeof sendMessageWeixin,
-  ) {}
+    config: ResolvedWeixinIlinkConfig,
+    metadata: IlinkClientMetadata,
+    resolveCredentials: () => WeixinIlinkCredentials | null,
+    resolveConfigManager: () => WeixinConfigManager | undefined,
+    sendTextImpl: typeof sendMessageWeixin,
+    contextTokens: WeixinContextTokenStore,
+  ) {
+    this.config = config;
+    this.#metadata = metadata;
+    this.#resolveCredentials = resolveCredentials;
+    this.#resolveConfigManager = resolveConfigManager;
+    this.#sendTextImpl = sendTextImpl;
+    this.#contextTokens = contextTokens;
+  }
 
   get credentials(): WeixinIlinkCredentials {
-    const credentials = this.resolveCredentials();
+    const credentials = this.#resolveCredentials();
     if (!credentials?.botToken) throw new Error('weixin-ilink client not authenticated');
     return credentials;
   }
 
   get authenticated(): boolean {
-    return Boolean(this.resolveCredentials()?.botToken);
+    return Boolean(this.#resolveCredentials()?.botToken);
   }
 
   get apiBaseUrl(): string {
-    return this.resolveCredentials()?.baseUrl ?? this.config.baseUrl;
+    return this.#resolveCredentials()?.baseUrl ?? this.config.baseUrl;
   }
 
   get cdnBaseUrl(): string {
@@ -35,16 +52,25 @@ export class WeixinIlinkClient {
   }
 
   contextToken(userId: string): string | undefined {
-    return getContextToken(this.config.id, userId);
+    return this.#contextTokens.get(userId);
+  }
+
+  reachableUserIds(): string[] {
+    return this.#contextTokens.userIds();
   }
 
   async sendText(to: string, text: string): Promise<{ messageId: string }> {
     const contextToken = this.contextToken(to);
     if (!contextToken) throw new Error(`missing context_token for peer ${to}`);
-    return this.sendTextImpl({
+    return this.#sendTextImpl({
       to,
       text,
-      opts: { baseUrl: this.apiBaseUrl, token: this.credentials.botToken, contextToken },
+      opts: {
+        baseUrl: this.apiBaseUrl,
+        metadata: this.#metadata,
+        token: this.credentials.botToken,
+        contextToken,
+      },
     });
   }
 
@@ -55,18 +81,24 @@ export class WeixinIlinkClient {
       filePath,
       to,
       text,
-      opts: { baseUrl: this.apiBaseUrl, token: this.credentials.botToken, contextToken },
+      opts: {
+        baseUrl: this.apiBaseUrl,
+        metadata: this.#metadata,
+        token: this.credentials.botToken,
+        contextToken,
+      },
       cdnBaseUrl: this.cdnBaseUrl,
     });
   }
 
   async sendTyping(userId: string, status: number): Promise<boolean> {
-    const manager = this.resolveConfigManager();
+    const manager = this.#resolveConfigManager();
     if (!this.authenticated || !manager) return false;
     const cfg = await manager.getForUser(userId, this.contextToken(userId));
     if (!cfg.typingTicket) return false;
     await sendTyping({
       baseUrl: this.apiBaseUrl,
+      metadata: this.#metadata,
       token: this.credentials.botToken,
       body: { ilink_user_id: userId, typing_ticket: cfg.typingTicket, status },
     });

package/src/context-store.ts

@@ -1,10 +1,101 @@
-export {
-  setContextToken,
-  getContextToken,
-  listContextTokenUserIds,
-  restoreContextTokens,
-  clearContextTokensForAccount,
-  flushContextTokenPersist,
-  bodyFromItemList,
-  isMediaItem,
-} from "./weixin-inbound.js";
+import fs from 'node:fs';
+import path from 'node:path';
+import type { WeixinIlinkStateStore } from './credentials.js';
+import { logger } from './ilink-logger.js';
+
+const PERSIST_DEBOUNCE_MS = 500;
+
+/** Endpoint-owned context-token repository with account-scoped persistence. */
+export class WeixinContextTokenStore {
+  readonly state: WeixinIlinkStateStore;
+  readonly #tokens = new Map<string, string>();
+  #persistTimer?: ReturnType<typeof setTimeout>;
+
+  constructor(state: WeixinIlinkStateStore) {
+    this.state = state;
+  }
+
+  get accountId(): string {
+    return this.state.endpointId;
+  }
+
+  get(userId: string): string | undefined {
+    const value = this.#tokens.get(userId);
+    logger.debug(`contextTokenStore.get: account=${this.accountId} user=${userId} found=${value !== undefined} storeSize=${this.#tokens.size}`);
+    return value;
+  }
+
+  set(userId: string, token: string): void {
+    logger.debug(`contextTokenStore.set: account=${this.accountId} user=${userId}`);
+    this.#tokens.set(userId, token);
+    this.#schedulePersist();
+  }
+
+  userIds(): string[] {
+    return [...this.#tokens.keys()];
+  }
+
+  restore(): void {
+    const filePath = this.#filePath();
+    try {
+      if (!fs.existsSync(filePath)) return;
+      const tokens = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as Record<string, unknown>;
+      let count = 0;
+      for (const [userId, token] of Object.entries(tokens)) {
+        if (typeof token !== 'string' || !token) continue;
+        this.#tokens.set(userId, token);
+        count += 1;
+      }
+      logger.info(`contextTokenStore.restore: restored ${count} tokens for account=${this.accountId}`);
+    } catch (error) {
+      logger.warn(`contextTokenStore.restore: failed to read ${filePath}: ${String(error)}`);
+    }
+  }
+
+  flush(): void {
+    if (this.#persistTimer) {
+      clearTimeout(this.#persistTimer);
+      this.#persistTimer = undefined;
+    }
+    this.#persist();
+  }
+
+  clear(): void {
+    if (this.#persistTimer) {
+      clearTimeout(this.#persistTimer);
+      this.#persistTimer = undefined;
+    }
+    this.#tokens.clear();
+    const filePath = this.#filePath();
+    try {
+      if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    } catch (error) {
+      logger.warn(`contextTokenStore.clear: failed to remove ${filePath}: ${String(error)}`);
+    }
+  }
+
+  #filePath(): string {
+    return this.state.contextTokensPath();
+  }
+
+  #schedulePersist(): void {
+    if (this.#persistTimer) clearTimeout(this.#persistTimer);
+    this.#persistTimer = setTimeout(() => {
+      this.#persistTimer = undefined;
+      this.#persist();
+    }, PERSIST_DEBOUNCE_MS);
+    this.#persistTimer.unref?.();
+  }
+
+  #persist(): void {
+    const filePath = this.#filePath();
+    try {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify(Object.fromEntries(this.#tokens)), 'utf-8');
+    } catch (error) {
+      logger.warn(`contextTokenStore.persist: failed to write ${filePath}: ${String(error)}`);
+    }
+  }
+}
+
+export { bodyFromItemList, isMediaItem } from './weixin-inbound.js';