@lobu/gateway 2.8.0 → 3.0.6

package/src/__tests__/config-memory-plugins.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { buildMemoryPlugins } from "../config";
+
+const originalMemoryUrl = process.env.MEMORY_URL;
+const originalDispatcherServiceName = process.env.DISPATCHER_SERVICE_NAME;
+const originalKubernetesNamespace = process.env.KUBERNETES_NAMESPACE;
+
+afterEach(() => {
+  if (originalMemoryUrl === undefined) {
+    delete process.env.MEMORY_URL;
+  } else {
+    process.env.MEMORY_URL = originalMemoryUrl;
+  }
+
+  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("buildMemoryPlugins", () => {
+  test("returns native memory when MEMORY_URL is unset and plugin exists", () => {
+    delete process.env.MEMORY_URL;
+
+    expect(buildMemoryPlugins({ hasNativeMemoryPlugin: true })).toEqual([
+      {
+        source: "@openclaw/native-memory",
+        slot: "memory",
+        enabled: true,
+      },
+    ]);
+  });
+
+  test("returns no plugin when MEMORY_URL is unset and native memory is unavailable", () => {
+    delete process.env.MEMORY_URL;
+
+    expect(buildMemoryPlugins({ hasNativeMemoryPlugin: false })).toEqual([]);
+  });
+
+  test("falls back to native memory when Owletto plugin is unavailable", () => {
+    process.env.MEMORY_URL = "https://memory.example.com";
+
+    expect(
+      buildMemoryPlugins({
+        hasOwlettoPlugin: false,
+        hasNativeMemoryPlugin: true,
+      })
+    ).toEqual([
+      {
+        source: "@openclaw/native-memory",
+        slot: "memory",
+        enabled: true,
+      },
+    ]);
+  });
+
+  test("returns no plugin when neither Owletto nor native memory plugin exists", () => {
+    process.env.MEMORY_URL = "https://memory.example.com";
+
+    expect(
+      buildMemoryPlugins({
+        hasOwlettoPlugin: false,
+        hasNativeMemoryPlugin: false,
+      })
+    ).toEqual([]);
+  });
+
+  test("uses Owletto plugin when installed and MEMORY_URL is set", () => {
+    process.env.MEMORY_URL = "https://memory.example.com";
+    process.env.DISPATCHER_SERVICE_NAME = "lobu-gateway";
+    process.env.KUBERNETES_NAMESPACE = "lobu";
+
+    expect(buildMemoryPlugins({ hasOwlettoPlugin: true })).toEqual([
+      {
+        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",
+        },
+      },
+    ]);
+  });
+});

package/src/__tests__/config-request-store.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, mock, test } from "bun:test";
+import {
+  applyPendingConfigRequest,
+  buildConfigRequestText,
+} from "../interactions/config-request-store";
+
+describe("config-request-store", () => {
+  test("applies skills, mcps, nix packages, and grants", async () => {
+    const updateSettings = mock(() => Promise.resolve());
+    const grant = mock(() => Promise.resolve());
+    const agentSettingsStore = {
+      getSettings: mock(() =>
+        Promise.resolve({
+          nixConfig: { packages: ["git"] },
+          skillsConfig: {
+            skills: [
+              {
+                repo: "existing-skill",
+                name: "Existing Skill",
+                description: "Existing",
+                enabled: false,
+              },
+            ],
+          },
+          mcpServers: {
+            existing: { enabled: true, url: "https://existing.example.com" },
+          },
+        })
+      ),
+      updateSettings,
+    };
+    const grantStore = { grant };
+
+    await applyPendingConfigRequest(
+      agentSettingsStore as any,
+      grantStore as any,
+      {
+        agentId: "agent-1",
+        reason: "Install requested skill",
+        skills: [
+          {
+            repo: "existing-skill",
+            name: "Existing Skill",
+            description: "Updated",
+          },
+          {
+            repo: "new-skill",
+            name: "New Skill",
+            description: "New",
+          },
+        ],
+        mcpServers: [
+          {
+            id: "new-mcp",
+            name: "New MCP",
+            url: "https://mcp.example.com",
+            type: "sse",
+          },
+        ],
+        nixPackages: ["git", "ffmpeg"],
+        grants: ["api.example.com"],
+      }
+    );
+
+    expect(updateSettings).toHaveBeenCalledTimes(1);
+    const [, updates] = updateSettings.mock.calls[0]!;
+    expect(updates.skillsConfig.skills).toHaveLength(2);
+    expect(
+      updates.skillsConfig.skills.find(
+        (skill: any) => skill.repo === "existing-skill"
+      ).enabled
+    ).toBe(true);
+    expect(
+      updates.skillsConfig.skills.find(
+        (skill: any) => skill.repo === "new-skill"
+      ).name
+    ).toBe("New Skill");
+    expect(updates.mcpServers["new-mcp"]).toMatchObject({
+      enabled: true,
+      url: "https://mcp.example.com",
+      type: "sse",
+    });
+    expect(updates.nixConfig.packages).toEqual(["git", "ffmpeg"]);
+    expect(grant).toHaveBeenCalledWith("agent-1", "api.example.com", null);
+  });
+
+  test("skips settings writes when a request only grants permissions", async () => {
+    const updateSettings = mock(() => Promise.resolve());
+    const grant = mock(() => Promise.resolve());
+    const agentSettingsStore = {
+      getSettings: mock(() => Promise.resolve({})),
+      updateSettings,
+    };
+    const grantStore = { grant };
+
+    await applyPendingConfigRequest(
+      agentSettingsStore as any,
+      grantStore as any,
+      {
+        agentId: "agent-1",
+        reason: "Allow API access",
+        grants: ["api.example.com"],
+      }
+    );
+
+    expect(updateSettings).not.toHaveBeenCalled();
+    expect(grant).toHaveBeenCalledWith("agent-1", "api.example.com", null);
+  });
+
+  test("builds readable config request text", () => {
+    const text = buildConfigRequestText({
+      agentId: "agent-1",
+      reason: "Install skill",
+      message: "Needed for triage",
+      skills: [{ repo: "ops-triage", name: "Ops Triage" }],
+      nixPackages: ["ffmpeg"],
+      grants: ["api.example.com"],
+      providers: ["openai"],
+    });
+
+    expect(text).toContain("Configuration Change Request");
+    expect(text).toContain("Ops Triage");
+    expect(text).toContain("ffmpeg");
+    expect(text).toContain("api.example.com");
+    expect(text).toContain("openai");
+  });
+});

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

@@ -0,0 +1,144 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { MockRedisClient } from "@lobu/core/testing";
+import { AgentMetadataStore } from "../auth/agent-metadata-store";
+import { UserAgentsStore } from "../auth/user-agents-store";
+import { createConnectionCrudRoutes } from "../routes/public/connections";
+import { setAuthProvider } from "../routes/public/settings-auth";
+
+describe("connection routes", () => {
+  let redis: MockRedisClient;
+  let agentMetadataStore: AgentMetadataStore;
+  let userAgentsStore: UserAgentsStore;
+
+  beforeEach(async () => {
+    redis = new MockRedisClient();
+    agentMetadataStore = new AgentMetadataStore(redis as any);
+    userAgentsStore = new UserAgentsStore(redis as any);
+
+    await agentMetadataStore.createAgent(
+      "agent-1",
+      "Agent 1",
+      "telegram",
+      "u1"
+    );
+    await agentMetadataStore.createAgent(
+      "sandbox-1",
+      "Sandbox 1",
+      "telegram",
+      "u1",
+      {
+        parentConnectionId: "conn-1",
+      }
+    );
+    await userAgentsStore.addAgent("telegram", "u1", "agent-1");
+  });
+
+  afterEach(() => {
+    setAuthProvider(null);
+  });
+
+  function buildApp() {
+    return createConnectionCrudRoutes(
+      {
+        async listConnections(filters?: any) {
+          const connection = {
+            id: "conn-1",
+            platform: "telegram",
+            templateAgentId: "agent-1",
+            config: { platform: "telegram" },
+            settings: {},
+            metadata: {},
+            status: "active",
+            createdAt: 1,
+            updatedAt: 1,
+          };
+          if (
+            filters?.templateAgentId &&
+            filters.templateAgentId !== "agent-1"
+          ) {
+            return [];
+          }
+          return [connection];
+        },
+        async getConnection(id: string) {
+          if (id !== "conn-1") return null;
+          return {
+            id: "conn-1",
+            platform: "telegram",
+            templateAgentId: "agent-1",
+            config: { platform: "telegram" },
+            settings: {},
+            metadata: {},
+            status: "active",
+            createdAt: 1,
+            updatedAt: 1,
+          };
+        },
+        has() {
+          return true;
+        },
+        getServices() {
+          return {
+            getQueue() {
+              return {
+                getRedisClient() {
+                  return redis;
+                },
+              };
+            },
+          };
+        },
+      } as any,
+      {
+        userAgentsStore,
+        agentMetadataStore: {
+          getMetadata: (agentId: string) =>
+            agentMetadataStore.getMetadata(agentId),
+          listSandboxes: (connectionId: string) =>
+            agentMetadataStore.listSandboxes(connectionId),
+        },
+      }
+    );
+  }
+
+  test("forbids non-admin sessions from listing all connections", async () => {
+    setAuthProvider(() => ({
+      userId: "u1",
+      platform: "telegram",
+      exp: Date.now() + 60_000,
+    }));
+
+    const response = await buildApp().request("/api/v1/connections");
+    expect(response.status).toBe(403);
+  });
+
+  test("allows external owner sessions to list connections for their agent", async () => {
+    setAuthProvider(() => ({
+      userId: "u1",
+      oauthUserId: "u1",
+      platform: "external",
+      exp: Date.now() + 60_000,
+    }));
+
+    const response = await buildApp().request(
+      "/api/v1/connections?templateAgentId=agent-1"
+    );
+    expect(response.status).toBe(200);
+    const data = (await response.json()) as any;
+    expect(data.connections).toHaveLength(1);
+    expect(data.connections[0]?.id).toBe("conn-1");
+  });
+
+  test("forbids sandbox listing when session cannot access the connection template agent", async () => {
+    setAuthProvider(() => ({
+      userId: "u2",
+      platform: "telegram",
+      exp: Date.now() + 60_000,
+    }));
+
+    const response = await buildApp().request(
+      "/api/v1/connections/conn-1/sandboxes"
+    );
+    expect(response.status).toBe(403);
+  });
+});

package/src/__tests__/core-services-store-selection.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { GatewayConfig } from "../config";
+import { CoreServices } from "../services/core-services";
+import { MockMessageQueue } from "./setup";
+import {
+  RedisAgentAccessStore,
+  RedisAgentConfigStore,
+  RedisAgentConnectionStore,
+} from "../stores/redis-agent-store";
+
+function createGatewayConfig(
+  overrides?: Partial<GatewayConfig>
+): GatewayConfig {
+  return {
+    agentDefaults: {},
+    sessionTimeoutMinutes: 5,
+    logLevel: "INFO",
+    queues: {
+      connectionString: "redis://test",
+      directMessage: "direct_message",
+      messageQueue: "message_queue",
+      retryLimit: 3,
+      retryDelay: 1,
+      expireInHours: 24,
+    },
+    anthropicProxy: {
+      enabled: true,
+    },
+    orchestration: {
+      deploymentMode: "docker",
+      queues: {
+        connectionString: "redis://test",
+        retryLimit: 3,
+        retryDelay: 1,
+        expireInSeconds: 3600,
+      },
+      worker: {
+        image: {
+          repository: "lobu-worker",
+          tag: "latest",
+          digest: "",
+          pullPolicy: "Always",
+        },
+        imagePullSecrets: [],
+        serviceAccountName: "lobu-worker",
+        runtimeClassName: "",
+        startupTimeoutSeconds: 90,
+        resources: {
+          requests: { cpu: "100m", memory: "256Mi" },
+          limits: { cpu: "1000m", memory: "2Gi" },
+        },
+        idleCleanupMinutes: 60,
+        maxDeployments: 100,
+      },
+      kubernetes: { namespace: "lobu" },
+      cleanup: {
+        initialDelayMs: 1000,
+        intervalMs: 60000,
+        veryOldDays: 7,
+      },
+    },
+    mcp: {
+      publicGatewayUrl: "http://localhost:8080",
+      internalGatewayUrl: "http://gateway:8080",
+    },
+    health: {
+      checkIntervalMs: 1000,
+      staleThresholdMs: 2000,
+      protectActiveWorkers: true,
+    },
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  delete process.env.LOBU_WORKSPACE_ROOT;
+});
+
+describe("CoreServices store selection", () => {
+  test("uses Redis-backed stores by default when no file-first config is present", async () => {
+    const coreServices = new CoreServices(createGatewayConfig());
+    (coreServices as any).queue = new MockMessageQueue();
+
+    await (coreServices as any).initializeSessionServices();
+
+    expect(coreServices.getConfigStore()).toBeInstanceOf(RedisAgentConfigStore);
+    expect(coreServices.getConnectionStore()).toBeInstanceOf(
+      RedisAgentConnectionStore
+    );
+    expect(coreServices.getAccessStore()).toBeInstanceOf(RedisAgentAccessStore);
+  });
+});