@lobu/gateway 3.0.5 → 3.0.7

package/src/__tests__/agent-settings-store.test.ts

@@ -0,0 +1,323 @@
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+import { MockRedisClient } from "@lobu/core/testing";
+import { AgentSettingsStore } from "../auth/settings/agent-settings-store";
+
+const TEST_ENCRYPTION_KEY =
+  "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+
+let originalEncryptionKey: string | undefined;
+
+beforeAll(() => {
+  originalEncryptionKey = process.env.ENCRYPTION_KEY;
+  process.env.ENCRYPTION_KEY = TEST_ENCRYPTION_KEY;
+});
+
+afterAll(() => {
+  if (originalEncryptionKey !== undefined) {
+    process.env.ENCRYPTION_KEY = originalEncryptionKey;
+  } else {
+    delete process.env.ENCRYPTION_KEY;
+  }
+});
+
+function createStore(redis?: MockRedisClient) {
+  const r = redis ?? new MockRedisClient();
+  const store = new AgentSettingsStore(r as any);
+  return { store, redis: r };
+}
+
+describe("AgentSettingsStore", () => {
+  let redis: MockRedisClient;
+  let store: AgentSettingsStore;
+
+  beforeEach(() => {
+    const created = createStore();
+    redis = created.redis;
+    store = created.store;
+  });
+
+  describe("CRUD basics", () => {
+    test("saveSettings stores and getSettings retrieves", async () => {
+      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
+      const result = await store.getSettings("agent-1");
+      expect(result).not.toBeNull();
+      expect(result!.model).toBe("claude-sonnet-4");
+      expect(result!.updatedAt).toBeGreaterThan(0);
+    });
+
+    test("getSettings returns null for non-existent agent", async () => {
+      const result = await store.getSettings("missing");
+      expect(result).toBeNull();
+    });
+
+    test("updateSettings merges with existing", async () => {
+      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
+      await store.updateSettings("agent-1", { soulMd: "Be helpful" });
+      const result = await store.getSettings("agent-1");
+      expect(result!.model).toBe("claude-sonnet-4");
+      expect(result!.soulMd).toBe("Be helpful");
+    });
+
+    test("deleteSettings removes settings", async () => {
+      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
+      await store.deleteSettings("agent-1");
+      const result = await store.getSettings("agent-1");
+      expect(result).toBeNull();
+    });
+
+    test("hasSettings returns boolean", async () => {
+      expect(await store.hasSettings("agent-1")).toBe(false);
+      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
+      expect(await store.hasSettings("agent-1")).toBe(true);
+    });
+  });
+
+  describe("partial update merging", () => {
+    test("merges new fields with existing", async () => {
+      await store.saveSettings("agent-1", {
+        model: "claude-sonnet-4",
+        soulMd: "Original",
+      });
+      await store.updateSettings("agent-1", { userMd: "New field" });
+      const result = await store.getSettings("agent-1");
+      expect(result!.model).toBe("claude-sonnet-4");
+      expect(result!.soulMd).toBe("Original");
+      expect(result!.userMd).toBe("New field");
+    });
+
+    test("overwrites overlapping fields", async () => {
+      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
+      await store.updateSettings("agent-1", { model: "claude-opus-4" });
+      const result = await store.getSettings("agent-1");
+      expect(result!.model).toBe("claude-opus-4");
+    });
+
+    test("creates if no existing settings", async () => {
+      await store.updateSettings("agent-1", { model: "claude-opus-4" });
+      const result = await store.getSettings("agent-1");
+      expect(result).not.toBeNull();
+      expect(result!.model).toBe("claude-opus-4");
+    });
+  });
+
+  describe("encryption of authProfiles.credential", () => {
+    test("credential is encrypted in Redis and decrypted on read", async () => {
+      const apiKey = "sk-ant-secret-key-12345";
+      await store.saveSettings("agent-1", {
+        authProfiles: [
+          {
+            id: "profile-1",
+            provider: "anthropic",
+            model: "claude-sonnet-4",
+            credential: apiKey,
+            label: "test",
+            authType: "api-key",
+            createdAt: Date.now(),
+          },
+        ],
+      });
+
+      // Check raw value in Redis has enc:v1: prefix
+      const rawData = await redis.get("agent:settings:agent-1");
+      expect(rawData).not.toBeNull();
+      const parsed = JSON.parse(rawData!);
+      expect(parsed.authProfiles[0].credential).toStartWith("enc:v1:");
+      expect(parsed.authProfiles[0].credential).not.toBe(apiKey);
+
+      // Check decrypted on read
+      const result = await store.getSettings("agent-1");
+      expect(result!.authProfiles![0].credential).toBe(apiKey);
+    });
+  });
+
+  describe("encryption of refreshToken", () => {
+    test("refreshToken is encrypted in Redis and decrypted on read", async () => {
+      const refreshToken = "rt-secret-refresh-token-xyz";
+      await store.saveSettings("agent-1", {
+        authProfiles: [
+          {
+            id: "profile-1",
+            provider: "anthropic",
+            model: "claude-sonnet-4",
+            credential: "sk-key",
+            label: "test",
+            authType: "oauth",
+            metadata: {
+              refreshToken,
+              email: "user@example.com",
+            },
+            createdAt: Date.now(),
+          },
+        ],
+      });
+
+      // Check raw value in Redis
+      const rawData = await redis.get("agent:settings:agent-1");
+      const parsed = JSON.parse(rawData!);
+      expect(parsed.authProfiles[0].metadata.refreshToken).toStartWith(
+        "enc:v1:"
+      );
+
+      // Check decrypted on read
+      const result = await store.getSettings("agent-1");
+      expect(result!.authProfiles![0].metadata!.refreshToken).toBe(
+        refreshToken
+      );
+    });
+  });
+
+  describe("no double-encryption", () => {
+    test("already encrypted values are not re-encrypted", async () => {
+      // Save once to encrypt
+      await store.saveSettings("agent-1", {
+        authProfiles: [
+          {
+            id: "profile-1",
+            provider: "anthropic",
+            model: "claude-sonnet-4",
+            credential: "sk-key",
+            label: "test",
+            authType: "api-key",
+            createdAt: Date.now(),
+          },
+        ],
+      });
+
+      const rawAfterFirst = await redis.get("agent:settings:agent-1");
+      const parsedFirst = JSON.parse(rawAfterFirst!);
+      const encryptedCredential = parsedFirst.authProfiles[0].credential;
+
+      // Update to re-save (simulating save with already-encrypted value)
+      await store.updateSettings("agent-1", { model: "claude-opus-4" });
+
+      const rawAfterSecond = await redis.get("agent:settings:agent-1");
+      const parsedSecond = JSON.parse(rawAfterSecond!);
+
+      // The credential should still be encrypted, not double-encrypted
+      // Both should decrypt to the same plaintext
+      const result = await store.getSettings("agent-1");
+      expect(result!.authProfiles![0].credential).toBe("sk-key");
+    });
+  });
+
+  describe("graceful plaintext when ENCRYPTION_KEY missing", () => {
+    test("values stored as plaintext without encryption key", async () => {
+      const savedKey = process.env.ENCRYPTION_KEY;
+      delete process.env.ENCRYPTION_KEY;
+
+      try {
+        const { store: noEncStore, redis: noEncRedis } = createStore();
+
+        const apiKey = "sk-plaintext-key";
+        await noEncStore.saveSettings("agent-1", {
+          authProfiles: [
+            {
+              id: "profile-1",
+              provider: "anthropic",
+              model: "claude-sonnet-4",
+              credential: apiKey,
+              label: "test",
+              authType: "api-key",
+              createdAt: Date.now(),
+            },
+          ],
+        });
+
+        // Raw value should be plaintext (no enc:v1: prefix)
+        const rawData = await noEncRedis.get("agent:settings:agent-1");
+        const parsed = JSON.parse(rawData!);
+        expect(parsed.authProfiles[0].credential).toBe(apiKey);
+        expect(parsed.authProfiles[0].credential).not.toStartWith("enc:v1:");
+
+        // Read should also return plaintext
+        const result = await noEncStore.getSettings("agent-1");
+        expect(result!.authProfiles![0].credential).toBe(apiKey);
+      } finally {
+        process.env.ENCRYPTION_KEY = savedKey;
+      }
+    });
+  });
+
+  describe("findTemplateAgentId", () => {
+    test("returns first agent with installedProviders", async () => {
+      // Agent without installedProviders
+      await store.saveSettings("agent-no-providers", {
+        model: "claude-sonnet-4",
+      });
+
+      // Agent with installedProviders
+      await store.saveSettings("agent-with-providers", {
+        model: "claude-opus-4",
+        installedProviders: [
+          {
+            id: "anthropic",
+            displayName: "Anthropic",
+            envVarName: "ANTHROPIC_API_KEY",
+            upstreamBaseUrl: "https://api.anthropic.com",
+          },
+        ],
+      });
+
+      const templateId = await store.findTemplateAgentId();
+      expect(templateId).toBe("agent-with-providers");
+    });
+
+    test("returns null when no agents have providers", async () => {
+      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
+      await store.saveSettings("agent-2", { model: "claude-opus-4" });
+
+      const templateId = await store.findTemplateAgentId();
+      expect(templateId).toBeNull();
+    });
+  });
+
+  describe("findSandboxAgentIds", () => {
+    test("returns agent IDs referencing template", async () => {
+      const templateId = "template-agent";
+
+      await store.saveSettings(templateId, {
+        model: "claude-opus-4",
+        installedProviders: [
+          {
+            id: "anthropic",
+            displayName: "Anthropic",
+            envVarName: "ANTHROPIC_API_KEY",
+            upstreamBaseUrl: "https://api.anthropic.com",
+          },
+        ],
+      });
+
+      await store.saveSettings("sandbox-1", {
+        model: "claude-sonnet-4",
+        templateAgentId: templateId,
+      });
+
+      await store.saveSettings("sandbox-2", {
+        model: "claude-sonnet-4",
+        templateAgentId: templateId,
+      });
+
+      // Unrelated agent
+      await store.saveSettings("other-agent", {
+        model: "claude-sonnet-4",
+      });
+
+      const sandboxIds = await store.findSandboxAgentIds(templateId);
+      expect(sandboxIds).toHaveLength(2);
+      expect(sandboxIds.sort()).toEqual(["sandbox-1", "sandbox-2"]);
+    });
+
+    test("returns empty array when no sandboxes exist", async () => {
+      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
+      const sandboxIds = await store.findSandboxAgentIds("non-existent");
+      expect(sandboxIds).toEqual([]);
+    });
+  });
+});

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

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

@@ -0,0 +1,131 @@
+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" });
+  });
+});