@axiom-lattice/gateway 2.1.97 → 2.1.99

package/src/channels/wechat/wechat-client.ts

@@ -0,0 +1,162 @@
+import { randomBytes } from "crypto";
+
+const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+
+function getBaseUrl(): string {
+  return process.env.WECHAT_ILINK_BASE_URL || DEFAULT_BASE_URL;
+}
+
+function generateWechatUin(): string {
+  const buf = Buffer.alloc(4);
+  buf.writeUInt32BE(Math.floor(Math.random() * 0xffffffff), 0);
+  return buf.toString("base64url");
+}
+
+async function apiGet<T>(path: string, extraHeaders?: Record<string, string>): Promise<T> {
+  const url = `${getBaseUrl()}${path}`;
+  const headers: Record<string, string> = { ...extraHeaders };
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    throw new Error(`iLink GET ${path} failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+async function apiGetAuth<T>(path: string, botToken: string, extraHeaders?: Record<string, string>): Promise<T> {
+  const url = `${getBaseUrl()}${path}`;
+  const headers: Record<string, string> = {
+    "AuthorizationType": "ilink_bot_token",
+    "X-WECHAT-UIN": generateWechatUin(),
+    "Authorization": `Bearer ${botToken}`,
+    ...extraHeaders,
+  };
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    throw new Error(`iLink GET ${path} failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+async function apiPost<T>(path: string, body: unknown, botToken: string, signal?: AbortSignal): Promise<T> {
+  const url = `${getBaseUrl()}${path}`;
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "AuthorizationType": "ilink_bot_token",
+    "X-WECHAT-UIN": generateWechatUin(),
+    "Authorization": `Bearer ${botToken}`,
+  };
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal,
+  });
+  if (!res.ok) {
+    throw new Error(`iLink POST ${path} failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+export async function getUpdates(
+  botToken: string,
+  syncBuffer: string,
+  signal?: AbortSignal,
+): Promise<{ msgs: Array<{
+  message_type?: number;
+  from_user_id?: string;
+  client_id?: string;
+  item_list?: Array<{ type?: number; text_item?: { text?: string } }>;
+  context_token?: string;
+  create_time_ms?: number;
+}>; syncBuffer: string }> {
+  const data = await apiPost<{
+    ret?: number;
+    errcode?: number;
+    errmsg?: string;
+    msgs?: Array<{
+      message_type?: number;
+      from_user_id?: string;
+      client_id?: string;
+      item_list?: Array<{ type?: number; text_item?: { text?: string } }>;
+      context_token?: string;
+      create_time_ms?: number;
+    }>;
+    get_updates_buf?: string;
+  }>("/ilink/bot/getupdates", {
+    get_updates_buf: syncBuffer,
+    base_info: { channel_version: "1.0.2" },
+  }, botToken, signal);
+
+  // Check API-level error codes (HTTP 200 can still be an error)
+  if ((data.ret !== undefined && data.ret !== 0) || (data.errcode !== undefined && data.errcode !== 0)) {
+    throw new Error(`iLink getUpdates error: ret=${data.ret} errcode=${data.errcode} errmsg=${data.errmsg ?? ""}`);
+  }
+
+  return {
+    msgs: data.msgs ?? [],
+    syncBuffer: data.get_updates_buf ?? syncBuffer,
+  };
+}
+
+function generateClientId(): string {
+  return `axiom-wechat:${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export async function sendMessage(
+  botToken: string,
+  toUserId: string,
+  text: string,
+  contextToken: string,
+): Promise<void> {
+  await apiPost<unknown>("/ilink/bot/sendmessage", {
+    msg: {
+      from_user_id: "",
+      to_user_id: toUserId,
+      client_id: generateClientId(),
+      message_type: 2, // MSG_TYPE_BOT
+      message_state: 2, // MSG_STATE_FINISH
+      item_list: [{ type: 1, text_item: { text } }],
+      context_token: contextToken,
+    },
+    base_info: { channel_version: "1.0.2" },
+  }, botToken);
+}
+
+export async function getQrCode(): Promise<{ qrcode: string; qrcodeImgUrl: string }> {
+  const data = await apiGet<{ qrcode?: string; qrcode_img_content?: string }>(
+    "/ilink/bot/get_bot_qrcode?bot_type=3",
+  );
+  if (!data.qrcode || !data.qrcode_img_content) {
+    throw new Error("Failed to get WeChat QR code");
+  }
+  return { qrcode: data.qrcode, qrcodeImgUrl: data.qrcode_img_content };
+}
+
+export async function getQrCodeStatus(
+  qrcode: string,
+  signal?: AbortSignal,
+): Promise<{
+  status: "wait" | "scaned" | "confirmed" | "expired";
+  botToken?: string;
+  uin?: string;
+  botId?: string;
+  baseUrl?: string;
+}> {
+  const data = await apiGet<{
+    status?: string;
+    bot_token?: string;
+    ilink_bot_id?: string;
+    ilink_user_id?: string;
+    baseurl?: string;
+  }>(`/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, {
+    "iLink-App-ClientVersion": "1",
+  });
+  return {
+    status: (data.status as "wait" | "scaned" | "confirmed" | "expired") || "wait",
+    botToken: data.bot_token,
+    uin: data.ilink_user_id,
+    botId: data.ilink_bot_id,
+    baseUrl: data.baseurl,
+  };
+}

package/src/controllers/__tests__/run.test.ts

@@ -16,7 +16,7 @@ jest.mock("@axiom-lattice/core", () => ({
 }));
 
 describe("recoverRun", () => {
-  let recoverRun: Function;
+  let recoverRun: (...args: unknown[]) => unknown;
 
   beforeEach(async () => {
     jest.clearAllMocks();

package/src/controllers/__tests__/tasks.test.ts

@@ -19,12 +19,12 @@ jest.mock('@axiom-lattice/core', () => ({
 }));
 
 describe('Tasks Controller', () => {
-  let listTasks: Function;
-  let getTask: Function;
-  let createTask: Function;
-  let updateTask: Function;
-  let deleteTask: Function;
-  let completeTask: Function;
+  let listTasks: (...args: unknown[]) => unknown;
+  let getTask: (...args: unknown[]) => unknown;
+  let createTask: (...args: unknown[]) => unknown;
+  let updateTask: (...args: unknown[]) => unknown;
+  let deleteTask: (...args: unknown[]) => unknown;
+  let completeTask: (...args: unknown[]) => unknown;
 
   const mockReply = () =>
     ({

package/src/controllers/channel-installations.ts

@@ -7,6 +7,23 @@ import {
   UpdateChannelInstallationRequest,
   ChannelInstallationType,
 } from "@axiom-lattice/protocols";
+import type { ChannelAdapterRegistry } from "../channels/registry";
+
+/**
+ * Controller-scoped deps for channel lifecycle management.
+ * Set by the gateway during route registration so that
+ * enable/disable/deletion can start/stop live connections.
+ */
+let _adapterRegistry: ChannelAdapterRegistry | undefined;
+let _router: { dispatch(msg: unknown): Promise<unknown> } | undefined;
+
+export function setChannelControllerDeps(deps: {
+  adapterRegistry: ChannelAdapterRegistry;
+  router: { dispatch(msg: unknown): Promise<unknown> };
+}): void {
+  _adapterRegistry = deps.adapterRegistry;
+  _router = deps.router;
+}
 
 /**
  * Channel Installation Controller
@@ -212,6 +229,18 @@ export async function createChannelInstallation(
       body,
     );
 
+    // Start live connection for channels that need it (e.g. WeChat polling, Lark WS)
+    if (body.enabled !== false && _adapterRegistry) {
+      const adapter = _adapterRegistry.get(body.channel);
+      if (adapter?.connect) {
+        try {
+          await adapter.connect(installation, { router: _router });
+        } catch (err) {
+          console.error("Failed to start channel connection after creation:", err);
+        }
+      }
+    }
+
     reply.code(201);
     return {
       success: true,
@@ -286,6 +315,17 @@ export async function updateChannelInstallation(
       };
     }
 
+    // Handle enable/disable — start/stop live connections
+    if (body.enabled !== undefined && body.enabled !== existing.enabled) {
+      const adapter = _adapterRegistry?.get(existing.channel);
+      if (body.enabled && adapter?.connect) {
+        // Re-connect: pass router deps so the adapter can dispatch messages
+        await adapter.connect(installation, { router: _router });
+      } else if (!body.enabled && adapter?.disconnect) {
+        await adapter.disconnect(installationId);
+      }
+    }
+
     return {
       success: true,
       message: "Channel installation updated successfully",
@@ -333,6 +373,18 @@ export async function deleteChannelInstallation(
       };
     }
 
+    // Disconnect live connection before removing from DB
+    if (_adapterRegistry) {
+      const adapter = _adapterRegistry.get(existing.channel);
+      if (adapter?.disconnect) {
+        try {
+          await adapter.disconnect(installationId);
+        } catch (err) {
+          console.error("Failed to disconnect channel adapter:", err);
+        }
+      }
+    }
+
     const deleted = await store.deleteInstallation(tenantId, installationId);
 
     if (!deleted) {

package/src/controllers/database-configs.ts

@@ -374,7 +374,7 @@ export async function testDatabaseConnection(
       try {
         await db.disconnect();
         await sqlDatabaseManager.removeDatabase(tenantId, testKey);
-      } catch {}
+      } catch { /* cleanup error, ignore */ }
 
       return {
         success: true,

package/src/controllers/metrics-configs.ts

@@ -556,7 +556,7 @@ export async function testMetricsServerConnection(
       // Cleanup on error
       try {
         metricsServerManager.removeServer(tenantId, testKey);
-      } catch {}
+      } catch { /* cleanup error, ignore */ }
 
       return {
         success: true,

package/src/controllers/workspace.ts

@@ -461,7 +461,7 @@ export class WorkspaceController {
         const inferredContentType = this.getMimeType(filename);
 
         try {
-          let contentType = inferredContentType;
+          const contentType = inferredContentType;
 
           // Inject AI2APP context script for HTML files (sandbox storage)
           const isHtml = contentType?.toLowerCase().includes("text/html") || 
@@ -635,7 +635,7 @@ export class WorkspaceController {
             ? pathEntry
             : undefined;
 
-      if (pathValue && !/^[a-zA-Z0-9_./~\-]+$/.test(pathValue)) {
+      if (pathValue && !/^[a-zA-Z0-9_./~-]+$/.test(pathValue)) {
         return reply
           .status(400)
           .send({ success: false, error: "Invalid path parameter" });

package/src/index.ts

@@ -14,6 +14,7 @@ import { createDeduplicationMiddleware, createRateLimitMiddleware, createAuditLo
 import { setBindingRegistry, setMenuRegistry } from "@axiom-lattice/core";
 import { larkChannelAdapter } from "./channels/lark/LarkChannelAdapter";
 import { extractUserFromAuthHeader } from "./controllers/auth";
+import { setChannelControllerDeps } from "./controllers/channel-installations";
 import { configureSwagger } from "./swagger";
 import {
   setQueueServiceType,
@@ -289,13 +290,12 @@ const start = async (config?: LatticeGatewayConfig) => {
     let channelDeps: { router: MessageRouter; installationStore: ChannelInstallationStore } | undefined;
     const adapterRegistry = new ChannelAdapterRegistry();
     adapterRegistry.register(larkChannelAdapter);
+    const { wechatChannelAdapter } = await import("./channels/wechat/WechatChannelAdapter");
+    adapterRegistry.register(wechatChannelAdapter);
     try {
       const { getStoreLattice: getStore } = await import("@axiom-lattice/core");
-      let bindingStore: BindingRegistry;
-      let installationStore: ChannelInstallationStore;
-
-      bindingStore = getStore("default", "channelBinding").store as BindingRegistry;
-      installationStore = getStore("default", "channelInstallation").store as ChannelInstallationStore;
+      const bindingStore = getStore("default", "channelBinding").store as BindingRegistry;
+      const installationStore = getStore("default", "channelInstallation").store as ChannelInstallationStore;
 
       setBindingRegistry(bindingStore);
 
@@ -339,6 +339,10 @@ const start = async (config?: LatticeGatewayConfig) => {
     }
 
     // Register all routes (channel routes only active if channelDeps is set)
+    // Wire controller deps so enable/disable/delete can manage live connections
+    if (channelDeps?.router) {
+      setChannelControllerDeps({ adapterRegistry, router: channelDeps.router });
+    }
     registerLatticeRoutes(app, channelDeps);
 
     // Register sandbox manager if not already registered