@lobu/gateway 3.0.5 → 3.0.6

package/src/__tests__/setup.ts

@@ -0,0 +1,133 @@
+/**
+ * Test setup and utilities for Gateway tests.
+ *
+ * Shared mocks (Redis, Queue, fetch, factories) live in @lobu/core fixtures.
+ * This file re-exports them and adds gateway-specific helpers.
+ */
+
+import { createMockJob as _createMockJob } from "@lobu/core/testing";
+
+export {
+  createInstructionContext,
+  createMockJob,
+  createWorkerConfig,
+  MockMessageQueue,
+  MockRedisClient,
+  mockFetch,
+} from "@lobu/core/testing";
+
+/**
+ * Mock Express Response for SSE testing (gateway-specific)
+ */
+export class MockResponse {
+  private _ended = false;
+  private _written: string[] = [];
+  private _closeCallbacks: (() => void)[] = [];
+
+  write(chunk: string): boolean {
+    if (this._ended) {
+      throw new Error("Cannot write to ended response");
+    }
+    this._written.push(chunk);
+    return true;
+  }
+
+  end(): void {
+    this._ended = true;
+  }
+
+  onClose(callback: () => void): void {
+    this._closeCallbacks.push(callback);
+  }
+
+  simulateClose(): void {
+    for (const cb of this._closeCallbacks) cb();
+  }
+
+  isEnded(): boolean {
+    return this._ended;
+  }
+
+  getWritten(): string[] {
+    return this._written;
+  }
+
+  getLastWrite(): string | undefined {
+    return this._written[this._written.length - 1];
+  }
+
+  getAllWrites(): string {
+    return this._written.join("");
+  }
+
+  clearWrites(): void {
+    this._written = [];
+  }
+}
+
+/**
+ * Test utilities
+ */
+export class TestHelpers {
+  static createMockJob(overrides: any = {}): any {
+    return _createMockJob(overrides);
+  }
+
+  static async delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  static parseSSE(sse: string): { event: string; data: any }[] {
+    const events: { event: string; data: any }[] = [];
+    const lines = sse.split("\n");
+
+    let currentEvent = "";
+    let currentData = "";
+
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        currentEvent = line.substring(6).trim();
+      } else if (line.startsWith("data:")) {
+        currentData = line.substring(5).trim();
+      } else if (line === "") {
+        if (currentEvent && currentData) {
+          try {
+            events.push({
+              event: currentEvent,
+              data: JSON.parse(currentData),
+            });
+          } catch {
+            events.push({
+              event: currentEvent,
+              data: currentData,
+            });
+          }
+          currentEvent = "";
+          currentData = "";
+        }
+      }
+    }
+
+    return events;
+  }
+}
+
+/**
+ * Mock environment variables
+ */
+const mockEnvVars = {
+  WORKER_STALE_TIMEOUT_MINUTES: "10",
+  PUBLIC_GATEWAY_URL: "https://test-gateway.example.com",
+};
+
+export function setupTestEnv(): void {
+  for (const [key, value] of Object.entries(mockEnvVars)) {
+    process.env[key] = value;
+  }
+}
+
+export function cleanupTestEnv(): void {
+  for (const key of Object.keys(mockEnvVars)) {
+    delete process.env[key];
+  }
+}

package/src/__tests__/skill-and-mcp-registry.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, test } from "bun:test";
+import { McpRegistryService } from "../services/mcp-registry";
+import type { SystemConfigResolver } from "../services/system-config-resolver";
+
+// --- McpRegistryService ---
+
+function createMockResolver(
+  entries: Array<{
+    id: string;
+    name: string;
+    description: string;
+    type: "oauth" | "stdio" | "sse" | "api-key";
+    config: Record<string, unknown>;
+  }>
+) {
+  return {
+    getMcpRegistryServers: async () => entries,
+  } as unknown as SystemConfigResolver;
+}
+
+const mcpEntries = [
+  {
+    id: "github",
+    name: "GitHub",
+    description: "GitHub integration",
+    type: "stdio" as const,
+    config: { type: "stdio" },
+  },
+  {
+    id: "sentry",
+    name: "Sentry",
+    description: "Error tracking",
+    type: "sse" as const,
+    config: { type: "sse" },
+  },
+  {
+    id: "playwright",
+    name: "Playwright",
+    description: "Browser automation",
+    type: "stdio" as const,
+    config: {},
+  },
+  {
+    id: "notion",
+    name: "Notion",
+    description: "Notion workspace",
+    type: "oauth" as const,
+    config: {},
+  },
+  {
+    id: "linear",
+    name: "Linear",
+    description: "Issue tracker",
+    type: "api-key" as const,
+    config: {},
+  },
+  {
+    id: "slack",
+    name: "Slack",
+    description: "Slack messaging",
+    type: "oauth" as const,
+    config: {},
+  },
+  {
+    id: "jira",
+    name: "Jira",
+    description: "Project management",
+    type: "api-key" as const,
+    config: {},
+  },
+];
+
+describe("McpRegistryService", () => {
+  test("getCurated returns entries matching curated IDs", async () => {
+    const service = new McpRegistryService(createMockResolver(mcpEntries));
+    const curated = await service.getCurated();
+
+    const ids = curated.map((e) => e.id);
+    for (const curatedId of McpRegistryService.CURATED_MCP_IDS) {
+      expect(ids).toContain(curatedId);
+    }
+    expect(curated).toHaveLength(5);
+  });
+
+  test("getCurated falls back to first 5 when no curated IDs match", async () => {
+    const noCuratedEntries = [
+      {
+        id: "custom1",
+        name: "Custom 1",
+        description: "Desc",
+        type: "sse" as const,
+        config: {},
+      },
+      {
+        id: "custom2",
+        name: "Custom 2",
+        description: "Desc",
+        type: "sse" as const,
+        config: {},
+      },
+      {
+        id: "custom3",
+        name: "Custom 3",
+        description: "Desc",
+        type: "sse" as const,
+        config: {},
+      },
+      {
+        id: "custom4",
+        name: "Custom 4",
+        description: "Desc",
+        type: "sse" as const,
+        config: {},
+      },
+      {
+        id: "custom5",
+        name: "Custom 5",
+        description: "Desc",
+        type: "sse" as const,
+        config: {},
+      },
+      {
+        id: "custom6",
+        name: "Custom 6",
+        description: "Desc",
+        type: "sse" as const,
+        config: {},
+      },
+    ];
+    const service = new McpRegistryService(
+      createMockResolver(noCuratedEntries)
+    );
+    const curated = await service.getCurated();
+
+    expect(curated).toHaveLength(5);
+    expect(curated.map((e) => e.id)).toEqual([
+      "custom1",
+      "custom2",
+      "custom3",
+      "custom4",
+      "custom5",
+    ]);
+  });
+
+  test("search matches by name, description, and id", async () => {
+    const service = new McpRegistryService(createMockResolver(mcpEntries));
+
+    const byName = await service.search("GitHub");
+    expect(byName.some((e) => e.id === "github")).toBe(true);
+
+    const byDesc = await service.search("Browser automation");
+    expect(byDesc.some((e) => e.id === "playwright")).toBe(true);
+
+    const byId = await service.search("linear");
+    expect(byId.some((e) => e.id === "linear")).toBe(true);
+  });
+
+  test("search respects limit", async () => {
+    const service = new McpRegistryService(createMockResolver(mcpEntries));
+    // "a" appears in many names/descriptions
+    const results = await service.search("a", 2);
+    expect(results.length).toBeLessThanOrEqual(2);
+  });
+
+  test("search with empty query returns all up to limit", async () => {
+    const service = new McpRegistryService(createMockResolver(mcpEntries));
+
+    const results = await service.search("", 3);
+    expect(results).toHaveLength(3);
+
+    const allResults = await service.search("");
+    expect(allResults).toHaveLength(mcpEntries.length);
+  });
+
+  test("getAll returns complete list", async () => {
+    const service = new McpRegistryService(createMockResolver(mcpEntries));
+    const all = await service.getAll();
+    expect(all).toHaveLength(mcpEntries.length);
+  });
+
+  test("getById returns specific entry", async () => {
+    const service = new McpRegistryService(createMockResolver(mcpEntries));
+
+    const entry = await service.getById("sentry");
+    expect(entry).not.toBeNull();
+    expect(entry!.name).toBe("Sentry");
+  });
+
+  test("getById returns null for unknown id", async () => {
+    const service = new McpRegistryService(createMockResolver(mcpEntries));
+    const entry = await service.getById("nonexistent");
+    expect(entry).toBeNull();
+  });
+
+  test("no resolver returns empty results", async () => {
+    const service = new McpRegistryService();
+
+    expect(await service.getCurated()).toEqual([]);
+    expect(await service.search("github")).toEqual([]);
+    expect(await service.getAll()).toEqual([]);
+    expect(await service.getById("github")).toBeNull();
+  });
+});

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

@@ -0,0 +1,161 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { createSlackRoutes } from "../routes/public/slack";
+
+class RouteRedisMock {
+  private store = new Map<string, string>();
+
+  async setex(key: string, _ttlSeconds: number, value: string): Promise<void> {
+    this.store.set(key, value);
+  }
+
+  async get(key: string): Promise<string | null> {
+    return this.store.get(key) ?? null;
+  }
+
+  async getdel(key: string): Promise<string | null> {
+    const value = this.store.get(key) ?? null;
+    this.store.delete(key);
+    return value;
+  }
+
+  async del(...keys: string[]): Promise<number> {
+    let removed = 0;
+    for (const key of keys) {
+      if (this.store.delete(key)) {
+        removed++;
+      }
+    }
+    return removed;
+  }
+}
+
+describe("slack routes", () => {
+  const originalClientId = process.env.SLACK_CLIENT_ID;
+  const originalScopes = process.env.SLACK_OAUTH_SCOPES;
+
+  let redis: RouteRedisMock;
+  let completeSlackOAuthInstall: ReturnType<typeof mock>;
+  let handleSlackAppWebhook: ReturnType<typeof mock>;
+  let router: ReturnType<typeof createSlackRoutes>;
+
+  beforeEach(() => {
+    process.env.SLACK_CLIENT_ID = "client-123";
+    process.env.SLACK_OAUTH_SCOPES = "chat:write,commands";
+
+    redis = new RouteRedisMock();
+    completeSlackOAuthInstall = mock(async () => ({
+      teamId: "T123",
+      teamName: "Acme",
+      connectionId: "conn-1",
+    }));
+    handleSlackAppWebhook = mock(async (request: Request) => {
+      const body = await request.text();
+      return new Response(`handled:${body}`);
+    });
+
+    router = createSlackRoutes({
+      getServices: () => ({
+        getQueue: () => ({
+          getRedisClient: () => redis,
+        }),
+        getPublicGatewayUrl: () => "https://gateway.example.com",
+      }),
+      completeSlackOAuthInstall,
+      handleSlackAppWebhook,
+    } as any);
+  });
+
+  afterEach(() => {
+    if (originalClientId === undefined) {
+      delete process.env.SLACK_CLIENT_ID;
+    } else {
+      process.env.SLACK_CLIENT_ID = originalClientId;
+    }
+
+    if (originalScopes === undefined) {
+      delete process.env.SLACK_OAUTH_SCOPES;
+    } else {
+      process.env.SLACK_OAUTH_SCOPES = originalScopes;
+    }
+  });
+
+  test("GET /slack/install redirects to Slack OAuth and stores state", async () => {
+    const response = await router.request("/slack/install");
+
+    expect(response.status).toBe(302);
+
+    const location = response.headers.get("location");
+    expect(location).toBeTruthy();
+
+    const redirectUrl = new URL(location!);
+    expect(redirectUrl.origin).toBe("https://slack.com");
+    expect(redirectUrl.pathname).toBe("/oauth/v2/authorize");
+    expect(redirectUrl.searchParams.get("client_id")).toBe("client-123");
+    expect(redirectUrl.searchParams.get("scope")).toBe("chat:write,commands");
+    expect(redirectUrl.searchParams.get("redirect_uri")).toBe(
+      "https://gateway.example.com/slack/oauth_callback"
+    );
+
+    const state = redirectUrl.searchParams.get("state");
+    expect(state).toBeTruthy();
+
+    const rawState = await redis.get(`slack:oauth:state:${state}`);
+    expect(rawState).toBeTruthy();
+    expect(JSON.parse(rawState!)).toEqual({
+      createdAt: expect.any(Number),
+      redirectUri: "https://gateway.example.com/slack/oauth_callback",
+    });
+  });
+
+  test("GET /slack/oauth_callback rejects invalid state", async () => {
+    const response = await router.request(
+      "/slack/oauth_callback?code=test-code&state=missing"
+    );
+    const body = await response.text();
+
+    expect(response.status).toBe(400);
+    expect(body).toContain("Authentication Failed");
+    expect(body).toContain("invalid or has expired");
+    expect(completeSlackOAuthInstall).not.toHaveBeenCalled();
+  });
+
+  test("GET /slack/oauth_callback completes install and clears state", async () => {
+    await redis.setex(
+      "slack:oauth:state:test-state",
+      600,
+      JSON.stringify({
+        createdAt: Date.now(),
+        redirectUri: "https://gateway.example.com/slack/oauth_callback",
+      })
+    );
+
+    const response = await router.request(
+      "/slack/oauth_callback?code=test-code&state=test-state"
+    );
+    const body = await response.text();
+
+    expect(response.status).toBe(200);
+    expect(body).toContain("Slack installed");
+    expect(body).toContain("Workspace connected to Lobu:");
+    expect(body).toContain("Connection ID: conn-1");
+    expect(completeSlackOAuthInstall).toHaveBeenCalledTimes(1);
+    expect(completeSlackOAuthInstall.mock.calls[0]?.[1]).toBe(
+      "https://gateway.example.com/slack/oauth_callback"
+    );
+    expect(await redis.get("slack:oauth:state:test-state")).toBeNull();
+  });
+
+  test("POST /slack/events forwards requests to the chat manager", async () => {
+    const response = await router.request("/slack/events", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ team_id: "T123", type: "event_callback" }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(await response.text()).toContain("handled:");
+    expect(handleSlackAppWebhook).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/system-config-resolver.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+import type { ProviderConfigEntry, SkillConfig } from "@lobu/core";
+import { SystemConfigResolver } from "../services/system-config-resolver";
+
+class MockSystemSkillsService {
+  constructor(
+    private readonly providers: Record<string, ProviderConfigEntry>,
+    private readonly skills: SkillConfig[]
+  ) {}
+
+  async getProviderConfigs(): Promise<Record<string, ProviderConfigEntry>> {
+    return this.providers;
+  }
+
+  async getSystemSkills(): Promise<SkillConfig[]> {
+    return this.skills;
+  }
+}
+
+describe("SystemConfigResolver MCP and provider resolution", () => {
+  test("builds global MCP server map and registry entries from system skills", async () => {
+    const resolver = new SystemConfigResolver(
+      new MockSystemSkillsService(
+        {
+          groq: {
+            displayName: "Groq",
+            iconUrl: "https://example.com/groq.png",
+            envVarName: "GROQ_API_KEY",
+            upstreamBaseUrl: "https://api.groq.com/openai",
+            apiKeyInstructions: "Get key",
+            apiKeyPlaceholder: "gsk_...",
+          },
+        },
+        [
+          {
+            repo: "system/owletto",
+            name: "Owletto",
+            enabled: true,
+            description: "Memory MCP",
+            mcpServers: [
+              {
+                id: "owletto",
+                name: "Owletto",
+                url: "https://owletto.com/mcp",
+              },
+              { id: "local-tool", command: "mcp-local", args: ["--stdio"] },
+            ],
+          } as SkillConfig,
+        ]
+      ) as any
+    );
+
+    const globalMcp = await resolver.getGlobalMcpServers();
+    const registryEntries = await resolver.getMcpRegistryServers();
+    const providers = await resolver.getProviderConfigs();
+
+    expect(globalMcp.owletto).toEqual({
+      type: "sse",
+      url: "https://owletto.com/mcp",
+    });
+    expect(globalMcp["local-tool"]).toEqual({
+      type: "stdio",
+      command: "mcp-local",
+      args: ["--stdio"],
+    });
+
+    expect(registryEntries.map((entry) => entry.id)).toEqual([
+      "owletto",
+      "local-tool",
+    ]);
+    expect(registryEntries[1]?.type).toBe("stdio");
+
+    expect(Object.keys(providers)).toEqual(["groq"]);
+  });
+});

package/src/__tests__/system-message-limiter.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import { MockRedisClient } from "@lobu/core/testing";
+import { SystemMessageLimiter } from "../infrastructure/redis/system-message-limiter";
+
+describe("SystemMessageLimiter", () => {
+  test("sends once and suppresses subsequent sends within TTL", async () => {
+    const redis = new MockRedisClient() as any;
+    const limiter = new SystemMessageLimiter(redis, "test");
+
+    let sentCount = 0;
+    const sendFn = async () => {
+      sentCount += 1;
+    };
+
+    const first = await limiter.sendOnce("k", sendFn, {
+      sentTtlSeconds: 60,
+      lockTtlSeconds: 30,
+    });
+    const second = await limiter.sendOnce("k", sendFn, {
+      sentTtlSeconds: 60,
+      lockTtlSeconds: 30,
+    });
+
+    expect(first).toBe(true);
+    expect(second).toBe(false);
+    expect(sentCount).toBe(1);
+  });
+
+  test("suppresses concurrent sends using lock even before sent marker is written", async () => {
+    const redis = new MockRedisClient() as any;
+    const limiter = new SystemMessageLimiter(redis, "test");
+
+    let release!: () => void;
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+
+    let started = 0;
+    const sendFn = async () => {
+      started += 1;
+      await gate;
+    };
+
+    const p1 = limiter.sendOnce("k2", sendFn, {
+      sentTtlSeconds: 60,
+      lockTtlSeconds: 30,
+    });
+    const p2 = limiter.sendOnce("k2", sendFn, {
+      sentTtlSeconds: 60,
+      lockTtlSeconds: 30,
+    });
+
+    // Ensure both have attempted to run; only one should have entered sendFn.
+    await new Promise((r) => setTimeout(r, 0));
+    expect(started).toBe(1);
+
+    release();
+    const [r1, r2] = await Promise.all([p1, p2]);
+    expect([r1, r2].filter(Boolean).length).toBe(1);
+  });
+
+  test("does not set sent marker on failure (allows retry)", async () => {
+    const redis = new MockRedisClient() as any;
+    const limiter = new SystemMessageLimiter(redis, "test");
+
+    let attempts = 0;
+    const sendFn = async () => {
+      attempts += 1;
+      throw new Error("fail");
+    };
+
+    await expect(
+      limiter.sendOnce("k3", sendFn, {
+        sentTtlSeconds: 60,
+        lockTtlSeconds: 30,
+      })
+    ).rejects.toThrow("fail");
+
+    // Next call should try again (not suppressed).
+    await expect(
+      limiter.sendOnce("k3", sendFn, {
+        sentTtlSeconds: 60,
+        lockTtlSeconds: 30,
+      })
+    ).rejects.toThrow("fail");
+
+    expect(attempts).toBe(2);
+  });
+});