@axiom-lattice/gateway 2.1.96 → 2.1.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.96",
+  "version": "2.1.98",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -40,11 +40,11 @@
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
     "zod": "3.25.76",
-    "@axiom-lattice/agent-eval": "2.1.78",
-    "@axiom-lattice/core": "2.1.84",
-    "@axiom-lattice/pg-stores": "1.0.75",
-    "@axiom-lattice/protocols": "2.1.43",
-    "@axiom-lattice/queue-redis": "1.0.42"
+    "@axiom-lattice/agent-eval": "2.1.80",
+    "@axiom-lattice/core": "2.1.86",
+    "@axiom-lattice/pg-stores": "1.0.77",
+    "@axiom-lattice/protocols": "2.1.44",
+    "@axiom-lattice/queue-redis": "1.0.43"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -68,7 +68,7 @@
     "build": "tsup src/index.ts --format cjs,esm --dts --clean --sourcemap",
     "start": "node dist/index.js",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch --sourcemap",
-    "lint": "tsc --noEmit",
+    "lint": "eslint src && tsc --noEmit",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"

package/src/channels/lark/LarkChannelAdapter.ts

@@ -194,4 +194,24 @@ export const larkChannelAdapter: ChannelAdapter<LarkChannelInstallationConfig> =
     activeConnections.set(installationId, client);
     logger.info("Lark WS client connected", { installationId });
   },
+
+  async disconnect(installationId: string): Promise<void> {
+    const client = activeConnections.get(installationId);
+    if (!client) {
+      logger.warn("Lark WS not connected, nothing to disconnect", { installationId });
+      return;
+    }
+
+    logger.info("Lark WS client disconnecting", { installationId });
+    try {
+      client.close({ force: true });
+    } catch (err) {
+      logger.error("Lark WS client stop error", {
+        installationId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+    activeConnections.delete(installationId);
+    logger.info("Lark WS client disconnected", { installationId });
+  },
 };

package/src/channels/routes.ts

@@ -1,5 +1,6 @@
 import type { FastifyInstance } from "fastify";
 import { registerLarkChannelRoutes } from "./lark/routes";
+import { registerWechatChannelRoutes } from "./wechat/routes";
 import type { MessageRouter } from "../router/MessageRouter";
 import type { ChannelInstallationStore } from "@axiom-lattice/protocols";
 
@@ -15,6 +16,7 @@ type ChannelRouteRegistrar = (
 
 const channelRouteRegistrars: ChannelRouteRegistrar[] = [
   (app, deps) => registerLarkChannelRoutes(app, deps),
+  (app, _deps) => registerWechatChannelRoutes(app),
 ];
 
 export function registerChannelRoutes(

package/src/channels/wechat/WechatChannelAdapter.ts

@@ -0,0 +1,294 @@
+import { z } from "zod";
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  ReplyTarget,
+  ChannelInstallation,
+} from "@axiom-lattice/protocols";
+import type { WechatChannelInstallationConfig } from "@axiom-lattice/protocols";
+import { getUpdates, sendMessage } from "./wechat-client";
+import { setContextToken, getContextToken, deleteContextToken } from "./context-store";
+import { Logger } from "../../logger/Logger";
+
+const logger = new Logger({ serviceName: "lattice/gateway/wechat" });
+
+const wechatConfigSchema = z.object({
+  botToken: z.string(),
+  uin: z.string().optional(),
+});
+
+const MAX_RECONNECT_DELAY_MS = 30_000;
+const BASE_RECONNECT_DELAY_MS = 1_000;
+const HEARTBEAT_INTERVAL_MS = 60_000;
+const CHANNEL_VERSION = "1.0.2";
+
+// ─── Message type constants ───────────────────────────────────────────────
+
+const MSG_TYPE_USER = 1;
+const MSG_ITEM_TEXT = 1;
+
+// ─── Polling connection state ─────────────────────────────────────────────
+
+interface PollingState {
+  installationId: string;
+  abortController: AbortController;
+  lastActivity: number;
+  heartbeatTimer: NodeJS.Timeout;
+}
+
+const activeConnections = new Map<string, PollingState>();
+
+// ─── Message dedup ────────────────────────────────────────────────────────
+
+const seenClientIds = new Set<string>();
+
+function addToDedup(clientId: string): boolean {
+  if (!clientId || seenClientIds.has(clientId)) return false;
+  seenClientIds.add(clientId);
+  if (seenClientIds.size > 1000) {
+    const first = seenClientIds.values().next().value;
+    if (first !== undefined) seenClientIds.delete(first);
+  }
+  return true;
+}
+
+// ─── Text extraction from iLink message ───────────────────────────────────
+
+function extractText(msg: { item_list?: Array<{ type?: number; text_item?: { text?: string } }> }): string | null {
+  if (!msg.item_list?.length) return null;
+  for (const item of msg.item_list) {
+    if (item.type === MSG_ITEM_TEXT && item.text_item?.text) {
+      return item.text_item.text;
+    }
+  }
+  return null;
+}
+
+// ─── Adapter ──────────────────────────────────────────────────────────────
+
+export const wechatChannelAdapter: ChannelAdapter<WechatChannelInstallationConfig> = {
+  channel: "wechat",
+
+  configSchema: wechatConfigSchema,
+
+  async receive(
+    rawPayload: unknown,
+    installation: ChannelInstallation<WechatChannelInstallationConfig>,
+  ): Promise<InboundMessage | null> {
+    const msg = rawPayload as {
+      from_user_id?: string;
+      client_id?: string;
+      message_type?: number;
+      item_list?: Array<{ type?: number; text_item?: { text?: string } }>;
+      context_token?: string;
+    };
+
+    // Only process user messages (type 1), skip bot echoes (type 2)
+    if (msg.message_type !== MSG_TYPE_USER) return null;
+
+    const senderId = msg.from_user_id;
+    if (!senderId) return null;
+
+    const text = extractText(msg);
+    if (!text) return null;
+
+    // Cache context token for reply
+    if (msg.context_token) {
+      setContextToken(senderId, msg.context_token);
+    }
+
+    return {
+      channel: "wechat",
+      channelInstallationId: installation.id,
+      tenantId: installation.tenantId,
+      sender: {
+        id: senderId,
+        displayName: senderId.split("@")[0],
+      },
+      content: {
+        text,
+      },
+      conversation: {
+        id: senderId,
+        type: "direct",
+      },
+      replyTarget: {
+        adapterChannel: "wechat",
+        channelInstallationId: installation.id,
+        rawTarget: { senderId },
+      },
+    };
+  },
+
+  async sendReply(
+    replyTarget: ReplyTarget,
+    message: OutboundMessage,
+    installation: ChannelInstallation<WechatChannelInstallationConfig>,
+  ): Promise<void> {
+    const senderId = replyTarget.rawTarget.senderId as string;
+    const contextToken = getContextToken(senderId);
+
+    if (!contextToken) {
+      logger.warn("WeChat context token expired, cannot send reply", {
+        installationId: installation.id,
+        senderId,
+      });
+      deleteContextToken(senderId);
+      return;
+    }
+
+    const { botToken } = installation.config;
+    await sendMessage(botToken, senderId, message.text, contextToken);
+  },
+
+  resolveThreadId(message: InboundMessage, binding: unknown): string {
+    const date = new Date().toISOString().split("T")[0];
+    const agentId = (binding as { agentId: string }).agentId;
+    return `wechat:dm:${message.sender.id}:${agentId}:${date}`;
+  },
+
+  async connect(
+    installation: ChannelInstallation<WechatChannelInstallationConfig>,
+    deps?: unknown,
+  ): Promise<void> {
+    const { id: installationId, tenantId, config } = installation;
+
+    if (!config.botToken) {
+      logger.warn("WeChat installation missing botToken, skipping", { installationId });
+      return;
+    }
+
+    if (activeConnections.has(installationId)) {
+      logger.warn("WeChat polling already running for installation, skipping", { installationId });
+      return;
+    }
+
+    logger.info("WeChat polling starting", { installationId, tenantId });
+
+    const abortController = new AbortController();
+
+    const heartbeatTimer = setInterval(() => {
+      const state2 = activeConnections.get(installationId);
+      if (!state2) {
+        clearInterval(heartbeatTimer);
+        return;
+      }
+      const elapsed = Date.now() - state2.lastActivity;
+      if (elapsed > HEARTBEAT_INTERVAL_MS * 2) {
+        logger.error("WeChat polling heartbeat lost — no activity", {
+          installationId,
+          elapsedMs: elapsed,
+        });
+        state2.abortController.abort();
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+
+    const state: PollingState = {
+      installationId,
+      abortController,
+      lastActivity: Date.now(),
+      heartbeatTimer,
+    };
+    activeConnections.set(installationId, state);
+
+    const router = (deps as { router?: { dispatch(msg: InboundMessage): Promise<unknown> } })?.router;
+
+    let syncBuffer = "";
+    let reconnectDelay = BASE_RECONNECT_DELAY_MS;
+
+    const scheduleNextPoll = (): void => {
+      poll().catch((err) => {
+        logger.error("WeChat poll iteration crashed", {
+          installationId,
+          error: err instanceof Error ? err.message : String(err),
+        });
+        const currentState = activeConnections.get(installationId);
+        if (currentState && !currentState.abortController.signal.aborted) {
+          setTimeout(scheduleNextPoll, reconnectDelay);
+        }
+      });
+    };
+
+    const poll = async (): Promise<void> => {
+      const currentState = activeConnections.get(installationId);
+      if (!currentState || currentState.abortController.signal.aborted) {
+        logger.info("WeChat polling aborted", { installationId });
+        return;
+      }
+
+      try {
+        const result = await getUpdates(
+          config.botToken,
+          syncBuffer,
+          currentState.abortController.signal,
+        );
+        syncBuffer = result.syncBuffer;
+        reconnectDelay = BASE_RECONNECT_DELAY_MS;
+        currentState.lastActivity = Date.now();
+
+        if (result.msgs.length > 0) {
+          logger.info("WeChat poll received messages", {
+            installationId,
+            count: result.msgs.length,
+          });
+        }
+
+        for (const rawMsg of result.msgs) {
+          // Only user messages, skip bot echoes and non-text
+          if (rawMsg.message_type !== MSG_TYPE_USER) continue;
+
+          const text = extractText(rawMsg);
+          if (!text) continue;
+
+          if (!addToDedup((rawMsg as { client_id?: string }).client_id ?? "")) continue;
+
+          const inbound = await wechatChannelAdapter.receive(
+            rawMsg,
+            installation as ChannelInstallation<WechatChannelInstallationConfig>,
+          );
+          if (inbound && router) {
+            const dispatchResult = await router.dispatch(inbound);
+            if (!(dispatchResult as { success?: boolean }).success) {
+              logger.warn("WeChat dispatch failed", {
+                installationId,
+                error: (dispatchResult as { error?: { message?: string } }).error?.message,
+              });
+            }
+          }
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          logger.info("WeChat poll aborted by signal", { installationId });
+          return;
+        }
+
+        logger.error("WeChat poll error", {
+          installationId,
+          error: err instanceof Error ? err.message : String(err),
+        });
+        await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+        reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+      }
+
+      scheduleNextPoll();
+    };
+
+    scheduleNextPoll();
+    logger.info("WeChat polling started", { installationId });
+  },
+
+  async disconnect(installationId: string): Promise<void> {
+    const state = activeConnections.get(installationId);
+    if (!state) {
+      logger.warn("WeChat polling not running, nothing to disconnect", { installationId });
+      return;
+    }
+
+    logger.info("WeChat polling disconnecting", { installationId });
+    state.abortController.abort();
+    clearInterval(state.heartbeatTimer);
+    activeConnections.delete(installationId);
+    logger.info("WeChat polling disconnected", { installationId });
+  },
+};

package/src/channels/wechat/context-store.ts

@@ -0,0 +1,47 @@
+interface ContextTokenEntry {
+  token: string;
+  senderId: string;
+  updatedAt: number;
+}
+
+const TOKEN_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const store = new Map<string, ContextTokenEntry>();
+const timers = new Map<string, NodeJS.Timeout>();
+
+export function getContextToken(senderId: string): string | undefined {
+  const entry = store.get(senderId);
+  if (!entry) return undefined;
+  if (Date.now() - entry.updatedAt > TOKEN_TTL_MS) {
+    deleteContextToken(senderId);
+    return undefined;
+  }
+  return entry.token;
+}
+
+export function setContextToken(senderId: string, token: string): void {
+  // Clear existing timer
+  const existingTimer = timers.get(senderId);
+  if (existingTimer) clearTimeout(existingTimer);
+
+  store.set(senderId, { token, senderId, updatedAt: Date.now() });
+
+  // Auto-cleanup after TTL
+  const timer = setTimeout(() => {
+    store.delete(senderId);
+    timers.delete(senderId);
+  }, TOKEN_TTL_MS);
+  timers.set(senderId, timer);
+}
+
+export function deleteContextToken(senderId: string): void {
+  store.delete(senderId);
+  const timer = timers.get(senderId);
+  if (timer) {
+    clearTimeout(timer);
+    timers.delete(senderId);
+  }
+}
+
+export function getContextTokenStoreSize(): number {
+  return store.size;
+}

package/src/channels/wechat/controller.ts

@@ -0,0 +1,59 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { getQrCode, getQrCodeStatus } from "./wechat-client";
+import type { QrSession } from "./types";
+
+const qrSessions = new Map<string, QrSession>();
+const SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+function cleanupExpiredSessions(): void {
+  const now = Date.now();
+  for (const [key, session] of qrSessions) {
+    if (now - session.createdAt > SESSION_TTL_MS) {
+      qrSessions.delete(key);
+    }
+  }
+}
+
+export async function handleGetQrCode(
+  _request: FastifyRequest,
+  reply: FastifyReply,
+): Promise<void> {
+  try {
+    cleanupExpiredSessions();
+    const { qrcode, qrcodeImgUrl } = await getQrCode();
+    qrSessions.set(qrcode, { qrcode, createdAt: Date.now() });
+    reply.send({ success: true, data: { qrcode, qrcodeImgUrl } });
+  } catch (err) {
+    reply.status(500).send({
+      success: false,
+      message: err instanceof Error ? err.message : "Failed to get QR code",
+    });
+  }
+}
+
+export async function handleGetQrCodeStatus(
+  request: FastifyRequest,
+  reply: FastifyReply,
+): Promise<void> {
+  const { qrcode } = request.query as { qrcode?: string };
+  if (!qrcode) {
+    reply.status(400).send({ success: false, message: "qrcode is required" });
+    return;
+  }
+
+  const session = qrSessions.get(qrcode);
+  if (!session) {
+    reply.status(404).send({ success: false, message: "Session not found or expired" });
+    return;
+  }
+
+  try {
+    const result = await getQrCodeStatus(qrcode);
+    reply.send({ success: true, data: result });
+  } catch (err) {
+    reply.status(500).send({
+      success: false,
+      message: err instanceof Error ? err.message : "Failed to check QR status",
+    });
+  }
+}

package/src/channels/wechat/routes.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance } from "fastify";
+import { handleGetQrCode, handleGetQrCodeStatus } from "./controller";
+
+export function registerWechatChannelRoutes(app: FastifyInstance): void {
+  app.get("/api/channels/wechat/setup/qrcode", handleGetQrCode);
+  app.get("/api/channels/wechat/setup/status", handleGetQrCodeStatus);
+}

package/src/channels/wechat/types.ts

@@ -0,0 +1,62 @@
+export interface WechatInstallationConfig {
+  botToken: string;
+  uin?: string;
+}
+
+// ─── iLink message types ─────────────────────────────────────────────────
+
+export const MSG_TYPE_USER = 1;
+export const MSG_TYPE_BOT = 2;
+export const MSG_STATE_FINISH = 2;
+export const MSG_ITEM_TEXT = 1;
+
+export interface TextItem {
+  text?: string;
+}
+
+export interface MessageItem {
+  type?: number;
+  text_item?: TextItem;
+}
+
+export interface WechatMessage {
+  from_user_id?: string;
+  to_user_id?: string;
+  client_id?: string;
+  message_type?: number;
+  message_state?: number;
+  item_list?: MessageItem[];
+  context_token?: string;
+  create_time_ms?: number;
+}
+
+export interface GetUpdatesResp {
+  ret?: number;
+  errcode?: number;
+  errmsg?: string;
+  msgs?: WechatMessage[];
+  get_updates_buf?: string;
+  longpolling_timeout_ms?: number;
+}
+
+// ─── QR login types ───────────────────────────────────────────────────────
+
+export interface WechatQrCodeResponse {
+  qrcode?: string;
+  qrcode_img_content?: string;
+  error?: string;
+}
+
+export interface WechatQrCodeStatusResponse {
+  status: "wait" | "scaned" | "confirmed" | "expired";
+  bot_token?: string;
+  ilink_bot_id?: string;
+  ilink_user_id?: string;
+  baseurl?: string;
+  error?: string;
+}
+
+export interface QrSession {
+  qrcode: string;
+  createdAt: number;
+}