@lobu/gateway 3.0.8 → 3.0.12

package/src/__tests__/model-selection.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  getModelSelectionState,
-  reconcileModelSelectionForInstalledProviders,
-  resolveEffectiveModelRef,
-} from "../auth/settings/model-selection";
-
-describe("model-selection", () => {
-  test("uses legacy model as pinned fallback", () => {
-    expect(getModelSelectionState({ model: "openai/gpt-5" })).toEqual({
-      mode: "pinned",
-      pinnedModel: "openai/gpt-5",
-    });
-  });
-
-  test("resolves pinned model when pinned provider is installed", () => {
-    const effective = resolveEffectiveModelRef({
-      modelSelection: { mode: "pinned", pinnedModel: "openai/gpt-5" },
-      installedProviders: [
-        { providerId: "openai", installedAt: 1 },
-        { providerId: "anthropic", installedAt: 2 },
-      ],
-      providerModelPreferences: {
-        openai: "openai/gpt-4.1",
-      },
-    } as any);
-
-    expect(effective).toBe("openai/gpt-5");
-  });
-
-  test("falls back to primary provider preference when pinned provider is removed", () => {
-    const effective = resolveEffectiveModelRef({
-      modelSelection: { mode: "pinned", pinnedModel: "anthropic/claude-3.7" },
-      installedProviders: [{ providerId: "openai", installedAt: 1 }],
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-        anthropic: "anthropic/claude-3.7",
-      },
-    } as any);
-
-    expect(effective).toBe("openai/gpt-5");
-  });
-
-  test("reconcile clears invalid pinned selection and removes uninstalled preferences", () => {
-    const reconciled = reconcileModelSelectionForInstalledProviders({
-      model: "anthropic/claude-3.7",
-      modelSelection: { mode: "pinned", pinnedModel: "anthropic/claude-3.7" },
-      installedProviders: [{ providerId: "openai", installedAt: 1 }],
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-        anthropic: "anthropic/claude-3.7",
-      },
-    } as any);
-
-    expect(reconciled).toEqual({
-      modelSelection: { mode: "auto" },
-      model: undefined,
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-      },
-    });
-  });
-
-  test("reconcile keeps valid pinned selection", () => {
-    const reconciled = reconcileModelSelectionForInstalledProviders({
-      model: "openai/gpt-5",
-      modelSelection: { mode: "pinned", pinnedModel: "openai/gpt-5" },
-      installedProviders: [{ providerId: "openai", installedAt: 1 }],
-      providerModelPreferences: {
-        openai: "openai/gpt-4.1",
-      },
-    } as any);
-
-    expect(reconciled.modelSelection).toEqual({
-      mode: "pinned",
-      pinnedModel: "openai/gpt-5",
-    });
-    expect(reconciled.model).toBe("openai/gpt-5");
-  });
-
-  test("auto mode follows primary provider order change", () => {
-    const before = resolveEffectiveModelRef({
-      modelSelection: { mode: "auto" },
-      installedProviders: [
-        { providerId: "openai", installedAt: 1 },
-        { providerId: "anthropic", installedAt: 2 },
-      ],
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-        anthropic: "anthropic/claude-sonnet-4",
-      },
-    } as any);
-    const after = resolveEffectiveModelRef({
-      modelSelection: { mode: "auto" },
-      installedProviders: [
-        { providerId: "anthropic", installedAt: 2 },
-        { providerId: "openai", installedAt: 1 },
-      ],
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-        anthropic: "anthropic/claude-sonnet-4",
-      },
-    } as any);
-
-    expect(before).toBe("openai/gpt-5");
-    expect(after).toBe("anthropic/claude-sonnet-4");
-  });
-
-  test("auto mode can keep non-primary provider preference without affecting effective model", () => {
-    const reconciled = reconcileModelSelectionForInstalledProviders({
-      modelSelection: { mode: "auto" },
-      installedProviders: [
-        { providerId: "openai", installedAt: 1 },
-        { providerId: "anthropic", installedAt: 2 },
-      ],
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-        anthropic: "anthropic/claude-opus-4",
-      },
-    } as any);
-
-    expect(reconciled.providerModelPreferences).toEqual({
-      openai: "openai/gpt-5",
-      anthropic: "anthropic/claude-opus-4",
-    });
-    expect(
-      resolveEffectiveModelRef({
-        modelSelection: reconciled.modelSelection,
-        installedProviders: [
-          { providerId: "openai", installedAt: 1 },
-          { providerId: "anthropic", installedAt: 2 },
-        ],
-        providerModelPreferences: reconciled.providerModelPreferences,
-      } as any)
-    ).toBe("openai/gpt-5");
-  });
-
-  test("reconcile removes stale preferences when provider is deleted", () => {
-    const reconciled = reconcileModelSelectionForInstalledProviders({
-      modelSelection: { mode: "auto" },
-      installedProviders: [{ providerId: "anthropic", installedAt: 2 }],
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-        anthropic: "anthropic/claude-sonnet-4",
-      },
-    } as any);
-
-    expect(reconciled.providerModelPreferences).toEqual({
-      anthropic: "anthropic/claude-sonnet-4",
-    });
-  });
-
-  test("falls back to auto when pinned model has no resolvable provider", () => {
-    const reconciled = reconcileModelSelectionForInstalledProviders({
-      modelSelection: { mode: "pinned", pinnedModel: "gpt-5" },
-      installedProviders: [{ providerId: "openai", installedAt: 1 }],
-      providerModelPreferences: {
-        openai: "openai/gpt-5",
-      },
-    } as any);
-
-    expect(reconciled.modelSelection).toEqual({ mode: "auto" });
-    expect(reconciled.model).toBeUndefined();
-    expect(
-      resolveEffectiveModelRef({
-        modelSelection: reconciled.modelSelection,
-        installedProviders: [{ providerId: "openai", installedAt: 1 }],
-        providerModelPreferences: reconciled.providerModelPreferences,
-      } as any)
-    ).toBe("openai/gpt-5");
-  });
-});

package/src/__tests__/oauth-templates.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  renderOAuthErrorPage,
-  renderOAuthSuccessPage,
-} from "../auth/oauth-templates";
-
-describe("OAuth template escaping", () => {
-  test("escapes reflected OAuth error params", () => {
-    const html = renderOAuthErrorPage(
-      '<script>alert("xss")</script>',
-      '<img src=x onerror=alert("xss")>'
-    );
-
-    expect(html).not.toContain('<script>alert("xss")</script>');
-    expect(html).not.toContain('<img src=x onerror=alert("xss")>');
-    expect(html).toContain(
-      "&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;"
-    );
-    expect(html).toContain("&lt;img src=x onerror=alert(&quot;xss&quot;)&gt;");
-  });
-
-  test("escapes provider name on success page", () => {
-    const html = renderOAuthSuccessPage('"><svg onload=alert(1)>');
-
-    expect(html).not.toContain('"><svg onload=alert(1)>');
-    expect(html).toContain("&quot;&gt;&lt;svg onload=alert(1)&gt;");
-  });
-
-  test("escapes settings URL on success page", () => {
-    const html = renderOAuthSuccessPage(
-      "Google",
-      '"><script>alert(1)</script>'
-    );
-
-    expect(html).not.toContain('"><script>alert(1)</script>');
-    expect(html).toContain("&quot;&gt;&lt;script&gt;alert(1)&lt;/script&gt;");
-    expect(html).toContain("Open Configuration");
-  });
-});

package/src/__tests__/platform-adapter-slack-send.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import { ChatInstanceManager } from "../connections/chat-instance-manager";
-
-/**
- * Helper: create a ChatInstanceManager with mocked internals for testing
- * sendPlatformMessage without requiring Redis.
- */
-function createTestManager(overrides: {
-  listConnections: (...args: any[]) => Promise<any[]>;
-  has: (id: string) => boolean;
-  getInstance: (id: string) => any;
-}): ChatInstanceManager {
-  const manager = new ChatInstanceManager();
-  // Patch internal methods used by sendPlatformMessage / selectConnectionForPlatform
-  (manager as any).listConnections = overrides.listConnections;
-  manager.has = overrides.has;
-  manager.getInstance = overrides.getInstance;
-  return manager;
-}
-
-describe("ChatInstanceManager Slack sendPlatformMessage", () => {
-  test("posts top-level messages through the channel API", async () => {
-    const post = mock(async () => ({ ts: "1700000000.000100" }));
-    const channel = mock(() => ({ post }));
-
-    const manager = createTestManager({
-      listConnections: async () => [
-        {
-          id: "conn-1",
-          platform: "slack",
-          agentId: "system:connection:slack",
-          config: {
-            platform: "slack",
-            botToken: "xoxb",
-            signingSecret: "sig",
-          },
-          settings: { allowGroups: true },
-          metadata: {},
-          status: "active",
-          createdAt: 0,
-          updatedAt: 0,
-        },
-      ],
-      has: () => true,
-      getInstance: () => ({
-        chat: {
-          channel,
-        },
-      }),
-    });
-
-    const result = await manager.sendPlatformMessage("slack", "@me hello", {
-      agentId: "agent-1",
-      channelId: "C123",
-      teamId: "T123",
-    });
-
-    expect(result.messageId).toBe("1700000000.000100");
-    expect(channel).toHaveBeenCalledTimes(1);
-    expect(channel.mock.calls[0]?.[0]).toBe("slack:C123");
-    expect(post).toHaveBeenCalledTimes(1);
-    expect(post.mock.calls[0]?.[0]).toBe("@me hello");
-  });
-
-  test("posts thread replies through a resolved thread", async () => {
-    const post = mock(async () => ({ ts: "1700000000.000200" }));
-    const createThread = mock(async () => ({ post }));
-    const getAdapter = mock(() => ({ name: "slack" }));
-
-    const manager = createTestManager({
-      listConnections: async () => [
-        {
-          id: "conn-1",
-          platform: "slack",
-          agentId: "system:connection:slack:T123",
-          config: {
-            platform: "slack",
-            botToken: "xoxb",
-            signingSecret: "sig",
-          },
-          settings: { allowGroups: true },
-          metadata: { teamId: "T123" },
-          status: "active",
-          createdAt: 0,
-          updatedAt: 0,
-        },
-      ],
-      has: () => true,
-      getInstance: () => ({
-        chat: {
-          getAdapter,
-          createThread,
-        },
-      }),
-    });
-
-    const result = await manager.sendPlatformMessage("slack", "@me follow up", {
-      agentId: "agent-1",
-      channelId: "C123",
-      conversationId: "1700000000.000100",
-      teamId: "T123",
-    });
-
-    expect(result.messageId).toBe("1700000000.000200");
-    expect(getAdapter).toHaveBeenCalledTimes(1);
-    expect(getAdapter.mock.calls[0]?.[0]).toBe("slack");
-    expect(createThread).toHaveBeenCalledTimes(1);
-    expect(createThread.mock.calls[0]?.[1]).toBe(
-      "slack:C123:1700000000.000100"
-    );
-    expect(post).toHaveBeenCalledTimes(1);
-    expect(post.mock.calls[0]?.[0]).toBe("@me follow up");
-  });
-});

package/src/__tests__/platform-helpers-model-resolution.test.ts

@@ -1,253 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import {
-  hasConfiguredProvider,
-  resolveAgentId,
-  resolveAgentOptions,
-} from "../services/platform-helpers";
-
-const originalDispatcherServiceName = process.env.DISPATCHER_SERVICE_NAME;
-const originalKubernetesNamespace = process.env.KUBERNETES_NAMESPACE;
-
-afterEach(() => {
-  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("resolveAgentOptions model resolution", () => {
-  test("uses pinned model when pinned provider is installed", async () => {
-    const settingsStore = {
-      getEffectiveSettings: async () =>
-        ({
-          modelSelection: {
-            mode: "pinned",
-            pinnedModel: "openai/gpt-5",
-          },
-          installedProviders: [{ providerId: "openai", installedAt: 1 }],
-        }) as any,
-      getSettings: async () =>
-        ({
-          modelSelection: {
-            mode: "pinned",
-            pinnedModel: "openai/gpt-5",
-          },
-          installedProviders: [{ providerId: "openai", installedAt: 1 }],
-        }) as any,
-    };
-
-    const resolved = await resolveAgentOptions(
-      "agent-1",
-      { model: "fallback-model" },
-      settingsStore as any
-    );
-
-    expect(resolved.model).toBe("openai/gpt-5");
-  });
-
-  test("uses primary provider preference in auto mode", async () => {
-    const settingsStore = {
-      getEffectiveSettings: async () =>
-        ({
-          modelSelection: {
-            mode: "auto",
-          },
-          installedProviders: [
-            { providerId: "chatgpt", installedAt: 1 },
-            { providerId: "claude", installedAt: 2 },
-          ],
-          providerModelPreferences: {
-            chatgpt: "chatgpt/gpt-5",
-            claude: "claude/sonnet",
-          },
-        }) as any,
-      getSettings: async () =>
-        ({
-          modelSelection: {
-            mode: "auto",
-          },
-          installedProviders: [
-            { providerId: "chatgpt", installedAt: 1 },
-            { providerId: "claude", installedAt: 2 },
-          ],
-          providerModelPreferences: {
-            chatgpt: "chatgpt/gpt-5",
-            claude: "claude/sonnet",
-          },
-        }) as any,
-    };
-
-    const resolved = await resolveAgentOptions(
-      "agent-1",
-      { model: "fallback-model" },
-      settingsStore as any
-    );
-
-    expect(resolved.model).toBe("chatgpt/gpt-5");
-  });
-
-  test("clears model in auto mode when providers exist but no preference", async () => {
-    const settingsStore = {
-      getEffectiveSettings: async () =>
-        ({
-          modelSelection: {
-            mode: "auto",
-          },
-          installedProviders: [{ providerId: "chatgpt", installedAt: 1 }],
-        }) as any,
-      getSettings: async () =>
-        ({
-          modelSelection: {
-            mode: "auto",
-          },
-          installedProviders: [{ providerId: "chatgpt", installedAt: 1 }],
-        }) as any,
-    };
-
-    const resolved = await resolveAgentOptions(
-      "agent-1",
-      { model: "fallback-model" },
-      settingsStore as any
-    );
-
-    expect(resolved.model).toBeUndefined();
-  });
-
-  test("normalizes legacy Owletto gateway URLs to the runtime K8s service", async () => {
-    process.env.DISPATCHER_SERVICE_NAME = "lobu-gateway";
-    process.env.KUBERNETES_NAMESPACE = "lobu";
-
-    const settingsStore = {
-      getEffectiveSettings: async () =>
-        ({
-          pluginsConfig: {
-            plugins: [
-              {
-                source: "@lobu/owletto-openclaw",
-                slot: "memory",
-                enabled: true,
-                config: {
-                  mcpUrl: "http://gateway:8080/mcp/owletto",
-                  gatewayAuthUrl: "http://gateway:8080",
-                },
-              },
-            ],
-          },
-        }) as any,
-    };
-
-    const resolved = await resolveAgentOptions(
-      "agent-1",
-      {},
-      settingsStore as any
-    );
-
-    expect(resolved.pluginsConfig).toEqual({
-      plugins: [
-        {
-          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",
-          },
-        },
-      ],
-    });
-  });
-
-  test("preserves custom Owletto endpoints", async () => {
-    process.env.DISPATCHER_SERVICE_NAME = "lobu-gateway";
-    process.env.KUBERNETES_NAMESPACE = "lobu";
-
-    const settingsStore = {
-      getEffectiveSettings: async () =>
-        ({
-          pluginsConfig: {
-            plugins: [
-              {
-                source: "@lobu/owletto-openclaw",
-                slot: "memory",
-                enabled: true,
-                config: {
-                  mcpUrl: "https://owletto.example.com/mcp",
-                  gatewayAuthUrl: "https://owletto.example.com",
-                },
-              },
-            ],
-          },
-        }) as any,
-    };
-
-    const resolved = await resolveAgentOptions(
-      "agent-1",
-      {},
-      settingsStore as any
-    );
-
-    expect(resolved.pluginsConfig).toEqual({
-      plugins: [
-        {
-          source: "@lobu/owletto-openclaw",
-          slot: "memory",
-          enabled: true,
-          config: {
-            mcpUrl: "https://owletto.example.com/mcp",
-            gatewayAuthUrl: "https://owletto.example.com",
-          },
-        },
-      ],
-    });
-  });
-});
-
-describe("hasConfiguredProvider", () => {
-  test("accepts inherited template credentials from effective settings", async () => {
-    const settingsStore = {
-      getEffectiveSettings: async () =>
-        ({
-          authProfiles: [
-            {
-              id: "profile-1",
-              provider: "z-ai",
-              credential: "secret",
-              authType: "api-key",
-              label: "z.ai",
-              model: "*",
-              createdAt: 1,
-            },
-          ],
-          installedProviders: [{ providerId: "z-ai", installedAt: 1 }],
-        }) as any,
-    };
-
-    await expect(
-      hasConfiguredProvider("telegram-6570514069", settingsStore as any)
-    ).resolves.toBe(true);
-  });
-});
-
-describe("resolveAgentId", () => {
-  test("uses deterministic id by default", async () => {
-    const resolved = await resolveAgentId({
-      platform: "telegram",
-      userId: "777",
-      channelId: "12345",
-      isGroup: false,
-    });
-
-    expect(resolved).toEqual({
-      agentId: "telegram-777",
-      promptSent: false,
-    });
-  });
-});