@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/channels/routes.ts

@@ -1,30 +0,0 @@
-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";
-
-interface ChannelRouteDependencies {
-  router: MessageRouter;
-  installationStore: ChannelInstallationStore;
-}
-
-type ChannelRouteRegistrar = (
-  app: FastifyInstance,
-  dependencies: ChannelRouteDependencies,
-) => void;
-
-const channelRouteRegistrars: ChannelRouteRegistrar[] = [
-  (app, deps) => registerLarkChannelRoutes(app, deps),
-  (app, _deps) => registerWechatChannelRoutes(app),
-];
-
-export function registerChannelRoutes(
-  app: FastifyInstance,
-  dependencies?: ChannelRouteDependencies,
-): void {
-  if (!dependencies) return;
-  for (const registerRoutes of channelRouteRegistrars) {
-    registerRoutes(app, dependencies);
-  }
-}

package/src/channels/wechat/WechatChannelAdapter.ts

@@ -1,294 +0,0 @@
-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(installation.id, 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(installation.id, senderId);
-
-    if (!contextToken) {
-      logger.warn("WeChat context token expired, cannot send reply", {
-        installationId: installation.id,
-        senderId,
-      });
-      deleteContextToken(installation.id, 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/__tests__/context-store.test.ts

@@ -1,148 +0,0 @@
-import {
-  setContextToken,
-  getContextToken,
-  deleteContextToken,
-  getContextTokenStoreSize,
-} from "../context-store";
-
-describe("context-store", () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    // Clear all tokens by deleting known keys (no public clear API)
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  describe("setContextToken / getContextToken", () => {
-    it("stores and retrieves a token keyed by installationId + senderId", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "token-abc");
-      expect(getContextToken("inst-1", "user-a@im.wechat")).toBe("token-abc");
-    });
-
-    it("returns undefined for unknown installationId + senderId", () => {
-      expect(getContextToken("inst-1", "unknown@im.wechat")).toBeUndefined();
-    });
-
-    it("returns undefined when senderId matches but installationId differs", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "token-abc");
-      expect(getContextToken("inst-2", "user-a@im.wechat")).toBeUndefined();
-    });
-  });
-
-  describe("isolation between installations", () => {
-    it("does not collide when different installations use the same senderId", () => {
-      setContextToken("inst-1", "user-x@im.wechat", "tok-111");
-      setContextToken("inst-2", "user-x@im.wechat", "tok-222");
-
-      expect(getContextToken("inst-1", "user-x@im.wechat")).toBe("tok-111");
-      expect(getContextToken("inst-2", "user-x@im.wechat")).toBe("tok-222");
-    });
-
-    it("isolates tokens between multiple installations with multiple users", () => {
-      setContextToken("inst-1", "alice@im.wechat", "a1");
-      setContextToken("inst-1", "bob@im.wechat", "b1");
-      setContextToken("inst-2", "alice@im.wechat", "a2");
-      setContextToken("inst-2", "charlie@im.wechat", "c2");
-
-      expect(getContextToken("inst-1", "alice@im.wechat")).toBe("a1");
-      expect(getContextToken("inst-1", "bob@im.wechat")).toBe("b1");
-      expect(getContextToken("inst-2", "alice@im.wechat")).toBe("a2");
-      expect(getContextToken("inst-2", "charlie@im.wechat")).toBe("c2");
-    });
-  });
-
-  describe("overwrite", () => {
-    it("overwrites existing token for the same installationId + senderId", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "old-token");
-      setContextToken("inst-1", "user-a@im.wechat", "new-token");
-
-      expect(getContextToken("inst-1", "user-a@im.wechat")).toBe("new-token");
-    });
-
-    it("does not affect other senderIds in the same installation", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "tok-a");
-      setContextToken("inst-1", "user-b@im.wechat", "tok-b");
-      setContextToken("inst-1", "user-a@im.wechat", "tok-a-v2");
-
-      expect(getContextToken("inst-1", "user-a@im.wechat")).toBe("tok-a-v2");
-      expect(getContextToken("inst-1", "user-b@im.wechat")).toBe("tok-b");
-    });
-  });
-
-  describe("deleteContextToken", () => {
-    it("removes a specific token", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "tok-a");
-      deleteContextToken("inst-1", "user-a@im.wechat");
-
-      expect(getContextToken("inst-1", "user-a@im.wechat")).toBeUndefined();
-    });
-
-    it("only removes the targeted key, leaving others intact", () => {
-      setContextToken("inst-1", "alice@im.wechat", "tok-1");
-      setContextToken("inst-1", "bob@im.wechat", "tok-2");
-      setContextToken("inst-2", "alice@im.wechat", "tok-3");
-
-      deleteContextToken("inst-1", "alice@im.wechat");
-
-      expect(getContextToken("inst-1", "alice@im.wechat")).toBeUndefined();
-      expect(getContextToken("inst-1", "bob@im.wechat")).toBe("tok-2");
-      expect(getContextToken("inst-2", "alice@im.wechat")).toBe("tok-3");
-    });
-
-    it("is a no-op for unknown keys", () => {
-      expect(() => deleteContextToken("inst-1", "no-such@im.wechat")).not.toThrow();
-    });
-  });
-
-  describe("TTL expiry", () => {
-    it("returns undefined after TTL has passed", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "tok-a");
-
-      // Advance time past 24h TTL
-      jest.advanceTimersByTime(25 * 60 * 60 * 1000);
-
-      expect(getContextToken("inst-1", "user-a@im.wechat")).toBeUndefined();
-    });
-
-    it("returns token within TTL window", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "tok-a");
-
-      // Advance time to just under 24h
-      jest.advanceTimersByTime(23 * 60 * 60 * 1000);
-
-      expect(getContextToken("inst-1", "user-a@im.wechat")).toBe("tok-a");
-    });
-
-    it("resets TTL when overwritten", () => {
-      setContextToken("inst-1", "user-a@im.wechat", "tok-v1");
-      jest.advanceTimersByTime(23 * 60 * 60 * 1000);
-
-      // Overwrite resets the TTL
-      setContextToken("inst-1", "user-a@im.wechat", "tok-v2");
-      jest.advanceTimersByTime(23 * 60 * 60 * 1000);
-
-      // Original TTL + 23h would have expired, but overwrite reset it
-      expect(getContextToken("inst-1", "user-a@im.wechat")).toBe("tok-v2");
-    });
-  });
-
-  describe("getContextTokenStoreSize", () => {
-    it("returns the number of stored entries", () => {
-      const startSize = getContextTokenStoreSize();
-
-      setContextToken("sz-1", "a@im.wechat", "x");
-      expect(getContextTokenStoreSize()).toBe(startSize + 1);
-
-      setContextToken("sz-1", "b@im.wechat", "y");
-      expect(getContextTokenStoreSize()).toBe(startSize + 2);
-
-      setContextToken("sz-2", "a@im.wechat", "z");
-      expect(getContextTokenStoreSize()).toBe(startSize + 3);
-
-      deleteContextToken("sz-1", "a@im.wechat");
-      expect(getContextTokenStoreSize()).toBe(startSize + 2);
-    });
-  });
-});

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

@@ -1,54 +0,0 @@
-interface ContextTokenEntry {
-  token: string;
-  installationId: 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>();
-
-function makeKey(installationId: string, senderId: string): string {
-  return `${installationId}::${senderId}`;
-}
-
-export function getContextToken(installationId: string, senderId: string): string | undefined {
-  const key = makeKey(installationId, senderId);
-  const entry = store.get(key);
-  if (!entry) return undefined;
-  if (Date.now() - entry.updatedAt > TOKEN_TTL_MS) {
-    deleteContextToken(installationId, senderId);
-    return undefined;
-  }
-  return entry.token;
-}
-
-export function setContextToken(installationId: string, senderId: string, token: string): void {
-  const key = makeKey(installationId, senderId);
-
-  const existingTimer = timers.get(key);
-  if (existingTimer) clearTimeout(existingTimer);
-
-  store.set(key, { token, installationId, senderId, updatedAt: Date.now() });
-
-  const timer = setTimeout(() => {
-    store.delete(key);
-    timers.delete(key);
-  }, TOKEN_TTL_MS);
-  timers.set(key, timer);
-}
-
-export function deleteContextToken(installationId: string, senderId: string): void {
-  const key = makeKey(installationId, senderId);
-  store.delete(key);
-  const timer = timers.get(key);
-  if (timer) {
-    clearTimeout(timer);
-    timers.delete(key);
-  }
-}
-
-export function getContextTokenStoreSize(): number {
-  return store.size;
-}

package/src/channels/wechat/controller.ts

@@ -1,59 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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;
-}