@lobu/gateway 3.0.5 → 3.0.7

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

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

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

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

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