@lobu/gateway 3.0.9 → 3.0.12

package/src/__tests__/chat-instance-manager-slack.test.ts

@@ -1,204 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import { ChatInstanceManager } from "../connections/chat-instance-manager";
-
-class PipelineRedisMock {
-  private readonly operations: Array<() => Promise<unknown>> = [];
-
-  constructor(private readonly redis: RedisMock) {}
-
-  set(key: string, value: string): this {
-    this.operations.push(() => this.redis.set(key, value));
-    return this;
-  }
-
-  sadd(key: string, member: string): this {
-    this.operations.push(() => this.redis.sadd(key, member));
-    return this;
-  }
-
-  async exec(): Promise<unknown[]> {
-    const results: unknown[] = [];
-    for (const operation of this.operations) {
-      results.push(await operation());
-    }
-    return results;
-  }
-}
-
-class RedisMock {
-  private readonly strings = new Map<string, string>();
-  private readonly sets = new Map<string, Set<string>>();
-
-  async get(key: string): Promise<string | null> {
-    return this.strings.get(key) ?? null;
-  }
-
-  async set(key: string, value: string): Promise<"OK"> {
-    this.strings.set(key, value);
-    return "OK";
-  }
-
-  async del(...keys: string[]): Promise<number> {
-    let removed = 0;
-    for (const key of keys) {
-      const existed = this.strings.delete(key) || this.sets.delete(key);
-      if (existed) {
-        removed++;
-      }
-    }
-    return removed;
-  }
-
-  async sadd(key: string, ...members: string[]): Promise<number> {
-    if (!this.sets.has(key)) {
-      this.sets.set(key, new Set());
-    }
-
-    const set = this.sets.get(key)!;
-    let added = 0;
-    for (const member of members) {
-      if (!set.has(member)) {
-        set.add(member);
-        added++;
-      }
-    }
-    return added;
-  }
-
-  async srem(key: string, ...members: string[]): Promise<number> {
-    const set = this.sets.get(key);
-    if (!set) {
-      return 0;
-    }
-
-    let removed = 0;
-    for (const member of members) {
-      if (set.delete(member)) {
-        removed++;
-      }
-    }
-    return removed;
-  }
-
-  async smembers(key: string): Promise<string[]> {
-    return Array.from(this.sets.get(key) || []);
-  }
-
-  pipeline(): PipelineRedisMock {
-    return new PipelineRedisMock(this);
-  }
-}
-
-describe("ChatInstanceManager Slack marketplace support", () => {
-  test("ensureSlackWorkspaceConnection is idempotent per team", async () => {
-    const manager = new ChatInstanceManager() as any;
-    const redis = new RedisMock();
-    const startInstance = mock(async (connection: any) => {
-      manager.instances.set(connection.id, {
-        connection,
-        chat: { webhooks: { slack: async () => new Response("ok") } },
-        cleanup: async () => undefined,
-      });
-    });
-
-    manager.redis = redis;
-    manager.startInstance = startInstance;
-    manager.resolveSlackAdapterConfig = mock(() => ({
-      platform: "slack",
-      signingSecret: "signing-secret",
-      clientId: "client-id",
-      clientSecret: "client-secret",
-    }));
-
-    const first = await manager.ensureSlackWorkspaceConnection("T123", {
-      botToken: "xoxb-first-token",
-      botUserId: "U123",
-      teamName: "Acme",
-    });
-    const second = await manager.ensureSlackWorkspaceConnection("T123", {
-      botToken: "xoxb-second-token",
-      botUserId: "U456",
-      teamName: "Acme Updated",
-    });
-
-    expect(second.id).toBe(first.id);
-    expect(startInstance).toHaveBeenCalledTimes(2);
-
-    const connections = await manager.listConnections({ platform: "slack" });
-    expect(connections).toHaveLength(1);
-
-    const stored = JSON.parse(
-      (await redis.get(`connection:${first.id}`)) || "{}"
-    );
-    const decryptedConfig = manager.decryptConfig(stored.config);
-
-    expect(stored.metadata).toEqual({
-      teamId: "T123",
-      teamName: "Acme Updated",
-      botUserId: "U456",
-    });
-    expect(decryptedConfig.botToken).toBe("xoxb-second-token");
-    expect(decryptedConfig.botUserId).toBe("U456");
-  });
-
-  test("handleSlackAppWebhook prefers an exact team match", async () => {
-    const manager = new ChatInstanceManager() as any;
-
-    manager.findSlackConnectionByTeamId = mock(async (teamId: string) =>
-      teamId === "T123" ? { id: "conn-team" } : null
-    );
-    manager.getDefaultSlackConnection = mock(async () => ({
-      id: "conn-default",
-    }));
-    manager.ensureConnectionRunning = mock(async () => true);
-    manager.handleWebhook = mock(
-      async (connectionId: string, request: Request) => {
-        const body = await request.text();
-        return new Response(`${connectionId}:${body}`);
-      }
-    );
-
-    const body = JSON.stringify({ team_id: "T123", type: "event_callback" });
-    const response = await manager.handleSlackAppWebhook(
-      new Request("https://gateway.example.com/slack/events", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body,
-      })
-    );
-
-    expect(response.status).toBe(200);
-    expect(await response.text()).toBe(`conn-team:${body}`);
-    expect(manager.handleWebhook).toHaveBeenCalledTimes(1);
-    expect(manager.handleWebhook.mock.calls[0]?.[0]).toBe("conn-team");
-  });
-
-  test("handleSlackAppWebhook falls back to the default Slack connection", async () => {
-    const manager = new ChatInstanceManager() as any;
-
-    manager.findSlackConnectionByTeamId = mock(async () => null);
-    manager.getDefaultSlackConnection = mock(async () => ({
-      id: "conn-default",
-    }));
-    manager.ensureConnectionRunning = mock(async () => true);
-    manager.handleWebhook = mock(
-      async (connectionId: string, request: Request) => {
-        const body = await request.text();
-        return new Response(`${connectionId}:${body}`);
-      }
-    );
-
-    const body = JSON.stringify({ type: "url_verification" });
-    const response = await manager.handleSlackAppWebhook(
-      new Request("https://gateway.example.com/slack/events", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body,
-      })
-    );
-
-    expect(response.status).toBe(200);
-    expect(await response.text()).toBe(`conn-default:${body}`);
-    expect(manager.handleWebhook.mock.calls[0]?.[0]).toBe("conn-default");
-  });
-});

package/src/__tests__/chat-response-bridge.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ChatResponseBridge } from "../connections/chat-response-bridge";
-
-function createRedisMock() {
-  return {
-    pipeline() {
-      return {
-        rpush() {
-          return this;
-        },
-        ltrim() {
-          return this;
-        },
-        expire() {
-          return this;
-        },
-        exec: async () => [],
-      };
-    },
-  };
-}
-
-describe("ChatResponseBridge.handleEphemeral", () => {
-  test("renders settings links as native buttons for Chat SDK targets", async () => {
-    const posts: unknown[] = [];
-    const target = {
-      post: async (payload: unknown) => {
-        posts.push(payload);
-        return { id: "msg-1" };
-      },
-    };
-    const manager = {
-      getInstance: () => ({
-        connection: { platform: "telegram" },
-        chat: {
-          channel: () => target,
-        },
-      }),
-      getServices: () => ({
-        getQueue: () => ({
-          getRedisClient: () => createRedisMock(),
-        }),
-      }),
-    };
-
-    const bridge = new ChatResponseBridge(manager as any);
-    await bridge.handleEphemeral({
-      messageId: "m1",
-      channelId: "123",
-      conversationId: "123",
-      userId: "u1",
-      teamId: "telegram",
-      timestamp: Date.now(),
-      platform: "telegram",
-      platformMetadata: {
-        connectionId: "conn-1",
-        chatId: "123",
-      },
-      content:
-        "Setup required: add OpenAI in settings before this bot can respond.\n\n[Open Agent Settings](https://example.com/connect/claim?claim=abc123)",
-    });
-
-    expect(posts).toHaveLength(1);
-    expect(posts[0]).toBeObject();
-    expect(posts[0]).toHaveProperty("card");
-    expect(posts[0]).toHaveProperty("fallbackText");
-    expect((posts[0] as { fallbackText: string }).fallbackText).toContain(
-      "Open Agent Settings: https://example.com/connect/claim?claim=abc123"
-    );
-  });
-
-  test("buffers telegram markdown until completion", async () => {
-    const posts: unknown[] = [];
-    const target = {
-      post: async (payload: unknown) => {
-        posts.push(payload);
-        return { id: "msg-1", threadId: "123" };
-      },
-    };
-    const manager = {
-      getInstance: () => ({
-        connection: { platform: "telegram" },
-        chat: {
-          channel: () => target,
-        },
-      }),
-      getServices: () => ({
-        getQueue: () => ({
-          getRedisClient: () => createRedisMock(),
-        }),
-      }),
-    };
-
-    const bridge = new ChatResponseBridge(manager as any);
-    const basePayload = {
-      messageId: "m1",
-      channelId: "123",
-      conversationId: "123",
-      userId: "u1",
-      teamId: "telegram",
-      timestamp: Date.now(),
-      platform: "telegram",
-      platformMetadata: {
-        connectionId: "conn-1",
-        chatId: "123",
-      },
-    };
-
-    await bridge.handleDelta(
-      {
-        ...basePayload,
-        delta: "*Reason",
-      },
-      "session-1"
-    );
-    await bridge.handleDelta(
-      {
-        ...basePayload,
-        delta: "ing:* hello",
-      },
-      "session-1"
-    );
-
-    expect(posts).toHaveLength(0);
-
-    await bridge.handleCompletion(basePayload, "session-1");
-
-    expect(posts).toHaveLength(1);
-    expect(posts[0]).toEqual({ markdown: "*Reasoning:* hello" });
-  });
-});

package/src/__tests__/config-memory-plugins.test.ts

@@ -1,92 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { buildMemoryPlugins } from "../config";
-
-const originalMemoryUrl = process.env.MEMORY_URL;
-const originalDispatcherServiceName = process.env.DISPATCHER_SERVICE_NAME;
-const originalKubernetesNamespace = process.env.KUBERNETES_NAMESPACE;
-
-afterEach(() => {
-  if (originalMemoryUrl === undefined) {
-    delete process.env.MEMORY_URL;
-  } else {
-    process.env.MEMORY_URL = originalMemoryUrl;
-  }
-
-  if (originalDispatcherServiceName === undefined) {
-    delete process.env.DISPATCHER_SERVICE_NAME;
-  } else {
-    process.env.DISPATCHER_SERVICE_NAME = originalDispatcherServiceName;
-  }
-
-  if (originalKubernetesNamespace === undefined) {
-    delete process.env.KUBERNETES_NAMESPACE;
-  } else {
-    process.env.KUBERNETES_NAMESPACE = originalKubernetesNamespace;
-  }
-});
-
-describe("buildMemoryPlugins", () => {
-  test("returns native memory when MEMORY_URL is unset and plugin exists", () => {
-    delete process.env.MEMORY_URL;
-
-    expect(buildMemoryPlugins({ hasNativeMemoryPlugin: true })).toEqual([
-      {
-        source: "@openclaw/native-memory",
-        slot: "memory",
-        enabled: true,
-      },
-    ]);
-  });
-
-  test("returns no plugin when MEMORY_URL is unset and native memory is unavailable", () => {
-    delete process.env.MEMORY_URL;
-
-    expect(buildMemoryPlugins({ hasNativeMemoryPlugin: false })).toEqual([]);
-  });
-
-  test("falls back to native memory when Owletto plugin is unavailable", () => {
-    process.env.MEMORY_URL = "https://memory.example.com";
-
-    expect(
-      buildMemoryPlugins({
-        hasOwlettoPlugin: false,
-        hasNativeMemoryPlugin: true,
-      })
-    ).toEqual([
-      {
-        source: "@openclaw/native-memory",
-        slot: "memory",
-        enabled: true,
-      },
-    ]);
-  });
-
-  test("returns no plugin when neither Owletto nor native memory plugin exists", () => {
-    process.env.MEMORY_URL = "https://memory.example.com";
-
-    expect(
-      buildMemoryPlugins({
-        hasOwlettoPlugin: false,
-        hasNativeMemoryPlugin: false,
-      })
-    ).toEqual([]);
-  });
-
-  test("uses Owletto plugin when installed and MEMORY_URL is set", () => {
-    process.env.MEMORY_URL = "https://memory.example.com";
-    process.env.DISPATCHER_SERVICE_NAME = "lobu-gateway";
-    process.env.KUBERNETES_NAMESPACE = "lobu";
-
-    expect(buildMemoryPlugins({ hasOwlettoPlugin: true })).toEqual([
-      {
-        source: "@lobu/owletto-openclaw",
-        slot: "memory",
-        enabled: true,
-        config: {
-          mcpUrl: "http://lobu-gateway.lobu.svc.cluster.local:8080/mcp/owletto",
-          gatewayAuthUrl: "http://lobu-gateway.lobu.svc.cluster.local:8080",
-        },
-      },
-    ]);
-  });
-});

package/src/__tests__/config-request-store.test.ts

@@ -1,127 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import {
-  applyPendingConfigRequest,
-  buildConfigRequestText,
-} from "../interactions/config-request-store";
-
-describe("config-request-store", () => {
-  test("applies skills, mcps, nix packages, and grants", async () => {
-    const updateSettings = mock(() => Promise.resolve());
-    const grant = mock(() => Promise.resolve());
-    const agentSettingsStore = {
-      getSettings: mock(() =>
-        Promise.resolve({
-          nixConfig: { packages: ["git"] },
-          skillsConfig: {
-            skills: [
-              {
-                repo: "existing-skill",
-                name: "Existing Skill",
-                description: "Existing",
-                enabled: false,
-              },
-            ],
-          },
-          mcpServers: {
-            existing: { enabled: true, url: "https://existing.example.com" },
-          },
-        })
-      ),
-      updateSettings,
-    };
-    const grantStore = { grant };
-
-    await applyPendingConfigRequest(
-      agentSettingsStore as any,
-      grantStore as any,
-      {
-        agentId: "agent-1",
-        reason: "Install requested skill",
-        skills: [
-          {
-            repo: "existing-skill",
-            name: "Existing Skill",
-            description: "Updated",
-          },
-          {
-            repo: "new-skill",
-            name: "New Skill",
-            description: "New",
-          },
-        ],
-        mcpServers: [
-          {
-            id: "new-mcp",
-            name: "New MCP",
-            url: "https://mcp.example.com",
-            type: "sse",
-          },
-        ],
-        nixPackages: ["git", "ffmpeg"],
-        grants: ["api.example.com"],
-      }
-    );
-
-    expect(updateSettings).toHaveBeenCalledTimes(1);
-    const [, updates] = updateSettings.mock.calls[0]!;
-    expect(updates.skillsConfig.skills).toHaveLength(2);
-    expect(
-      updates.skillsConfig.skills.find(
-        (skill: any) => skill.repo === "existing-skill"
-      ).enabled
-    ).toBe(true);
-    expect(
-      updates.skillsConfig.skills.find(
-        (skill: any) => skill.repo === "new-skill"
-      ).name
-    ).toBe("New Skill");
-    expect(updates.mcpServers["new-mcp"]).toMatchObject({
-      enabled: true,
-      url: "https://mcp.example.com",
-      type: "sse",
-    });
-    expect(updates.nixConfig.packages).toEqual(["git", "ffmpeg"]);
-    expect(grant).toHaveBeenCalledWith("agent-1", "api.example.com", null);
-  });
-
-  test("skips settings writes when a request only grants permissions", async () => {
-    const updateSettings = mock(() => Promise.resolve());
-    const grant = mock(() => Promise.resolve());
-    const agentSettingsStore = {
-      getSettings: mock(() => Promise.resolve({})),
-      updateSettings,
-    };
-    const grantStore = { grant };
-
-    await applyPendingConfigRequest(
-      agentSettingsStore as any,
-      grantStore as any,
-      {
-        agentId: "agent-1",
-        reason: "Allow API access",
-        grants: ["api.example.com"],
-      }
-    );
-
-    expect(updateSettings).not.toHaveBeenCalled();
-    expect(grant).toHaveBeenCalledWith("agent-1", "api.example.com", null);
-  });
-
-  test("builds readable config request text", () => {
-    const text = buildConfigRequestText({
-      agentId: "agent-1",
-      reason: "Install skill",
-      message: "Needed for triage",
-      skills: [{ repo: "ops-triage", name: "Ops Triage" }],
-      nixPackages: ["ffmpeg"],
-      grants: ["api.example.com"],
-      providers: ["openai"],
-    });
-
-    expect(text).toContain("Configuration Change Request");
-    expect(text).toContain("Ops Triage");
-    expect(text).toContain("ffmpeg");
-    expect(text).toContain("api.example.com");
-    expect(text).toContain("openai");
-  });
-});

package/src/__tests__/connection-routes.test.ts

@@ -1,144 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { MockRedisClient } from "@lobu/core/testing";
-import { AgentMetadataStore } from "../auth/agent-metadata-store";
-import { UserAgentsStore } from "../auth/user-agents-store";
-import { createConnectionCrudRoutes } from "../routes/public/connections";
-import { setAuthProvider } from "../routes/public/settings-auth";
-
-describe("connection routes", () => {
-  let redis: MockRedisClient;
-  let agentMetadataStore: AgentMetadataStore;
-  let userAgentsStore: UserAgentsStore;
-
-  beforeEach(async () => {
-    redis = new MockRedisClient();
-    agentMetadataStore = new AgentMetadataStore(redis as any);
-    userAgentsStore = new UserAgentsStore(redis as any);
-
-    await agentMetadataStore.createAgent(
-      "agent-1",
-      "Agent 1",
-      "telegram",
-      "u1"
-    );
-    await agentMetadataStore.createAgent(
-      "sandbox-1",
-      "Sandbox 1",
-      "telegram",
-      "u1",
-      {
-        parentConnectionId: "conn-1",
-      }
-    );
-    await userAgentsStore.addAgent("telegram", "u1", "agent-1");
-  });
-
-  afterEach(() => {
-    setAuthProvider(null);
-  });
-
-  function buildApp() {
-    return createConnectionCrudRoutes(
-      {
-        async listConnections(filters?: any) {
-          const connection = {
-            id: "conn-1",
-            platform: "telegram",
-            templateAgentId: "agent-1",
-            config: { platform: "telegram" },
-            settings: {},
-            metadata: {},
-            status: "active",
-            createdAt: 1,
-            updatedAt: 1,
-          };
-          if (
-            filters?.templateAgentId &&
-            filters.templateAgentId !== "agent-1"
-          ) {
-            return [];
-          }
-          return [connection];
-        },
-        async getConnection(id: string) {
-          if (id !== "conn-1") return null;
-          return {
-            id: "conn-1",
-            platform: "telegram",
-            templateAgentId: "agent-1",
-            config: { platform: "telegram" },
-            settings: {},
-            metadata: {},
-            status: "active",
-            createdAt: 1,
-            updatedAt: 1,
-          };
-        },
-        has() {
-          return true;
-        },
-        getServices() {
-          return {
-            getQueue() {
-              return {
-                getRedisClient() {
-                  return redis;
-                },
-              };
-            },
-          };
-        },
-      } as any,
-      {
-        userAgentsStore,
-        agentMetadataStore: {
-          getMetadata: (agentId: string) =>
-            agentMetadataStore.getMetadata(agentId),
-          listSandboxes: (connectionId: string) =>
-            agentMetadataStore.listSandboxes(connectionId),
-        },
-      }
-    );
-  }
-
-  test("forbids non-admin sessions from listing all connections", async () => {
-    setAuthProvider(() => ({
-      userId: "u1",
-      platform: "telegram",
-      exp: Date.now() + 60_000,
-    }));
-
-    const response = await buildApp().request("/api/v1/connections");
-    expect(response.status).toBe(403);
-  });
-
-  test("allows external owner sessions to list connections for their agent", async () => {
-    setAuthProvider(() => ({
-      userId: "u1",
-      oauthUserId: "u1",
-      platform: "external",
-      exp: Date.now() + 60_000,
-    }));
-
-    const response = await buildApp().request(
-      "/api/v1/connections?templateAgentId=agent-1"
-    );
-    expect(response.status).toBe(200);
-    const data = (await response.json()) as any;
-    expect(data.connections).toHaveLength(1);
-    expect(data.connections[0]?.id).toBe("conn-1");
-  });
-
-  test("forbids sandbox listing when session cannot access the connection template agent", async () => {
-    setAuthProvider(() => ({
-      userId: "u2",
-      platform: "telegram",
-      exp: Date.now() + 60_000,
-    }));
-
-    const response = await buildApp().request(
-      "/api/v1/connections/conn-1/sandboxes"
-    );
-    expect(response.status).toBe(403);
-  });
-});