pi-llama-cpp 0.10.0 → 0.11.0

package/tests/serverManager.test.ts

@@ -2,14 +2,37 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 import { ServerManager } from "../src/managers/server";
 import { BaseModel } from "../src/models/baseModel";
 import { Server } from "../src/server";
-import { createMockServer, mockRpc } from "./mocks";
+import {
+  createMockModel,
+  createMockServer,
+  makeSettingsStub,
+  mockRpc,
+} from "./mocks";
+
+// Injected settings stub — the single instance passed to ServerManager and
+// to every real `new Server(...)` construction below (Server's eager
+// getApiKey() resolves the stub's placeholder, never consumed). Tests
+// re-stub members per case instead of module-mocking the singleton.
+const settingsStub = makeSettingsStub();
 
 const mockPi = {
   registerProvider: vi.fn(),
+  unregisterProvider: vi.fn(),
   registerCommand: vi.fn(),
   setModel: vi.fn(),
 };
 
+/**
+ * Creates a ServerManager whose list is driven by the mocked
+ * `settings.resolveServers()` — the same path a real scan takes.
+ */
+const createManager = async (...servers: Server[]): Promise<ServerManager> => {
+  vi.mocked(settingsStub.resolveServers).mockReturnValue(servers);
+  const manager = new ServerManager(settingsStub);
+  await manager.update(mockPi as any);
+  return manager;
+};
+
 beforeEach(() => {
   vi.clearAllMocks();
   mockRpc.mockImplementation((endpoint: string, fallback?: unknown) => {
@@ -24,22 +47,34 @@ beforeEach(() => {
 
 describe("Server", () => {
   it("should generate provider IDs from URLs", () => {
-    const server1 = new Server("http://127.0.0.1:8080");
+    const server1 = new Server(settingsStub, {
+      baseUrl: "http://127.0.0.1:8080",
+    });
     expect(server1.providerId).toBe("llama-server=http://127.0.0.1:8080");
-    const server2 = new Server("http://10.0.0.5:8080");
+    const server2 = new Server(settingsStub, {
+      baseUrl: "http://10.0.0.5:8080",
+    });
     expect(server2.providerId).toBe("llama-server=http://10.0.0.5:8080");
-    const server3 = new Server("http://127.0.0.1");
+    const server3 = new Server(settingsStub, { baseUrl: "http://127.0.0.1" });
     expect(server3.providerId).toBe("llama-server=http://127.0.0.1");
-    const server4 = new Server("http://127.0.0.1:80");
+    const server4 = new Server(settingsStub, {
+      baseUrl: "http://127.0.0.1:80",
+    });
     expect(server4.providerId).toBe("llama-server=http://127.0.0.1:80");
-    const server5 = new Server("https://127.0.0.1:443");
+    const server5 = new Server(settingsStub, {
+      baseUrl: "https://127.0.0.1:443",
+    });
     expect(server5.providerId).toBe("llama-server=https://127.0.0.1:443");
   });
 
   it("should generate provider names from URLs", () => {
-    const server1 = new Server("http://127.0.0.1:8080");
+    const server1 = new Server(settingsStub, {
+      baseUrl: "http://127.0.0.1:8080",
+    });
     expect(server1.providerName).toBe("Llama.cpp (http://127.0.0.1:8080)");
-    const server2 = new Server("http://10.0.0.5:8080");
+    const server2 = new Server(settingsStub, {
+      baseUrl: "http://10.0.0.5:8080",
+    });
     expect(server2.providerName).toBe("Llama.cpp (http://10.0.0.5:8080)");
   });
 });
@@ -51,32 +86,17 @@ describe("ServerManager", () => {
       id: "test-model",
       toProviderConfig: vi.fn().mockResolvedValue({ id: "test-model" }),
     } as unknown as BaseModel;
-    mockRpc.mockImplementation((endpoint: string, fallback?: unknown) => {
-      if (endpoint === "/v1/models") {
-        return Promise.resolve({ data: [mockModel], object: "list" });
-      }
-      const defaults: Record<string, unknown> = {
-        "/health": { status: "ok" },
-        "/props?autoload=false": { role: "router" },
-      };
-      return Promise.resolve(defaults[endpoint] ?? fallback ?? {});
-    });
-
     const server1 = createMockServer({
       baseUrl: "http://127.0.0.1:8080",
       apiKey: "key-1",
-      providerId: "llama-server=http://127.0.0.1:8080",
-      providerName: "Llama.cpp (http://127.0.0.1:8080)",
+      models: [mockModel],
     });
     const server2 = createMockServer({
       baseUrl: "http://127.0.0.1:8081",
       apiKey: "key-2",
-      providerId: "llama-server=http://127.0.0.1:8081",
-      providerName: "Llama.cpp (http://127.0.0.1:8081)",
+      models: [mockModel],
     });
-    const manager = new ServerManager([server1, server2] as any);
-
-    await manager.initialize(mockPi as any);
+    const manager = await createManager(server1, server2);
 
     expect(mockPi.registerProvider).toHaveBeenCalledTimes(2);
     expect(mockPi.registerProvider).toHaveBeenCalledWith(
@@ -101,25 +121,18 @@ describe("ServerManager", () => {
     );
   });
 
-  it("should return all models from all servers", () => {
-    const mockModel1 = {
-      name: "model-1",
-      id: "model-1",
-    } as unknown as BaseModel;
-    const mockModel2 = {
-      name: "model-2",
-      id: "model-2",
-    } as unknown as BaseModel;
+  it("should return all models from all servers", async () => {
+    const mockModel1 = createMockModel("model-1");
+    const mockModel2 = createMockModel("model-2");
     const server1 = createMockServer({
       baseUrl: "http://127.0.0.1:8080",
+      models: [mockModel1],
     });
     const server2 = createMockServer({
       baseUrl: "http://127.0.0.1:8081",
+      models: [mockModel2],
     });
-    const manager = new ServerManager([
-      { ...server1, models: [mockModel1] } as any,
-      { ...server2, models: [mockModel2] } as any,
-    ] as any);
+    const manager = await createManager(server1, server2);
 
     const allModels = manager.getAllModels();
 
@@ -127,4 +140,234 @@ describe("ServerManager", () => {
     expect(allModels[0]).toBe(mockModel1);
     expect(allModels[1]).toBe(mockModel2);
   });
+
+  describe("live server list (re-derived from settings)", () => {
+    /** Mock server; providerId/name derive from the URL as in production. */
+    const makeServer = (url: string, modelName?: string): Server =>
+      createMockServer({
+        baseUrl: url,
+        ...(modelName
+          ? { models: [createMockModel(modelName, { serverUrl: url })] }
+          : {}),
+      });
+
+    it("should register servers added after the first scan", async () => {
+      const server1 = makeServer("http://127.0.0.1:8080", "model-1");
+      vi.mocked(settingsStub.resolveServers).mockReturnValue([server1]);
+      const manager = new ServerManager(settingsStub);
+      await manager.update(mockPi as any);
+      expect(manager.servers).toHaveLength(1);
+
+      const server2 = makeServer("http://127.0.0.1:8081", "model-2");
+      vi.mocked(settingsStub.resolveServers).mockReturnValue([
+        server1,
+        server2,
+      ]);
+      await manager.update(mockPi as any);
+
+      expect(mockPi.registerProvider).toHaveBeenCalledWith(
+        "llama-server=http://127.0.0.1:8081",
+        expect.objectContaining({ baseUrl: "http://127.0.0.1:8081" }),
+      );
+      expect(manager.servers).toHaveLength(2);
+      expect(manager.getAllModels().map((m) => m.id)).toEqual([
+        "model-1",
+        "model-2",
+      ]);
+    });
+
+    it("should unregister and disconnect removed servers on the next scan", async () => {
+      const disconnectKept = vi.fn();
+      const disconnectRemoved = vi.fn();
+      const server1 = makeServer("http://127.0.0.1:8080", "model-1");
+      const server2 = makeServer("http://127.0.0.1:8081", "model-2");
+      // createMockServer stubs initialize out (models are pre-seeded), so the
+      // SSE managers never get wired; seed the slots ServerManager reaches
+      // disconnect through, mirroring an initialized server.
+      (server1 as any).sse = { disconnect: disconnectKept };
+      (server2 as any).sse = { disconnect: disconnectRemoved };
+
+      const manager = await createManager(server1, server2);
+      expect(manager.servers).toHaveLength(2);
+
+      vi.mocked(settingsStub.resolveServers).mockReturnValue([server1]);
+      await manager.update(mockPi as any);
+
+      expect(mockPi.unregisterProvider).toHaveBeenCalledTimes(1);
+      expect(mockPi.unregisterProvider).toHaveBeenCalledWith(
+        "llama-server=http://127.0.0.1:8081",
+      );
+      expect(disconnectRemoved).toHaveBeenCalledTimes(1);
+      // Surviving providers keep their SSE manager connected (today's behavior)
+      expect(disconnectKept).not.toHaveBeenCalled();
+      expect(manager.getAllModels().map((m) => m.id)).toEqual(["model-1"]);
+    });
+
+    it("should unregister the old provider when a server URL changes", async () => {
+      const manager = await createManager(
+        makeServer("http://127.0.0.1:8080", "model-1"),
+      );
+
+      vi.mocked(settingsStub.resolveServers).mockReturnValue([
+        makeServer("http://127.0.0.1:9090", "model-1"),
+      ]);
+      await manager.update(mockPi as any);
+
+      expect(mockPi.unregisterProvider).toHaveBeenCalledWith(
+        "llama-server=http://127.0.0.1:8080",
+      );
+      expect(mockPi.registerProvider).toHaveBeenCalledWith(
+        "llama-server=http://127.0.0.1:9090",
+        expect.objectContaining({ baseUrl: "http://127.0.0.1:9090" }),
+      );
+      expect(manager.servers[0]?.providerId).toBe(
+        "llama-server=http://127.0.0.1:9090",
+      );
+    });
+
+    it("should re-register same-id servers without unregistering (name edit)", async () => {
+      const original = createMockServer({
+        baseUrl: "http://127.0.0.1:8080",
+        customId: "my-custom-id",
+        customName: "A",
+      });
+      const manager = await createManager(original);
+
+      const renamed = createMockServer({
+        baseUrl: "http://127.0.0.1:8080",
+        customId: "my-custom-id",
+        customName: "B",
+      });
+      vi.mocked(settingsStub.resolveServers).mockReturnValue([renamed]);
+      await manager.update(mockPi as any);
+
+      expect(mockPi.unregisterProvider).not.toHaveBeenCalled();
+      expect(vi.mocked(mockPi.registerProvider).mock.calls.at(-1)).toEqual([
+        "my-custom-id",
+        expect.objectContaining({ name: "Llama.cpp (B)" }),
+      ]);
+      expect(manager.servers[0]?.providerId).toBe("my-custom-id");
+    });
+
+    it("should collapse duplicate URLs into a single server", async () => {
+      const first = makeServer("http://127.0.0.1:8080", "model-1");
+      const duplicate = makeServer("http://127.0.0.1:8080", "model-1");
+      const manager = await createManager(first, duplicate);
+
+      expect(manager.servers).toHaveLength(1);
+      expect(mockPi.registerProvider).toHaveBeenCalledTimes(1);
+      expect(manager.getAllModels()).toHaveLength(1);
+    });
+
+    it("should return undefined from getServer for a removed server's model", async () => {
+      const manager = await createManager(
+        makeServer("http://127.0.0.1:8080", "model-1"),
+      );
+
+      const live = manager.getAllModels()[0];
+      expect(manager.getServer(live)).toBe(manager.servers[0]);
+
+      const orphan = { serverUrl: "http://gone:1" } as unknown as BaseModel;
+      expect(manager.getServer(orphan)).toBeUndefined();
+    });
+  });
+
+  describe("sortBy", () => {
+    const sortBy = () => vi.mocked(settingsStub.resolveSortBy);
+
+    it("should return models in API order when sortBy is 'api'", async () => {
+      sortBy().mockReturnValue("api");
+
+      const mockModelA = createMockModel("model-a");
+      const mockModelZ = createMockModel("model-z");
+      const manager = await createManager(
+        createMockServer({
+          baseUrl: "http://127.0.0.1:8080",
+          models: [mockModelA, mockModelZ],
+        }),
+      );
+
+      const allModels = manager.getAllModels();
+
+      expect(allModels).toHaveLength(2);
+      expect(allModels[0]).toBe(mockModelA);
+      expect(allModels[1]).toBe(mockModelZ);
+    });
+
+    it("should sort models by ID ascending when sortBy is 'asc'", async () => {
+      sortBy().mockReturnValue("asc");
+
+      const mockModelZ = createMockModel("model-z");
+      const mockModelA = createMockModel("model-a");
+      const manager = await createManager(
+        createMockServer({
+          baseUrl: "http://127.0.0.1:8080",
+          models: [mockModelZ, mockModelA],
+        }),
+      );
+
+      const allModels = manager.getAllModels();
+
+      expect(allModels).toHaveLength(2);
+      expect(allModels[0]).toBe(mockModelA);
+      expect(allModels[1]).toBe(mockModelZ);
+    });
+
+    it("should sort models by ID descending when sortBy is 'desc'", async () => {
+      sortBy().mockReturnValue("desc");
+
+      const mockModelA = createMockModel("model-a");
+      const mockModelZ = createMockModel("model-z");
+      const manager = await createManager(
+        createMockServer({
+          baseUrl: "http://127.0.0.1:8080",
+          models: [mockModelA, mockModelZ],
+        }),
+      );
+
+      const allModels = manager.getAllModels();
+
+      expect(allModels).toHaveLength(2);
+      expect(allModels[0]).toBe(mockModelZ);
+      expect(allModels[1]).toBe(mockModelA);
+    });
+
+    it("should sort models by name ascending when sortBy is 'asc-name'", async () => {
+      sortBy().mockReturnValue("asc-name");
+
+      const mockModelB = createMockModel("zebra", { id: "model-b" });
+      const mockModelA = createMockModel("alpha", { id: "model-a" });
+      const manager = await createManager(
+        createMockServer({
+          baseUrl: "http://127.0.0.1:8080",
+          models: [mockModelB, mockModelA],
+        }),
+      );
+
+      const allModels = manager.getAllModels();
+
+      expect(allModels).toHaveLength(2);
+      expect(allModels[0]).toBe(mockModelA);
+      expect(allModels[1]).toBe(mockModelB);
+    });
+
+    it("should sort models by name descending when sortBy is 'desc-name'", async () => {
+      sortBy().mockReturnValue("desc-name");
+
+      const mockModelA = createMockModel("alpha", { id: "model-a" });
+      const mockModelB = createMockModel("zebra", { id: "model-b" });
+      const manager = await createManager(
+        createMockServer({
+          baseUrl: "http://127.0.0.1:8080",
+          models: [mockModelA, mockModelB],
+        }),
+      );
+
+      const allModels = manager.getAllModels();
+
+      expect(allModels).toHaveLength(2);
+      expect(allModels[0]).toBe(mockModelB);
+      expect(allModels[1]).toBe(mockModelA);
+    });
+  });
 });

package/tests/settings.test.ts

@@ -1,3 +1,4 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   API_KEY_PLACEHOLDER,
@@ -17,6 +18,7 @@ const mockSettingsManager = vi.hoisted(() => ({
   getGlobalSettings: vi.fn(),
   getDefaultThinkingLevel: vi.fn(),
   getThinkingBudgets: vi.fn(),
+  reload: vi.fn(),
 }));
 
 // Mock getAgentDir, readStoredCredential, and SettingsManager before importing resolver
@@ -31,6 +33,8 @@ vi.mock("@earendil-works/pi-coding-agent", () => ({
 
 vi.mock("node:fs/promises", () => ({
   readFile: vi.fn(),
+  writeFile: vi.fn(),
+  rename: vi.fn(),
 }));
 
 // Import mocked modules
@@ -131,6 +135,34 @@ describe("URL resolution fallback chain", () => {
 
     expect(result).toEqual(["http://first:8080", "http://second:9090"]);
   });
+
+  it("should drop env URLs without an http(s) scheme, warn, and fall through", async () => {
+    process.env.LLAMA_SERVER_URL = "127.0.0.1:8080";
+
+    const result = settings.resolveUrls();
+
+    expect(result).toEqual([LLAMA_SERVER_URL]);
+    expect(settings.takeWarnings()).toEqual([
+      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
+    ]);
+    expect(settings.takeWarnings()).toEqual([]); // drained
+  });
+
+  it("should drop server entries without an http(s) scheme and warn", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [{ url: "127.0.0.1:8080" }, { url: "http://good:8080/" }],
+      },
+    });
+
+    const result = settings.resolveUrls();
+
+    expect(result).toEqual(["http://good:8080"]);
+    expect(settings.takeWarnings()).toEqual([
+      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
+    ]);
+    expect(settings.takeWarnings()).toEqual([]); // drained
+  });
 });
 
 describe("llamaSettings.servers resolution", () => {
@@ -315,13 +347,16 @@ describe("API key resolution", () => {
 
 describe("Server with custom id", () => {
   it("should use custom id as providerId when provided", () => {
-    const server = new Server("http://127.0.0.1:8080", "my-custom-id");
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+    });
 
     expect(server.providerId).toEqual("my-custom-id");
   });
 
   it("should fall back to URL-based providerId when no custom id", () => {
-    const server = new Server("http://127.0.0.1:8080");
+    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
 
     expect(server.providerId).toEqual(
       `${PROVIDER_PREFIX}=http://127.0.0.1:8080`,
@@ -329,14 +364,19 @@ describe("Server with custom id", () => {
   });
 
   it("should try custom id first in getApiKey(), then fall back to URL-based", () => {
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+    });
+
+    // Server construction resolves the key eagerly (ApiClient built there);
+    // clear so the assertions below observe only the explicit getApiKey() call
     vi.clearAllMocks();
     // Mock: custom id returns placeholder (no key found)
     mockReadStoredCredential
       .mockReturnValueOnce(API_KEY_PLACEHOLDER)
       .mockReturnValueOnce({ key: "fallback-key" });
 
-    const server = new Server("http://127.0.0.1:8080", "my-custom-id");
-
     const result = server.getApiKey();
 
     expect(result).toEqual("fallback-key");
@@ -350,7 +390,10 @@ describe("Server with custom id", () => {
   it("should return custom id key directly when found", () => {
     mockReadStoredCredential.mockReturnValue({ key: "custom-key" });
 
-    const server = new Server("http://127.0.0.1:8080", "my-custom-id");
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+    });
 
     const result = server.getApiKey();
 
@@ -361,27 +404,26 @@ describe("Server with custom id", () => {
 
 describe("Server with custom name", () => {
   it("should use custom name as suffix in providerName", () => {
-    const server = new Server(
-      "http://127.0.0.1:8080",
-      undefined,
-      "Remote Server",
-    );
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customName: "Remote Server",
+    });
 
     expect(server.providerName).toEqual(`Llama.cpp (Remote Server)`);
   });
 
   it("should fall back to URL-based name when no custom name", () => {
-    const server = new Server("http://127.0.0.1:8080");
+    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
 
     expect(server.providerName).toEqual(`Llama.cpp (http://127.0.0.1:8080)`);
   });
 
   it("should use custom name even with custom id", () => {
-    const server = new Server(
-      "http://127.0.0.1:8080",
-      "my-custom-id",
-      "Remote Server",
-    );
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+      customName: "Remote Server",
+    });
 
     expect(server.providerId).toEqual("my-custom-id");
     expect(server.providerName).toEqual(`Llama.cpp (Remote Server)`);
@@ -409,6 +451,14 @@ describe("reactToModelSelect and autoloadOnMessage fallbacks", () => {
     expect(result).toBe(false);
   });
 
+  it("should return 'asc' when sortBy is not set", async () => {
+    const { settings } = await import("../src/managers/settings");
+
+    const result = settings.resolveSortBy();
+
+    expect(result).toBe("asc");
+  });
+
   it("should return user values when set", async () => {
     mockSettingsManager.getProjectSettings.mockReturnValue({
       llamaSettings: {
@@ -634,3 +684,110 @@ describe("Thinking config resolution", () => {
     );
   });
 });
+
+describe("setLlamaSetting", () => {
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+  const mockGetProjectSettings = vi.mocked(
+    mockSettingsManager.getProjectSettings,
+  );
+  const mockGetGlobalSettings = vi.mocked(
+    mockSettingsManager.getGlobalSettings,
+  );
+  const mockReload = vi.mocked(mockSettingsManager.reload);
+  const mockReadFile = vi.mocked(readFile);
+  const mockWriteFile = vi.mocked(writeFile);
+  const mockRename = vi.mocked(rename);
+
+  const SETTINGS_PATH = "/fake/agent/dir/settings.json";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({});
+    mockReload.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue("{}");
+    mockWriteFile.mockResolvedValue(undefined);
+    mockRename.mockResolvedValue(undefined);
+  });
+
+  it("should write the merged llamaSettings key atomically and reload", async () => {
+    mockReadFile.mockResolvedValue(
+      JSON.stringify(
+        { unrelated: true, llamaSettings: { reactToModelSelect: true } },
+        null,
+        2,
+      ),
+    );
+
+    await settings.setLlamaSetting("sortBy", "desc");
+
+    expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    const [tmpPath, written, encoding] = mockWriteFile.mock.calls[0];
+    expect(tmpPath).toBe(`${SETTINGS_PATH}.tmp`);
+    expect(encoding).toBe("utf-8");
+    const parsed = JSON.parse(written as string);
+    expect(parsed).toEqual({
+      unrelated: true,
+      llamaSettings: { reactToModelSelect: true, sortBy: "desc" },
+    });
+    expect(mockRename).toHaveBeenCalledWith(
+      `${SETTINGS_PATH}.tmp`,
+      SETTINGS_PATH,
+    );
+    expect(mockReload).toHaveBeenCalledTimes(1);
+  });
+
+  it("should reflect the new value in resolvers immediately after the write", async () => {
+    mockSettingsManager.reload.mockImplementation(async () => {
+      mockGetGlobalSettings.mockReturnValue({
+        llamaSettings: { sortBy: "desc" },
+      });
+    });
+
+    await settings.setLlamaSetting("sortBy", "desc");
+
+    expect(settings.resolveSortBy()).toBe("desc");
+  });
+
+  it("should reject and skip reload when the write fails", async () => {
+    mockWriteFile.mockRejectedValue(new Error("ENOSPC: simulated"));
+
+    await expect(settings.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
+      "ENOSPC",
+    );
+    expect(mockReload).not.toHaveBeenCalled();
+  });
+
+  it("should reject and leave the file untouched when the JSON is invalid", async () => {
+    mockReadFile.mockResolvedValue("{ broken");
+
+    await expect(settings.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
+      /Cannot parse/,
+    );
+    expect(mockWriteFile).not.toHaveBeenCalled();
+    expect(mockReload).not.toHaveBeenCalled();
+  });
+
+  it("should persist booleans and numbers with type fidelity", async () => {
+    await settings.setLlamaSetting("reactToModelSelect", false);
+
+    const [, firstWrite] = mockWriteFile.mock.calls[0];
+    expect(JSON.parse(firstWrite as string)).toEqual({
+      llamaSettings: { reactToModelSelect: false },
+    });
+
+    await settings.setLlamaSetting("pollingTimeout", 120000);
+
+    const [, secondWrite] = mockWriteFile.mock.calls[1];
+    expect(JSON.parse(secondWrite as string)).toEqual({
+      llamaSettings: { pollingTimeout: 120000 },
+    });
+  });
+
+  it("should still construct the manager without arguments", async () => {
+    const { LlamaSettingsManager } = await import("../src/managers/settings");
+
+    expect(() => new LlamaSettingsManager()).not.toThrow();
+  });
+});