@lobu/gateway 3.0.8 → 3.0.12

package/src/__tests__/system-skills-service.test.ts

@@ -1,362 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { SystemSkillsService } from "../services/system-skills-service";
-
-const testConfig = {
-  skills: [
-    {
-      id: "github",
-      name: "GitHub",
-      description: "GitHub integration",
-      mcpServers: [
-        {
-          id: "github-mcp",
-          name: "GitHub MCP",
-          url: "https://github-mcp.example.com",
-        },
-      ],
-      nixPackages: ["git"],
-      permissions: ["github.com", "api.github.com"],
-    },
-    {
-      id: "owletto",
-      name: "Owletto",
-      description: "Owletto embedded",
-      hidden: true,
-      mcpServers: [
-        { id: "owletto-mcp", url: "https://owletto.example.com/mcp" },
-      ],
-    },
-  ],
-};
-
-let fetchCallCount = 0;
-const originalFetch = globalThis.fetch;
-
-function setupMockFetch(config: unknown, statusCode = 200) {
-  fetchCallCount = 0;
-  globalThis.fetch = async () => {
-    fetchCallCount++;
-    return new Response(JSON.stringify(config), {
-      status: statusCode,
-      headers: { "Content-Type": "application/json" },
-    });
-  };
-}
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  fetchCallCount = 0;
-});
-
-describe("SystemSkillsService", () => {
-  test("loads config from HTTP URL and maps skills correctly", async () => {
-    setupMockFetch(testConfig);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const skills = await service.getSystemSkills();
-
-    expect(skills).toHaveLength(2);
-    expect(skills[0]).toEqual({
-      repo: "system/github",
-      name: "GitHub",
-      description: "GitHub integration",
-      enabled: true,
-      system: true,
-      mcpServers: [
-        {
-          id: "github-mcp",
-          name: "GitHub MCP",
-          url: "https://github-mcp.example.com",
-        },
-      ],
-      nixPackages: ["git"],
-      permissions: ["github.com", "api.github.com"],
-    });
-    expect(skills[1]).toEqual({
-      repo: "system/owletto",
-      name: "Owletto",
-      description: "Owletto embedded",
-      enabled: true,
-      system: true,
-      mcpServers: [
-        { id: "owletto-mcp", url: "https://owletto.example.com/mcp" },
-      ],
-      nixPackages: undefined,
-      permissions: undefined,
-    });
-  });
-
-  test("returns empty array when fetch fails", async () => {
-    setupMockFetch({ error: "not found" }, 500);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const skills = await service.getSystemSkills();
-    expect(skills).toEqual([]);
-  });
-
-  test("returns empty array when no configUrl is provided", async () => {
-    const service = new SystemSkillsService();
-    const skills = await service.getSystemSkills();
-    expect(skills).toEqual([]);
-  });
-
-  test("getSearchableSkills filters out hidden entries", async () => {
-    setupMockFetch(testConfig);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const skills = await service.getSearchableSkills();
-
-    expect(skills).toHaveLength(1);
-    expect(skills[0].repo).toBe("system/github");
-  });
-
-  test("getRawSystemSkills returns unsubstituted env patterns", async () => {
-    const envKey = `__TEST_SSS_KEY_${Date.now()}`;
-    process.env[envKey] = "secret123";
-    try {
-      const configWithEnv = {
-        skills: [
-          {
-            id: "test-skill",
-            name: "Test",
-            mcpServers: [
-              {
-                id: "test-mcp",
-                url: `https://api.example.com/\${env:${envKey}}`,
-              },
-            ],
-          },
-        ],
-      };
-      setupMockFetch(configWithEnv);
-      const service = new SystemSkillsService(
-        "https://example.com/skills.json"
-      );
-
-      const raw = await service.getRawSystemSkills();
-      expect(raw[0].mcpServers![0].url).toBe(
-        `https://api.example.com/\${env:${envKey}}`
-      );
-
-      const substituted = await service.getSystemSkills();
-      expect(substituted[0].mcpServers![0].url).toBe(
-        "https://api.example.com/secret123"
-      );
-    } finally {
-      delete process.env[envKey];
-    }
-  });
-
-  test("env substitution replaces ${env:VAR} with process.env value", async () => {
-    const envKey = `__TEST_SSS_API_${Date.now()}`;
-    process.env[envKey] = "my-api-key-value";
-    try {
-      const configWithEnv = {
-        skills: [
-          {
-            id: "env-skill",
-            name: "Env Skill",
-            mcpServers: [
-              {
-                id: "env-mcp",
-                url: `https://api.example.com/mcp?key=\${env:${envKey}}`,
-              },
-            ],
-          },
-        ],
-      };
-      setupMockFetch(configWithEnv);
-      const service = new SystemSkillsService(
-        "https://example.com/skills.json"
-      );
-      const skills = await service.getSystemSkills();
-      expect(skills[0].mcpServers![0].url).toBe(
-        "https://api.example.com/mcp?key=my-api-key-value"
-      );
-    } finally {
-      delete process.env[envKey];
-    }
-  });
-
-  test("unset env var is replaced with empty string", async () => {
-    const envKey = `__TEST_SSS_NONEXISTENT_${Date.now()}`;
-    delete process.env[envKey];
-    const configWithEnv = {
-      skills: [
-        {
-          id: "missing-env",
-          name: "Missing Env",
-          mcpServers: [
-            {
-              id: "missing-mcp",
-              url: `https://api.example.com/\${env:${envKey}}/path`,
-            },
-          ],
-        },
-      ],
-    };
-    setupMockFetch(configWithEnv);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const skills = await service.getSystemSkills();
-    expect(skills[0].mcpServers![0].url).toBe("https://api.example.com//path");
-  });
-
-  test("getProviderConfigs extracts providers by skill id", async () => {
-    const configWithProviders = {
-      skills: [
-        {
-          id: "groq",
-          name: "Groq",
-          providers: [
-            {
-              displayName: "Groq",
-              iconUrl: "https://example.com/groq.png",
-              envVarName: "GROQ_API_KEY",
-              upstreamBaseUrl: "https://api.groq.com/openai",
-              apiKeyInstructions: "Get key from groq.com",
-              apiKeyPlaceholder: "gsk_...",
-            },
-          ],
-        },
-        {
-          id: "no-providers",
-          name: "No Providers",
-        },
-      ],
-    };
-    setupMockFetch(configWithProviders);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const providers = await service.getProviderConfigs();
-
-    expect(Object.keys(providers)).toEqual(["groq"]);
-    expect(providers.groq.displayName).toBe("Groq");
-    expect(providers.groq.envVarName).toBe("GROQ_API_KEY");
-  });
-
-  test("reload clears cache and allows re-fetch", async () => {
-    setupMockFetch(testConfig);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-
-    const first = await service.getSystemSkills();
-    expect(first).toHaveLength(2);
-    expect(fetchCallCount).toBe(1);
-
-    const updatedConfig = {
-      skills: [{ id: "new-skill", name: "New Skill" }],
-    };
-    setupMockFetch(updatedConfig);
-    service.reload();
-
-    const second = await service.getSystemSkills();
-    expect(second).toHaveLength(1);
-    expect(second[0].repo).toBe("system/new-skill");
-    expect(fetchCallCount).toBe(1);
-  });
-
-  test("reload with new URL uses the new URL", async () => {
-    setupMockFetch(testConfig);
-    const service = new SystemSkillsService("https://example.com/old.json");
-    await service.getSystemSkills();
-
-    const newConfig = {
-      skills: [{ id: "from-new-url", name: "From New URL" }],
-    };
-    setupMockFetch(newConfig);
-    service.reload("https://example.com/new.json");
-
-    const skills = await service.getSystemSkills();
-    expect(skills).toHaveLength(1);
-    expect(skills[0].repo).toBe("system/from-new-url");
-  });
-
-  test("caches config and only fetches once", async () => {
-    setupMockFetch(testConfig);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-
-    await service.getSystemSkills();
-    await service.getSystemSkills();
-    await service.getSearchableSkills();
-    await service.getProviderConfigs();
-
-    expect(fetchCallCount).toBe(1);
-  });
-
-  test("getRuntimeSystemSkills returns runtime format with content", async () => {
-    setupMockFetch(testConfig);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const runtime = await service.getRuntimeSystemSkills();
-
-    expect(runtime).toHaveLength(2);
-    expect(runtime[0].id).toBe("github");
-    expect(runtime[0].repo).toBe("system/github");
-    expect(runtime[0].name).toBe("GitHub");
-    expect(runtime[0].description).toBe("GitHub integration");
-    expect(runtime[0].content).toContain("# GitHub");
-    expect(runtime[0].content).toContain("System skill ID: `system/github`");
-    expect(runtime[0].content).toContain("## MCP Servers");
-    expect(runtime[0].content).toContain("GitHub MCP (`github-mcp`)");
-    expect(runtime[0].content).toContain("## Network Permissions");
-    expect(runtime[0].content).toContain("github.com, api.github.com");
-    expect(runtime[0].content).toContain("## Nix Packages");
-    expect(runtime[0].content).toContain("git");
-  });
-
-  test("toSkillConfig passes instructions through", async () => {
-    const configWithInstructions = {
-      skills: [
-        {
-          id: "owletto",
-          name: "Owletto Memory",
-          description: "Long-term memory",
-          instructions: "Check memory at conversation start.",
-          hidden: true,
-          mcpServers: [
-            { id: "owletto-mcp", url: "https://owletto.example.com" },
-          ],
-        },
-        {
-          id: "github",
-          name: "GitHub",
-          description: "GitHub integration",
-        },
-      ],
-    };
-    setupMockFetch(configWithInstructions);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const skills = await service.getSystemSkills();
-
-    expect(skills[0].instructions).toBe("Check memory at conversation start.");
-    expect(skills[1].instructions).toBeUndefined();
-  });
-
-  test("getRuntimeSystemSkills includes instructions in content and metadata", async () => {
-    const configWithInstructions = {
-      skills: [
-        {
-          id: "owletto",
-          name: "Owletto Memory",
-          description: "Long-term memory",
-          instructions: "Check memory at conversation start.",
-          mcpServers: [
-            { id: "owletto-mcp", url: "https://owletto.example.com" },
-          ],
-        },
-      ],
-    };
-    setupMockFetch(configWithInstructions);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const runtime = await service.getRuntimeSystemSkills();
-
-    expect(runtime[0].instructions).toBe("Check memory at conversation start.");
-    expect(runtime[0].content).toContain(
-      "**Instructions:** Check memory at conversation start."
-    );
-    expect(runtime[0].content).toContain("Long-term memory");
-  });
-
-  test("getRuntimeSystemSkills without instructions omits instructions block", async () => {
-    setupMockFetch(testConfig);
-    const service = new SystemSkillsService("https://example.com/skills.json");
-    const runtime = await service.getRuntimeSystemSkills();
-
-    expect(runtime[0].instructions).toBeUndefined();
-    expect(runtime[0].content).not.toContain("**Instructions:**");
-  });
-});

package/src/__tests__/transcription-service.test.ts

@@ -1,222 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
-import { TranscriptionService } from "../services/transcription-service";
-
-describe("TranscriptionService provider fallback", () => {
-  afterEach(() => {
-    mock.restore();
-  });
-
-  test("falls back to next configured provider when first fails", async () => {
-    const authProfilesManager = {
-      getBestProfile: mock(async (_agentId: string, providerId: string) => {
-        if (providerId === "chatgpt") {
-          return { credential: "openai-key" };
-        }
-        if (providerId === "gemini") {
-          return { credential: "gemini-key" };
-        }
-        return null;
-      }),
-    } as any;
-
-    const service = new TranscriptionService(authProfilesManager);
-    const transcribeWithProvider = mock(
-      async (_buffer: Buffer, config: any) => {
-        if (config.provider === "openai") {
-          throw new Error("openai unauthorized");
-        }
-        return "hello from gemini";
-      }
-    );
-    (service as any).transcribeWithProvider = transcribeWithProvider;
-
-    const result = await service.transcribe(
-      Buffer.from("audio"),
-      "agent-1",
-      "audio/ogg"
-    );
-
-    expect(transcribeWithProvider).toHaveBeenCalledTimes(2);
-    expect("text" in result).toBe(true);
-    if ("text" in result) {
-      expect(result.text).toBe("hello from gemini");
-      expect(result.provider).toBe("gemini");
-    }
-  });
-
-  test("returns no-provider error when no auth profiles exist", async () => {
-    const authProfilesManager = {
-      getBestProfile: mock(async () => null),
-    } as any;
-    const service = new TranscriptionService(authProfilesManager);
-
-    const result = await service.transcribe(
-      Buffer.from("audio"),
-      "agent-2",
-      "audio/ogg"
-    );
-
-    expect("error" in result).toBe(true);
-    if ("error" in result) {
-      expect(result.error).toContain("No transcription provider configured");
-    }
-  });
-
-  test("uses config-driven OpenAI-compatible STT provider", async () => {
-    const authProfilesManager = {
-      getBestProfile: mock(async (_agentId: string, providerId: string) => {
-        if (providerId === "openrouter") {
-          return { credential: "or-key" };
-        }
-        return null;
-      }),
-    } as any;
-
-    const providerConfigSource = mock(async () => ({
-      openrouter: {
-        displayName: "OpenRouter",
-        iconUrl: "https://example.com/icon.png",
-        envVarName: "OPENROUTER_API_KEY",
-        upstreamBaseUrl: "https://openrouter.ai/api/v1",
-        apiKeyInstructions: "x",
-        apiKeyPlaceholder: "x",
-        sdkCompat: "openai",
-        stt: {
-          enabled: true,
-          transcriptionPath: "/audio/transcriptions",
-          model: "gpt-4o-mini-transcribe",
-        },
-      },
-    }));
-
-    const service = new TranscriptionService(
-      authProfilesManager,
-      providerConfigSource
-    );
-
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = mock(
-      async (input: RequestInfo | URL, init?: RequestInit) => {
-        const url = String(input);
-        expect(url).toBe("https://openrouter.ai/api/v1/audio/transcriptions");
-        expect((init?.headers as Record<string, string>)?.Authorization).toBe(
-          "Bearer or-key"
-        );
-        return new Response(JSON.stringify({ text: "hello from openrouter" }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-    ) as any;
-
-    try {
-      const result = await service.transcribe(
-        Buffer.from("audio"),
-        "agent-3",
-        "audio/ogg"
-      );
-      expect("text" in result).toBe(true);
-      if ("text" in result) {
-        expect(result.text).toBe("hello from openrouter");
-        expect(result.provider).toBe("openai");
-      }
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("uses sdkCompat openai STT by default when stt block is missing", async () => {
-    const authProfilesManager = {
-      getBestProfile: mock(async (_agentId: string, providerId: string) => {
-        if (providerId === "openrouter") {
-          return { credential: "or-key" };
-        }
-        return null;
-      }),
-    } as any;
-
-    const providerConfigSource = mock(async () => ({
-      openrouter: {
-        displayName: "OpenRouter",
-        iconUrl: "https://example.com/icon.png",
-        envVarName: "OPENROUTER_API_KEY",
-        upstreamBaseUrl: "https://openrouter.ai/api/v1",
-        apiKeyInstructions: "x",
-        apiKeyPlaceholder: "x",
-        sdkCompat: "openai",
-      },
-    }));
-
-    const service = new TranscriptionService(
-      authProfilesManager,
-      providerConfigSource
-    );
-
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
-      const url = String(input);
-      expect(url).toBe("https://openrouter.ai/api/v1/audio/transcriptions");
-      return new Response(JSON.stringify({ text: "default stt works" }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as any;
-
-    try {
-      const result = await service.transcribe(
-        Buffer.from("audio"),
-        "agent-4",
-        "audio/ogg"
-      );
-      expect("text" in result).toBe(true);
-      if ("text" in result) {
-        expect(result.text).toBe("default stt works");
-        expect(result.provider).toBe("openai");
-      }
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("respects stt.enabled=false for config-driven providers", async () => {
-    const authProfilesManager = {
-      getBestProfile: mock(async (_agentId: string, providerId: string) => {
-        if (providerId === "openrouter") {
-          return { credential: "or-key" };
-        }
-        return null;
-      }),
-    } as any;
-
-    const providerConfigSource = mock(async () => ({
-      openrouter: {
-        displayName: "OpenRouter",
-        iconUrl: "https://example.com/icon.png",
-        envVarName: "OPENROUTER_API_KEY",
-        upstreamBaseUrl: "https://openrouter.ai/api/v1",
-        apiKeyInstructions: "x",
-        apiKeyPlaceholder: "x",
-        sdkCompat: "openai",
-        stt: {
-          enabled: false,
-        },
-      },
-    }));
-
-    const service = new TranscriptionService(
-      authProfilesManager,
-      providerConfigSource
-    );
-
-    const result = await service.transcribe(
-      Buffer.from("audio"),
-      "agent-5",
-      "audio/ogg"
-    );
-
-    expect("error" in result).toBe(true);
-    if ("error" in result) {
-      expect(result.error).toContain("No transcription provider configured");
-    }
-  });
-});

package/src/__tests__/utils/rate-limiter.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { MockRedisClient } from "../../../../core/src/__tests__/fixtures/mock-redis";
-import {
-  getClientIp,
-  RedisFixedWindowRateLimiter,
-} from "../../utils/rate-limiter";
-
-describe("RedisFixedWindowRateLimiter", () => {
-  test("allows requests within the window and blocks after the limit", async () => {
-    const redis = new MockRedisClient();
-    const limiter = new RedisFixedWindowRateLimiter(redis);
-
-    const first = await limiter.consume({
-      key: "rate:test:1",
-      limit: 2,
-      windowSeconds: 60,
-    });
-    const second = await limiter.consume({
-      key: "rate:test:1",
-      limit: 2,
-      windowSeconds: 60,
-    });
-    const third = await limiter.consume({
-      key: "rate:test:1",
-      limit: 2,
-      windowSeconds: 60,
-    });
-
-    expect(first.allowed).toBe(true);
-    expect(first.remaining).toBe(1);
-    expect(second.allowed).toBe(true);
-    expect(second.remaining).toBe(0);
-    expect(third.allowed).toBe(false);
-    expect(third.retryAfterSeconds).toBeGreaterThan(0);
-  });
-
-  test("resets after the time window", async () => {
-    const redis = new MockRedisClient();
-    const limiter = new RedisFixedWindowRateLimiter(redis);
-
-    await limiter.consume({
-      key: "rate:test:2",
-      limit: 1,
-      windowSeconds: 60,
-    });
-    const blocked = await limiter.consume({
-      key: "rate:test:2",
-      limit: 1,
-      windowSeconds: 60,
-    });
-    expect(blocked.allowed).toBe(false);
-
-    redis.advanceTime(61_000);
-
-    const reset = await limiter.consume({
-      key: "rate:test:2",
-      limit: 1,
-      windowSeconds: 60,
-    });
-    expect(reset.allowed).toBe(true);
-    expect(reset.count).toBe(1);
-  });
-
-  test("reset clears the tracked key", async () => {
-    const redis = new MockRedisClient();
-    const limiter = new RedisFixedWindowRateLimiter(redis);
-
-    await limiter.consume({
-      key: "rate:test:3",
-      limit: 1,
-      windowSeconds: 60,
-    });
-    await limiter.reset("rate:test:3");
-
-    const next = await limiter.consume({
-      key: "rate:test:3",
-      limit: 1,
-      windowSeconds: 60,
-    });
-    expect(next.allowed).toBe(true);
-    expect(next.count).toBe(1);
-  });
-});
-
-describe("getClientIp", () => {
-  test("prefers x-forwarded-for, then x-real-ip, then unknown", () => {
-    expect(
-      getClientIp({
-        forwardedFor: "203.0.113.1, 10.0.0.1",
-        realIp: "198.51.100.1",
-      })
-    ).toBe("203.0.113.1");
-
-    expect(
-      getClientIp({
-        realIp: "198.51.100.1",
-      })
-    ).toBe("198.51.100.1");
-
-    expect(getClientIp({})).toBe("unknown");
-  });
-});