@axiom-lattice/gateway 3.0.2 → 3.0.4

package/src/channels/lark/__tests__/parser.test.ts

@@ -1,72 +0,0 @@
-import { parseLarkMessageEvent } from "../parser";
-
-describe("parseLarkMessageEvent", () => {
-  it("parses a direct text message event", () => {
-    const parsed = parseLarkMessageEvent({
-      header: { event_type: "im.message.receive_v1" },
-      event: {
-        sender: { sender_id: { open_id: "ou_user_1" } },
-        message: {
-          message_id: "om_1",
-          chat_id: "oc_chat_1",
-          chat_type: "p2p",
-          message_type: "text",
-          content: '{"text":"hello"}',
-        },
-      },
-    });
-
-    expect(parsed).toEqual({
-      messageId: "om_1",
-      openId: "ou_user_1",
-      chatId: "oc_chat_1",
-      chatType: "direct",
-      text: "hello",
-    });
-  });
-
-  it("parses a group text message event", () => {
-    const parsed = parseLarkMessageEvent({
-      header: { event_type: "im.message.receive_v1" },
-      event: {
-        sender: { sender_id: { open_id: "ou_user_2" } },
-        message: {
-          message_id: "om_2",
-          chat_id: "oc_group_1",
-          chat_type: "group",
-          message_type: "text",
-          content: '{"text":"team update"}',
-        },
-      },
-    });
-
-    expect(parsed.chatType).toBe("group");
-    expect(parsed.text).toBe("team update");
-  });
-
-  it("returns null for unsupported event types", () => {
-    const parsed = parseLarkMessageEvent({
-      header: { event_type: "im.message.read_v1" },
-    });
-
-    expect(parsed).toBeNull();
-  });
-
-  it("returns null for non-text messages", () => {
-    const parsed = parseLarkMessageEvent({
-      header: { event_type: "im.message.receive_v1" },
-      event: {
-        sender: { sender_id: { open_id: "ou_user_3" } },
-        message: {
-          message_id: "om_3",
-          chat_id: "oc_chat_3",
-          chat_type: "p2p",
-          message_type: "image",
-          content: '{"image_key":"img_1"}',
-        },
-      },
-    });
-
-    expect(parsed).toBeNull();
-  });
-});

package/src/channels/lark/__tests__/sender.test.ts

@@ -1,37 +0,0 @@
-import { createLarkSender } from "../sender";
-
-describe("createLarkSender", () => {
-  it("sends a text reply through the lark sdk client", async () => {
-    const createMock = jest.fn().mockResolvedValue({ code: 0 });
-    const sdkClient = {
-      im: {
-        v1: {
-          message: {
-            create: createMock,
-          },
-        },
-      },
-    };
-
-    const sender = await createLarkSender(
-      {
-        appId: "cli_app_1",
-        appSecret: "secret",
-      },
-      sdkClient as never,
-    );
-
-    await sender.sendTextReply({ chatId: "oc_1", text: "hello" });
-
-    expect(createMock).toHaveBeenCalledWith({
-      params: {
-        receive_id_type: "chat_id",
-      },
-      data: {
-        receive_id: "oc_1",
-        msg_type: "text",
-        content: JSON.stringify({ text: "hello" }),
-      },
-    });
-  });
-});

package/src/channels/lark/__tests__/verification.test.ts

@@ -1,157 +0,0 @@
-import type { FastifyRequest } from "fastify";
-import crypto from "crypto";
-import {
-  createLarkRequestVerifier,
-  decryptLarkPayload,
-  parseLarkRequestBody,
-} from "../verification";
-
-describe("createLarkRequestVerifier", () => {
-  it("accepts requests with the configured verification token", () => {
-    const verify = createLarkRequestVerifier({
-      enabled: true,
-      appId: "app-id",
-      appSecret: "app-secret",
-      verificationToken: "token-1",
-      tenantId: "tenant-a",
-      assistantId: "assistant-a",
-      mappingMode: "hybrid",
-    });
-
-    const request = {
-      headers: {},
-      body: { token: "token-1" },
-    } as FastifyRequest;
-
-    expect(verify(request)).toBe(true);
-  });
-
-  it("rejects requests with the wrong verification token", () => {
-    const verify = createLarkRequestVerifier({
-      enabled: true,
-      appId: "app-id",
-      appSecret: "app-secret",
-      verificationToken: "token-1",
-      tenantId: "tenant-a",
-      assistantId: "assistant-a",
-      mappingMode: "hybrid",
-    });
-
-    const request = {
-      headers: {},
-      body: { token: "token-2" },
-    } as FastifyRequest;
-
-    expect(verify(request)).toBe(false);
-  });
-
-  it("accepts requests carrying lark signature headers", () => {
-    const verify = createLarkRequestVerifier({
-      enabled: true,
-      appId: "app-id",
-      appSecret: "app-secret",
-      tenantId: "tenant-a",
-      assistantId: "assistant-a",
-      mappingMode: "hybrid",
-    });
-
-    const request = {
-      headers: {
-        "x-lark-request-timestamp": "1712730010",
-        "x-lark-signature": "signature",
-      },
-      body: {},
-    } as FastifyRequest;
-
-    expect(verify(request)).toBe(true);
-  });
-
-  it("accepts v2 payloads that carry the token in header.token", () => {
-    const verify = createLarkRequestVerifier({
-      enabled: true,
-      appId: "app-id",
-      appSecret: "app-secret",
-      verificationToken: "token-1",
-      tenantId: "tenant-a",
-      assistantId: "assistant-a",
-      mappingMode: "hybrid",
-    });
-
-    const request = {
-      headers: {},
-      body: {
-        schema: "2.0",
-        header: {
-          token: "token-1",
-        },
-      },
-    } as FastifyRequest;
-
-    expect(verify(request)).toBe(true);
-  });
-
-  it("decrypts an encrypted lark payload", () => {
-    const encryptKey = "encrypt-key-1";
-    const payload = JSON.stringify({
-      type: "url_verification",
-      challenge: "challenge-1",
-      token: "token-1",
-    });
-    const encrypted = encryptForTest(encryptKey, payload);
-
-    expect(decryptLarkPayload(encryptKey, encrypted)).toEqual({
-      type: "url_verification",
-      challenge: "challenge-1",
-      token: "token-1",
-    });
-  });
-
-  it("parses encrypted payloads before token verification", () => {
-    const encryptKey = "encrypt-key-1";
-    const verify = createLarkRequestVerifier({
-      enabled: true,
-      appId: "app-id",
-      appSecret: "app-secret",
-      verificationToken: "token-1",
-      encryptKey,
-      tenantId: "tenant-a",
-      assistantId: "assistant-a",
-      mappingMode: "hybrid",
-    });
-
-    const encrypted = encryptForTest(
-      encryptKey,
-      JSON.stringify({
-        type: "url_verification",
-        challenge: "challenge-1",
-        token: "token-1",
-      }),
-    );
-
-    const request = {
-      headers: {},
-      body: {
-        encrypt: encrypted,
-      },
-    } as FastifyRequest;
-
-    expect(verify(request)).toBe(true);
-    expect(parseLarkRequestBody(request.body, encryptKey)).toEqual({
-      type: "url_verification",
-      challenge: "challenge-1",
-      token: "token-1",
-    });
-  });
-});
-
-function encryptForTest(encryptKey: string, plaintext: string): string {
-  const key = crypto.createHash("sha256").update(encryptKey).digest();
-  const iv = Buffer.alloc(16, 1);
-  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
-  const ciphertext = Buffer.concat([
-    cipher.update(Buffer.from(plaintext, "utf8")),
-    cipher.final(),
-  ]);
-
-  return Buffer.concat([iv, ciphertext]).toString("base64");
-}

package/src/channels/lark/controller.ts

@@ -1,48 +0,0 @@
-import type { FastifyReply, FastifyRequest } from "fastify";
-import type { ChannelInstallation, ChannelInstallationStore, LarkChannelInstallationConfig } from "@axiom-lattice/protocols";
-import { larkChannelAdapter } from "./LarkChannelAdapter";
-import type { MessageRouter } from "../../router/MessageRouter";
-import { parseLarkRequestBody } from "./verification";
-import { Logger } from "../../logger/Logger";
-
-const logger = new Logger({ serviceName: "lattice/gateway/lark" });
-
-export function createLarkEventHandler(deps: {
-  installationStore: ChannelInstallationStore;
-  router: MessageRouter;
-}) {
-  return async function handleLarkEvent(
-    request: FastifyRequest,
-    reply: FastifyReply,
-  ): Promise<void> {
-    const { installationId } = request.params as { installationId: string };
-
-    const installation = await deps.installationStore.getInstallationById(installationId);
-    if (!installation || installation.channel !== "lark") {
-      reply.status(404).send({ success: false, message: "Installation not found" });
-      return;
-    }
-
-    const larkInstallation = installation as ChannelInstallation<LarkChannelInstallationConfig>;
-    const body = parseLarkRequestBody(request.body, larkInstallation.config.encryptKey);
-
-    if (body.type === "url_verification" && body.challenge) {
-      reply.status(200).send({ challenge: body.challenge });
-      return;
-    }
-
-    const inboundMessage = await larkChannelAdapter.receive(request.body, larkInstallation);
-    if (!inboundMessage) {
-      reply.status(200).send();
-      return;
-    }
-
-    deps.router.dispatch(inboundMessage).catch((error) => {
-      logger.error("Lark message dispatch error", {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    });
-
-    reply.status(200).send();
-  };
-}

package/src/channels/lark/mapping-service.ts

@@ -1,138 +0,0 @@
-import type { ThreadStore } from "@axiom-lattice/protocols";
-import type { ChannelIdentityMappingStore } from "@axiom-lattice/pg-stores";
-import { randomUUID } from "crypto";
-
-interface GetOrCreateThreadInput {
-  channel: string;
-  channelAppId: string;
-  tenantId: string;
-  assistantId: string;
-  mappingMode: "user" | "group" | "hybrid";
-  openId: string;
-  chatId: string;
-  chatType: "direct" | "group";
-  messageId: string;
-  workspaceId?: string;
-  projectId?: string;
-}
-
-interface ChannelThreadMappingServiceDeps {
-  mappingStore: Pick<
-    ChannelIdentityMappingStore,
-    "getMappingBySubject" | "createMapping"
-  >;
-  threadStore: Pick<ThreadStore, "createThread" | "deleteThread">;
-  uuid?: () => string;
-}
-
-export function createChannelThreadMappingService(
-  deps: ChannelThreadMappingServiceDeps,
-) {
-  return {
-    async getOrCreateThread(input: GetOrCreateThreadInput): Promise<{ threadId: string }> {
-      const externalSubjectKey = buildExternalSubjectKey(input);
-      const existing = await deps.mappingStore.getMappingBySubject({
-        channel: input.channel,
-        channelAppId: input.channelAppId,
-        tenantId: input.tenantId,
-        assistantId: input.assistantId,
-        externalSubjectKey,
-      });
-
-      if (existing) {
-        return { threadId: existing.threadId };
-      }
-
-      const threadId = (deps.uuid || randomUUID)();
-
-      await deps.threadStore.createThread(input.tenantId, input.assistantId, threadId, {
-        metadata: {
-          tenantId: input.tenantId,
-          workspaceId: input.workspaceId,
-          projectId: input.projectId,
-          channel: input.channel,
-          larkChatId: input.chatId,
-          larkOpenId: input.openId,
-        },
-      });
-
-      try {
-        await deps.mappingStore.createMapping({
-          channel: input.channel,
-          channelAppId: input.channelAppId,
-          tenantId: input.tenantId,
-          assistantId: input.assistantId,
-          mappingMode: input.mappingMode,
-          externalSubjectType:
-            resolveSubjectType(input.mappingMode, input.chatType) === "user"
-              ? "user"
-              : "chat",
-          externalSubjectKey,
-          larkOpenId: input.openId,
-          larkChatId: input.chatId,
-          larkMessageId: input.messageId,
-          threadId,
-        });
-      } catch (error) {
-        if (!isUniqueViolation(error)) {
-          throw error;
-        }
-
-        const canonical = await deps.mappingStore.getMappingBySubject({
-          channel: input.channel,
-          channelAppId: input.channelAppId,
-          tenantId: input.tenantId,
-          assistantId: input.assistantId,
-          externalSubjectKey,
-        });
-
-        if (!canonical) {
-          throw error;
-        }
-
-        await deps.threadStore.deleteThread(input.tenantId, threadId);
-
-        return { threadId: canonical.threadId };
-      }
-
-      return { threadId };
-    },
-  };
-}
-
-function isUniqueViolation(error: unknown): boolean {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    (error as { code?: string }).code === "23505"
-  );
-}
-
-function buildExternalSubjectKey(input: GetOrCreateThreadInput): string {
-  const subjectType = resolveSubjectType(input.mappingMode, input.chatType);
-  const subjectValue = subjectType === "user" ? input.openId : input.chatId;
-
-  return [
-    input.channel,
-    input.channelAppId,
-    `tenant:${input.tenantId}`,
-    `assistant:${input.assistantId}`,
-    `${subjectType}:${subjectValue}`,
-  ].join(":");
-}
-
-function resolveSubjectType(
-  mappingMode: "user" | "group" | "hybrid",
-  chatType: "direct" | "group",
-): "user" | "chat" {
-  if (mappingMode === "user") {
-    return "user";
-  }
-
-  if (mappingMode === "group") {
-    return "chat";
-  }
-
-  return chatType === "direct" ? "user" : "chat";
-}

package/src/channels/lark/parser.ts

@@ -1,68 +0,0 @@
-import type { ParsedLarkMessageEvent } from "./types";
-
-interface RawLarkPayload {
-  header?: {
-    event_type?: string;
-  };
-  event?: {
-    sender?: {
-      sender_id?: {
-        open_id?: string;
-      };
-    };
-    message?: {
-      message_id?: string;
-      chat_id?: string;
-      chat_type?: string;
-      message_type?: string;
-      content?: string;
-    };
-  };
-}
-
-export function parseLarkMessageEvent(
-  payload: unknown,
-): ParsedLarkMessageEvent | null {
-  const raw = payload as RawLarkPayload;
-
-  if (raw.header?.event_type !== "im.message.receive_v1") {
-    return null;
-  }
-
-  const message = raw.event?.message;
-  const openId = raw.event?.sender?.sender_id?.open_id;
-
-  if (!message || !openId || message.message_type !== "text") {
-    return null;
-  }
-
-  const parsedContent = parseLarkTextContent(message.content);
-  if (!message.message_id || !message.chat_id || !parsedContent) {
-    return null;
-  }
-
-  return {
-    messageId: message.message_id,
-    openId,
-    chatId: message.chat_id,
-    chatType: normalizeChatType(message.chat_type),
-    text: parsedContent,
-  };
-}
-
-function parseLarkTextContent(content: string | undefined): string | null {
-  if (!content) {
-    return null;
-  }
-
-  try {
-    const parsed = JSON.parse(content) as { text?: string };
-    return typeof parsed.text === "string" ? parsed.text : null;
-  } catch {
-    return null;
-  }
-}
-
-function normalizeChatType(chatType: string | undefined): "direct" | "group" {
-  return chatType === "p2p" ? "direct" : "group";
-}

package/src/channels/lark/routes.ts

@@ -1,22 +0,0 @@
-import type { FastifyInstance } from "fastify";
-import { createLarkEventHandler } from "./controller";
-import type { MessageRouter } from "../../router/MessageRouter";
-import type { ChannelInstallationStore } from "@axiom-lattice/protocols";
-
-export function registerLarkChannelRoutes(
-  app: FastifyInstance,
-  deps: {
-    installationStore: ChannelInstallationStore;
-    router: MessageRouter;
-  },
-): void {
-  const handler = createLarkEventHandler({
-    installationStore: deps.installationStore,
-    router: deps.router,
-  });
-
-  app.post(
-    "/api/channels/lark/installations/:installationId/events",
-    handler,
-  );
-}

package/src/channels/lark/sender.ts

@@ -1,58 +0,0 @@
-interface LarkSenderConfig {
-  appId: string;
-  appSecret: string;
-}
-
-interface LarkSdkMessageClient {
-  im: {
-    v1: {
-      message: {
-        create(input: {
-          params: {
-            receive_id_type: "chat_id";
-          };
-          data: {
-            receive_id: string;
-            msg_type: "text";
-            content: string;
-          };
-        }): Promise<{ code?: number }>;
-      };
-    };
-  };
-}
-
-export async function createLarkSender(
-  config: LarkSenderConfig,
-  client?: LarkSdkMessageClient,
-) {
-  const resolved = client ?? (await createDefaultLarkClient(config));
-
-  return {
-    async sendTextReply(input: { chatId: string; text: string }): Promise<void> {
-      const response = await resolved.im.v1.message.create({
-        params: {
-          receive_id_type: "chat_id",
-        },
-        data: {
-          receive_id: input.chatId,
-          msg_type: "text",
-          content: JSON.stringify({ text: input.text }),
-        },
-      });
-
-      if (response.code && response.code !== 0) {
-        throw new Error("Failed to send Lark reply");
-      }
-    },
-  };
-}
-
-async function createDefaultLarkClient(config: LarkSenderConfig): Promise<LarkSdkMessageClient> {
-  const Lark = await import("@larksuiteoapi/node-sdk");
-
-  return new Lark.Client({
-    appId: config.appId,
-    appSecret: config.appSecret,
-  }) as LarkSdkMessageClient;
-}

package/src/channels/lark/types.ts

@@ -1,20 +0,0 @@
-export interface ParsedLarkMessageEvent {
-  messageId: string;
-  openId: string;
-  chatId: string;
-  chatType: "direct" | "group";
-  text: string;
-}
-
-export interface LarkUrlVerificationPayload {
-  type?: string;
-  challenge?: string;
-  token?: string;
-  schema?: string;
-  header?: {
-    token?: string;
-    event_type?: string;
-  };
-  encrypt?: string;
-}
-

package/src/channels/lark/verification.ts

@@ -1,32 +0,0 @@
-import crypto from "crypto";
-import type { LarkUrlVerificationPayload } from "./types";
-
-export function parseLarkRequestBody(
-  body: unknown,
-  encryptKey?: string,
-): LarkUrlVerificationPayload {
-  const parsed = (body || {}) as LarkUrlVerificationPayload;
-
-  if (encryptKey && typeof parsed.encrypt === "string") {
-    return decryptLarkPayload(encryptKey, parsed.encrypt);
-  }
-
-  return parsed;
-}
-
-export function decryptLarkPayload(
-  encryptKey: string,
-  encryptedPayload: string,
-): LarkUrlVerificationPayload {
-  const key = crypto.createHash("sha256").update(encryptKey).digest();
-  const buffer = Buffer.from(encryptedPayload, "base64");
-  const iv = buffer.subarray(0, 16);
-  const ciphertext = buffer.subarray(16);
-  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
-  const plaintext = Buffer.concat([
-    decipher.update(ciphertext),
-    decipher.final(),
-  ]).toString("utf8");
-
-  return JSON.parse(plaintext) as LarkUrlVerificationPayload;
-}

package/src/channels/registry.ts

@@ -1,20 +0,0 @@
-import type { ChannelAdapter } from "@axiom-lattice/protocols";
-
-export class ChannelAdapterRegistry {
-  private adapters = new Map<string, ChannelAdapter>();
-
-  register(adapter: ChannelAdapter): void {
-    if (this.adapters.has(adapter.channel)) {
-      throw new Error(`Channel adapter "${adapter.channel}" already registered`);
-    }
-    this.adapters.set(adapter.channel, adapter);
-  }
-
-  get(channel: string): ChannelAdapter | undefined {
-    return this.adapters.get(channel);
-  }
-
-  list(): string[] {
-    return Array.from(this.adapters.keys());
-  }
-}