@axiom-lattice/gateway 2.1.91 → 2.1.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.91",
+  "version": "2.1.93",
   "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.73",
-    "@axiom-lattice/core": "2.1.79",
-    "@axiom-lattice/pg-stores": "1.0.70",
-    "@axiom-lattice/protocols": "2.1.41",
-    "@axiom-lattice/queue-redis": "1.0.40"
+    "@axiom-lattice/agent-eval": "2.1.75",
+    "@axiom-lattice/core": "2.1.81",
+    "@axiom-lattice/pg-stores": "1.0.72",
+    "@axiom-lattice/protocols": "2.1.43",
+    "@axiom-lattice/queue-redis": "1.0.42"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/scripts/seed-lark-installation.ts

@@ -0,0 +1,54 @@
+/**
+ * Seed script: creates a Lark channel installation in the local SQLite store.
+ *
+ * Usage:
+ *   pnpm --filter @axiom-lattice/gateway exec tsx scripts/seed-lark-installation.ts
+ */
+
+import {
+  initDatabase,
+  getDatabase,
+  LocalChannelInstallationStore,
+  closeDatabase,
+} from "@axiom-lattice/local-stores";
+
+const APP_ID = "cli_a92dc36def309cca";
+const APP_SECRET = "hNTWhEfti4Y7JIq8JA46Af7WNPcAclGa";
+const INSTALLATION_ID = "lark-main";
+const TENANT_ID = "default";
+
+async function main(): Promise<void> {
+  const dbPath = process.env.LOCAL_DB_PATH || "~/.axiom/lattice.db";
+
+  console.log(`[seed] Initializing SQLite at ${dbPath}`);
+  await initDatabase({ dbPath });
+
+  const db = getDatabase();
+  const store = new LocalChannelInstallationStore(db);
+
+  console.log(`[seed] Creating Lark installation: ${INSTALLATION_ID}`);
+  const installation = await store.createInstallation(
+    TENANT_ID,
+    INSTALLATION_ID,
+    {
+      channel: "lark",
+      config: {
+        appId: APP_ID,
+        appSecret: APP_SECRET,
+      },
+      enabled: true,
+      rejectWhenNoBinding: false,
+    },
+  );
+
+  console.log(`[seed] Installation created:`);
+  console.log(JSON.stringify(installation, null, 2));
+
+  await closeDatabase();
+  console.log(`[seed] Done. Installation persisted to ${dbPath}`);
+}
+
+main().catch((err) => {
+  console.error("[seed] Failed:", err);
+  process.exit(1);
+});

package/src/channels/lark/LarkChannelAdapter.ts

@@ -8,6 +8,71 @@ import type {
 } from "@axiom-lattice/protocols";
 import type { LarkChannelInstallationConfig } from "@axiom-lattice/protocols";
 import { parseLarkMessageEvent } from "./parser";
+import { Logger } from "../../logger/Logger";
+import * as Lark from "@larksuiteoapi/node-sdk";
+
+const logger = new Logger({ serviceName: "lattice/gateway/lark" });
+
+// ─── WS connection state ──────────────────────────────────────────────────
+
+const activeConnections = new Map<string, Lark.WSClient>();
+
+// ─── WS message parsing (shared with lark-ws) ─────────────────────────────
+
+interface LarkWSMessageEvent {
+  sender?: { sender_id?: { open_id?: string } };
+  message?: {
+    message_id?: string;
+    chat_id?: string;
+    chat_type?: string;
+    message_type?: string;
+    content?: string;
+  };
+}
+
+function parseTextContent(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";
+}
+
+function wsEventToInbound(
+  event: LarkWSMessageEvent,
+  installationId: string,
+  tenantId: string,
+): InboundMessage | null {
+  const messageId = event.message?.message_id;
+  const chatId = event.message?.chat_id;
+  const openId = event.sender?.sender_id?.open_id;
+  if (!messageId || !chatId || !openId) return null;
+  if (event.message?.message_type !== "text") return null;
+
+  const text = parseTextContent(event.message.content);
+  if (!text) return null;
+
+  const chatType = normalizeChatType(event.message.chat_type);
+  return {
+    channel: "lark",
+    channelInstallationId: installationId,
+    tenantId,
+    sender: { id: openId, displayName: undefined },
+    content: { text, metadata: { chatId, chatType, messageId } },
+    conversation: { id: chatId, type: chatType },
+    replyTarget: {
+      adapterChannel: "lark",
+      channelInstallationId: installationId,
+      rawTarget: { chatId, messageId, chatType },
+    },
+  };
+}
+
+// ─── Adapter ──────────────────────────────────────────────────────────────
 
 export const larkConfigSchema = z.object({
   appId: z.string(),
@@ -32,30 +97,16 @@ export const larkChannelAdapter: ChannelAdapter<LarkChannelInstallationConfig> =
       channel: "lark",
       channelInstallationId: installation.id,
       tenantId: installation.tenantId,
-      sender: {
-        id: event.openId,
-        displayName: undefined,
-      },
+      sender: { id: event.openId, displayName: undefined },
       content: {
         text: event.text,
-        metadata: {
-          chatId: event.chatId,
-          chatType: event.chatType,
-          messageId: event.messageId,
-        },
-      },
-      conversation: {
-        id: event.chatId,
-        type: event.chatType,
+        metadata: { chatId: event.chatId, chatType: event.chatType, messageId: event.messageId },
       },
+      conversation: { id: event.chatId, type: event.chatType },
       replyTarget: {
         adapterChannel: "lark",
         channelInstallationId: installation.id,
-        rawTarget: {
-          chatId: event.chatId,
-          messageId: event.messageId,
-          chatType: event.chatType,
-        },
+        rawTarget: { chatId: event.chatId, messageId: event.messageId, chatType: event.chatType },
       },
     };
   },
@@ -72,4 +123,75 @@ export const larkChannelAdapter: ChannelAdapter<LarkChannelInstallationConfig> =
       text: message.text,
     });
   },
+
+  resolveThreadId(message: InboundMessage, binding: unknown): string {
+    const date = new Date().toISOString().split("T")[0];
+    const chatType = message.conversation?.type === "direct" ? "dm" : "group";
+    const agentId = (binding as { agentId: string }).agentId;
+    if (chatType === "dm") {
+      return `lark:dm:${message.sender.id}:${agentId}:${date}`;
+    }
+    return `lark:group:${message.conversation?.id ?? "unknown"}:${agentId}:${date}`;
+  },
+
+  async connect(
+    installation: ChannelInstallation<LarkChannelInstallationConfig>,
+    deps?: unknown,
+  ): Promise<void> {
+    const { id: installationId, tenantId, config } = installation;
+
+    if (!config.appId || !config.appSecret) {
+      logger.warn("Lark installation missing credentials, skipping", { installationId });
+      return;
+    }
+
+    if (activeConnections.has(installationId)) {
+      logger.warn("Lark WS already connected for installation, skipping", { installationId });
+      return;
+    }
+
+    logger.info("Lark WS client starting", { installationId, tenantId });
+
+    const router = (deps as { router?: { dispatch(msg: InboundMessage): Promise<unknown> } })?.router;
+
+    const eventDispatcher = new Lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (data: LarkWSMessageEvent) => {
+        try {
+          const inbound = wsEventToInbound(data, installationId, tenantId);
+          if (!inbound) return;
+
+          logger.info("Lark WS message received", {
+            installationId,
+            senderId: inbound.sender.id,
+            chatId: data.message?.chat_id,
+          });
+
+          if (router) {
+            const result = await router.dispatch(inbound);
+            if (!(result as { success?: boolean }).success) {
+              logger.warn("Lark WS dispatch failed", {
+                installationId,
+                error: (result as { error?: { message?: string } }).error?.message,
+              });
+            }
+          }
+        } catch (err) {
+          logger.error("Lark WS event handler error", {
+            installationId,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    });
+
+    const client = new Lark.WSClient({
+      appId: config.appId,
+      appSecret: config.appSecret,
+      loggerLevel: Lark.LoggerLevel.info,
+    });
+
+    await client.start({ eventDispatcher });
+    activeConnections.set(installationId, client);
+    logger.info("Lark WS client connected", { installationId });
+  },
 };

package/src/channels/lark/types.ts

@@ -18,16 +18,3 @@ export interface LarkUrlVerificationPayload {
   encrypt?: string;
 }
 
-export interface LarkIngressConfig {
-  enabled: boolean;
-  installationId?: string;
-  appId: string;
-  appSecret: string;
-  verificationToken?: string;
-  encryptKey?: string;
-  tenantId: string;
-  assistantId: string;
-  workspaceId?: string;
-  projectId?: string;
-  mappingMode: "user" | "group" | "hybrid";
-}

package/src/channels/lark/verification.ts

@@ -1,6 +1,5 @@
 import crypto from "crypto";
-import type { FastifyRequest } from "fastify";
-import type { LarkIngressConfig, LarkUrlVerificationPayload } from "./types";
+import type { LarkUrlVerificationPayload } from "./types";
 
 export function parseLarkRequestBody(
   body: unknown,
@@ -31,37 +30,3 @@ export function decryptLarkPayload(
 
   return JSON.parse(plaintext) as LarkUrlVerificationPayload;
 }
-
-export function createLarkRequestVerifier(config: LarkIngressConfig) {
-  return function verifyRequest(request: FastifyRequest): boolean {
-    const body = parseLarkRequestBody(request.body, config.encryptKey);
-
-    return verifyLarkParsedBody(body, config);
-  };
-}
-
-export function verifyLarkParsedBody(
-  body: LarkUrlVerificationPayload,
-  config: LarkIngressConfig,
-): boolean {
-    
-    if (!config.verificationToken) {
-      return true;
-    }
-
-    return extractVerificationToken(body) === config.verificationToken;
-}
-
-function extractVerificationToken(
-  body: LarkUrlVerificationPayload,
-): string | undefined {
-  if (typeof body.token === "string") {
-    return body.token;
-  }
-
-  if (typeof body.header?.token === "string") {
-    return body.header.token;
-  }
-
-  return undefined;
-}

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

@@ -0,0 +1,115 @@
+import { describe, expect, it, jest, beforeEach } from "@jest/globals";
+
+const mockGetAgent = jest.fn();
+const mockResumeTask = jest.fn();
+const mockGetRunStatus = jest.fn();
+
+jest.mock("@axiom-lattice/core", () => ({
+  agentInstanceManager: {
+    getAgent: mockGetAgent,
+  },
+  ThreadStatus: {
+    IDLE: "IDLE",
+    BUSY: "BUSY",
+    INTERRUPTED: "INTERRUPTED",
+  },
+}));
+
+describe("recoverRun", () => {
+  let recoverRun: Function;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    const mod = await import("../../controllers/run");
+    recoverRun = mod.recoverRun;
+  });
+
+  it("should recover a thread and return its status", async () => {
+    const mockReply = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    };
+    const request = {
+      params: { assistantId: "a1", threadId: "t1" },
+      headers: {
+        "x-tenant-id": "tenant-x",
+        "x-workspace-id": "ws-1",
+        "x-project-id": "pj-1",
+      },
+    } as any;
+
+    const mockAgent = {
+      resumeTask: mockResumeTask.mockResolvedValue(undefined),
+      getRunStatus: mockGetRunStatus.mockResolvedValue("BUSY"),
+    };
+    mockGetAgent.mockReturnValue(mockAgent);
+
+    await recoverRun(request, mockReply);
+
+    expect(mockGetAgent).toHaveBeenCalledWith({
+      assistant_id: "a1",
+      thread_id: "t1",
+      tenant_id: "tenant-x",
+      workspace_id: "ws-1",
+      project_id: "pj-1",
+    });
+    expect(mockResumeTask).toHaveBeenCalled();
+    expect(mockGetRunStatus).toHaveBeenCalled();
+    expect(mockReply.status).toHaveBeenCalledWith(200);
+    expect(mockReply.send).toHaveBeenCalledWith({
+      success: true,
+      threadId: "t1",
+      status: "BUSY",
+    });
+  });
+
+  it("should default workspace/project to default when headers missing", async () => {
+    const mockReply = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    };
+    const request = {
+      params: { assistantId: "a1", threadId: "t1" },
+      headers: { "x-tenant-id": "tenant-x" },
+    } as any;
+
+    const mockAgent = {
+      resumeTask: mockResumeTask.mockResolvedValue(undefined),
+      getRunStatus: mockGetRunStatus.mockResolvedValue("IDLE"),
+    };
+    mockGetAgent.mockReturnValue(mockAgent);
+
+    await recoverRun(request, mockReply);
+
+    expect(mockGetAgent).toHaveBeenCalledWith({
+      assistant_id: "a1",
+      thread_id: "t1",
+      tenant_id: "tenant-x",
+      workspace_id: "default",
+      project_id: "default",
+    });
+  });
+
+  it("should return 500 on error", async () => {
+    const mockReply = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    };
+    const request = {
+      params: { assistantId: "a1", threadId: "t1" },
+      headers: { "x-tenant-id": "tenant-x" },
+    } as any;
+
+    mockGetAgent.mockImplementation(() => {
+      throw new Error("Agent not found");
+    });
+
+    await recoverRun(request, mockReply);
+
+    expect(mockReply.status).toHaveBeenCalledWith(500);
+    expect(mockReply.send).toHaveBeenCalledWith({
+      success: false,
+      error: "Recover failed: Agent not found",
+    });
+  });
+});

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

@@ -0,0 +1,215 @@
+/**
+ * Tasks Controller 测试
+ *
+ * 测试任务 REST API 控制器的端点逻辑，包括权限控制和错误处理。
+ */
+
+import { describe, expect, it, jest, beforeEach } from '@jest/globals';
+
+const mockStore = {
+  create: jest.fn<(...args: unknown[]) => Promise<unknown>>(),
+  list: jest.fn<(...args: unknown[]) => Promise<unknown>>(),
+  update: jest.fn<(...args: unknown[]) => Promise<unknown>>(),
+  delete: jest.fn<(...args: unknown[]) => Promise<unknown>>(),
+  getById: jest.fn<(...args: unknown[]) => Promise<unknown>>(),
+};
+
+jest.mock('@axiom-lattice/core', () => ({
+  getStoreLattice: jest.fn(() => ({ store: mockStore })),
+}));
+
+describe('Tasks Controller', () => {
+  let listTasks: Function;
+  let getTask: Function;
+  let createTask: Function;
+  let updateTask: Function;
+  let deleteTask: Function;
+  let completeTask: Function;
+
+  const mockReply = () =>
+    ({
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    }) as any;
+
+  const makeRequest = (overrides: Record<string, any> = {}) =>
+    ({
+      headers: { 'x-tenant-id': 'tenant-1', 'x-user-id': 'user-1' },
+      query: {},
+      ...overrides,
+    }) as any;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    const mod = await import('../../controllers/tasks');
+    listTasks = mod.listTasks;
+    getTask = mod.getTask;
+    createTask = mod.createTask;
+    updateTask = mod.updateTask;
+    deleteTask = mod.deleteTask;
+    completeTask = mod.completeTask;
+  });
+
+  describe('listTasks', () => {
+    it('should return tasks for current user by default', async () => {
+      mockStore.list.mockResolvedValue([{ id: 't1', title: 'Test' }]);
+      const result = await listTasks(makeRequest(), mockReply());
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(1);
+      expect(mockStore.list).toHaveBeenCalledWith(
+        expect.objectContaining({ tenantId: 'tenant-1', ownerId: 'user-1' })
+      );
+    });
+
+    it('should filter by ownerId from query params', async () => {
+      mockStore.list.mockResolvedValue([]);
+      await listTasks(
+        makeRequest({ query: { ownerId: 'other-user' } }),
+        mockReply()
+      );
+      expect(mockStore.list).toHaveBeenCalledWith(
+        expect.objectContaining({ ownerId: 'other-user' })
+      );
+    });
+
+    it('should return error when something fails', async () => {
+      mockStore.list.mockRejectedValue(new Error('DB down'));
+      const result = await listTasks(makeRequest(), mockReply());
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('DB down');
+    });
+  });
+
+  describe('getTask', () => {
+    it('should return task by id', async () => {
+      const task = { id: 't1', tenantId: 'tenant-1', ownerType: 'user', ownerId: 'user-1', title: 'T' };
+      mockStore.getById.mockResolvedValue(task);
+      const result = await getTask(makeRequest({ params: { id: 't1' } }), mockReply());
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(task);
+    });
+
+    it('should return 404 for non-existent task', async () => {
+      mockStore.getById.mockResolvedValue(null);
+      const reply = mockReply();
+      await getTask(makeRequest({ params: { id: 'nope' } }), reply);
+      expect(reply.status).toHaveBeenCalledWith(404);
+      expect(reply.send).toHaveBeenCalledWith(
+        expect.objectContaining({ success: false, error: 'Task not found' })
+      );
+    });
+
+    it('should return 403 for task owned by different user', async () => {
+      const task = { id: 't1', tenantId: 'tenant-1', ownerType: 'user', ownerId: 'other-user', title: 'T' };
+      mockStore.getById.mockResolvedValue(task);
+      const reply = mockReply();
+      await getTask(makeRequest({ params: { id: 't1' } }), reply);
+      expect(reply.status).toHaveBeenCalledWith(403);
+    });
+  });
+
+  describe('createTask', () => {
+    it('should create task with auto-filled owner', async () => {
+      const newTask = { id: 'new', title: 'Hello' };
+      mockStore.create.mockResolvedValue(newTask);
+      const reply = mockReply();
+      await createTask(makeRequest({ body: { title: 'Hello' } }), reply);
+      expect(mockStore.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tenantId: 'tenant-1',
+          ownerType: 'user',
+          ownerId: 'user-1',
+          title: 'Hello',
+        })
+      );
+      expect(reply.status).toHaveBeenCalledWith(201);
+      expect(reply.send).toHaveBeenCalledWith(
+        expect.objectContaining({ success: true, data: newTask })
+      );
+    });
+
+    it('should return 400 when title is missing', async () => {
+      const reply = mockReply();
+      await createTask(makeRequest({ body: {} }), reply);
+      expect(reply.status).toHaveBeenCalledWith(400);
+      expect(reply.send).toHaveBeenCalledWith(
+        expect.objectContaining({ success: false, error: 'title is required' })
+      );
+    });
+
+    it('should return 500 on store error', async () => {
+      mockStore.create.mockRejectedValue(new Error('Store error'));
+      const reply = mockReply();
+      await createTask(makeRequest({ body: { title: 'T' } }), reply);
+      expect(reply.status).toHaveBeenCalledWith(500);
+    });
+  });
+
+  describe('updateTask', () => {
+    const existingTask = { id: 't1', tenantId: 'tenant-1', ownerType: 'user', ownerId: 'user-1' };
+
+    it('should update task fields', async () => {
+      mockStore.getById.mockResolvedValue(existingTask);
+      mockStore.update.mockResolvedValue({ ...existingTask, title: 'Updated' });
+      const result = await updateTask(
+        makeRequest({ params: { id: 't1' }, body: { title: 'Updated' } }),
+        mockReply()
+      );
+      expect(result.success).toBe(true);
+      expect(mockStore.update).toHaveBeenCalledWith('tenant-1', 't1', { title: 'Updated' });
+    });
+
+    it('should return 404 for non-existent task', async () => {
+      mockStore.getById.mockResolvedValue(null);
+      const reply = mockReply();
+      await updateTask(makeRequest({ params: { id: 'nope' }, body: {} }), reply);
+      expect(reply.status).toHaveBeenCalledWith(404);
+    });
+
+    it('should return 403 for task owned by different user', async () => {
+      mockStore.getById.mockResolvedValue({ ...existingTask, ownerId: 'other-user' });
+      const reply = mockReply();
+      await updateTask(makeRequest({ params: { id: 't1' }, body: {} }), reply);
+      expect(reply.status).toHaveBeenCalledWith(403);
+    });
+  });
+
+  describe('deleteTask', () => {
+    const existingTask = { id: 't1', tenantId: 'tenant-1', ownerType: 'user', ownerId: 'user-1' };
+
+    it('should delete task and return success', async () => {
+      mockStore.getById.mockResolvedValue(existingTask);
+      mockStore.delete.mockResolvedValue(true);
+      const result = await deleteTask(makeRequest({ params: { id: 't1' } }), mockReply());
+      expect(result.success).toBe(true);
+      expect(result.message).toBe('Task deleted');
+      expect(mockStore.delete).toHaveBeenCalledWith('tenant-1', 't1');
+    });
+
+    it('should return 403 for task owned by different user', async () => {
+      mockStore.getById.mockResolvedValue({ ...existingTask, ownerId: 'other-user' });
+      const reply = mockReply();
+      await deleteTask(makeRequest({ params: { id: 't1' } }), reply);
+      expect(reply.status).toHaveBeenCalledWith(403);
+    });
+  });
+
+  describe('completeTask', () => {
+    const existingTask = { id: 't1', tenantId: 'tenant-1', ownerType: 'user', ownerId: 'user-1' };
+
+    it('should mark task as completed', async () => {
+      mockStore.getById.mockResolvedValue(existingTask);
+      mockStore.update.mockResolvedValue({ ...existingTask, status: 'completed' });
+      const result = await completeTask(makeRequest({ params: { id: 't1' } }), mockReply());
+      expect(result.success).toBe(true);
+      expect(mockStore.update).toHaveBeenCalledWith('tenant-1', 't1', { status: 'completed' });
+    });
+
+    it('should return 403 for task owned by different user', async () => {
+      mockStore.getById.mockResolvedValue({ ...existingTask, ownerId: 'other-user' });
+      const reply = mockReply();
+      await completeTask(makeRequest({ params: { id: 't1' } }), reply);
+      expect(reply.status).toHaveBeenCalledWith(403);
+    });
+  });
+});

package/src/controllers/agent_task.ts

@@ -25,6 +25,8 @@ export const triggerAgentTask = async (
       request.body as TriggerAgentTaskRequest;
 
     const tenant_id = request.headers["x-tenant-id"] as string;
+    const workspace_id = request.headers["x-workspace-id"] as string | undefined;
+    const project_id = request.headers["x-project-id"] as string | undefined;
 
     // Validate required fields
     if (!assistant_id) {
@@ -51,6 +53,11 @@ export const triggerAgentTask = async (
       input,
       command,
       "x-tenant-id": tenant_id,
+      runConfig: {
+        workspaceId: workspace_id,
+        projectId: project_id,
+        user_id: (request as any).user?.id,
+      },
     });
 
     reply.status(200).send({