@lobu/gateway 3.0.9 → 3.0.12

package/src/__tests__/setup.ts

@@ -1,133 +0,0 @@
-/**
- * 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

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

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

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

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