pi-llama-cpp 0.10.0 → 0.11.0

package/tests/settingsStore.test.ts

@@ -0,0 +1,209 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { SettingsStore } from "../src/utils/settingsStore";
+
+vi.mock("@earendil-works/pi-coding-agent", () => ({
+  getAgentDir: vi.fn().mockReturnValue("/fake/agent/dir"),
+}));
+
+const mockReadFile = vi.hoisted(() => vi.fn());
+const mockWriteFile = vi.hoisted(() => vi.fn());
+const mockRename = vi.hoisted(() => vi.fn());
+
+vi.mock("node:fs/promises", () => ({
+  readFile: mockReadFile,
+  writeFile: mockWriteFile,
+  rename: mockRename,
+}));
+
+const mockGetAgentDir = vi.mocked(getAgentDir);
+
+const SETTINGS_PATH = "/fake/agent/dir/settings.json";
+
+describe("SettingsStore.read", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+  });
+
+  it("should return {} when the file is missing (ENOENT)", async () => {
+    mockReadFile.mockRejectedValue(
+      Object.assign(new Error("nope"), { code: "ENOENT" }),
+    );
+
+    const store = new SettingsStore(SETTINGS_PATH);
+
+    await expect(store.read()).resolves.toEqual({});
+  });
+
+  it("should reject with a message containing the path on invalid JSON", async () => {
+    mockReadFile.mockResolvedValue("{ not valid json");
+
+    const store = new SettingsStore(SETTINGS_PATH);
+
+    await expect(store.read()).rejects.toThrow(/Cannot parse.*settings\.json/);
+  });
+
+  it("should propagate non-ENOENT IO errors", async () => {
+    mockReadFile.mockRejectedValue(
+      Object.assign(new Error("permission denied"), { code: "EACCES" }),
+    );
+
+    const store = new SettingsStore(SETTINGS_PATH);
+
+    await expect(store.read()).rejects.toMatchObject({ code: "EACCES" });
+  });
+
+  it("should default the path to <agentDir>/settings.json", async () => {
+    mockReadFile.mockResolvedValue('{"a":1}');
+
+    const store = new SettingsStore();
+    await store.read();
+
+    expect(mockReadFile).toHaveBeenCalledWith(SETTINGS_PATH, "utf-8");
+  });
+});
+
+describe("SettingsStore.updateKey — file content", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockWriteFile.mockResolvedValue(undefined);
+    mockRename.mockResolvedValue(undefined);
+  });
+
+  it("should create the file with only the target key when the file was missing", async () => {
+    mockReadFile.mockRejectedValue(
+      Object.assign(new Error("nope"), { code: "ENOENT" }),
+    );
+
+    const store = new SettingsStore(SETTINGS_PATH);
+    await store.updateKey("llamaSettings", () => ({ sortBy: "asc" }));
+
+    const [, written] = mockWriteFile.mock.calls[0];
+    expect(JSON.parse(written as string)).toEqual({
+      llamaSettings: { sortBy: "asc" },
+    });
+  });
+
+  it("should preserve unrelated keys, their order, and merge into an existing target key", async () => {
+    mockReadFile.mockResolvedValue(
+      '{"aaa":1,"llamaSettings":{"sortBy":"asc"},"zzz":9}',
+    );
+
+    const store = new SettingsStore(SETTINGS_PATH);
+    await store.updateKey("llamaSettings", (current) => ({
+      ...(current as Record<string, unknown>),
+      sortBy: "desc",
+    }));
+
+    const [, written] = mockWriteFile.mock.calls[0];
+    const parsed = JSON.parse(written as string);
+    expect(Object.keys(parsed)).toEqual(["aaa", "llamaSettings", "zzz"]);
+    expect(parsed.llamaSettings).toEqual({ sortBy: "desc" });
+  });
+
+  it("should start from {} when the target key holds a non-object (null)", async () => {
+    mockReadFile.mockResolvedValue('{"llamaSettings":null}');
+
+    const store = new SettingsStore(SETTINGS_PATH);
+    await store.updateKey("llamaSettings", (current) => ({
+      ...(typeof current === "object" && current !== null ? current : {}),
+      autoloadOnMessage: true,
+    }));
+
+    const [, written] = mockWriteFile.mock.calls[0];
+    expect(JSON.parse(written as string)).toEqual({
+      llamaSettings: { autoloadOnMessage: true },
+    });
+  });
+});
+
+describe("SettingsStore.updateKey — write path", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockWriteFile.mockResolvedValue(undefined);
+    mockRename.mockResolvedValue(undefined);
+  });
+
+  it("should write to <path>.tmp with 2-space indent, then rename onto the real path", async () => {
+    mockReadFile.mockResolvedValue('{"llamaSettings":{"sortBy":"asc"}}');
+
+    const store = new SettingsStore(SETTINGS_PATH);
+    await store.updateKey("llamaSettings", (current) => ({
+      ...(current as Record<string, unknown>),
+      sortBy: "desc",
+    }));
+
+    expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      `${SETTINGS_PATH}.tmp`,
+      expect.stringContaining('\n  "llamaSettings"'),
+      "utf-8",
+    );
+    expect(mockRename).toHaveBeenCalledTimes(1);
+    expect(mockRename).toHaveBeenCalledWith(
+      `${SETTINGS_PATH}.tmp`,
+      SETTINGS_PATH,
+    );
+  });
+
+  it("should apply queued concurrent writes in submission order (last write wins)", async () => {
+    // Simulate a real file: reads return the last written content.
+    let contents = "{}";
+    mockReadFile.mockImplementation(async () => contents);
+    mockWriteFile.mockImplementation(async (_path: unknown, data: string) => {
+      contents = data;
+    });
+
+    const store = new SettingsStore(SETTINGS_PATH);
+    const first = store.updateKey("llamaSettings", (current) => ({
+      ...(current as Record<string, unknown>),
+      first: 1,
+    }));
+    const second = store.updateKey("llamaSettings", (current) => ({
+      ...(current as Record<string, unknown>),
+      second: 2,
+    }));
+
+    await first;
+    await second;
+
+    // Without the queue both writes would read the same "{}" and the final
+    // content would only hold the last caller's key.
+    expect(mockReadFile).toHaveBeenCalledTimes(2);
+    expect(mockWriteFile).toHaveBeenCalledTimes(2);
+    const [, firstWrite] = mockWriteFile.mock.calls[0];
+    const [, secondWrite] = mockWriteFile.mock.calls[1];
+    expect(JSON.parse(firstWrite as string)).toEqual({
+      llamaSettings: { first: 1 },
+    });
+    expect(JSON.parse(secondWrite as string)).toEqual({
+      llamaSettings: { first: 1, second: 2 },
+    });
+  });
+
+  it("should reject a failing write but let the next queued update still run", async () => {
+    mockReadFile.mockResolvedValue('{"llamaSettings":{}}');
+    mockWriteFile.mockRejectedValueOnce(new Error("ENOSPC: simulated"));
+
+    const store = new SettingsStore(SETTINGS_PATH);
+    const failing = store.updateKey("llamaSettings", (current) => ({
+      ...(current as Record<string, unknown>),
+      a: 1,
+    }));
+    const following = store.updateKey("llamaSettings", (current) => ({
+      ...(current as Record<string, unknown>),
+      b: 2,
+    }));
+
+    await expect(failing).rejects.toThrow("ENOSPC");
+    await expect(following).resolves.toBeUndefined();
+
+    const [, lastWrite] = mockWriteFile.mock.calls[1];
+    expect(JSON.parse(lastWrite as string)).toEqual({
+      llamaSettings: { b: 2 },
+    });
+  });
+});

package/tests/sseManager.test.ts

@@ -1,21 +1,98 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { SERVER_TIMEOUT } from "../src/constants";
+import { describe, expect, it, vi } from "vitest";
 import { SSEManager } from "../src/sse/manager";
+import { createMockServer } from "./mocks";
 
-beforeEach(() => {
-  vi.clearAllMocks();
+/**
+ * Builds an SSEManager bound to a stub server, mirroring how
+ * `Server.initialize()` wires it up (timeouts are read through the server).
+ */
+const createManager = (
+  pollingTimeout = 60000,
+  serverTimeout = 1000,
+): SSEManager =>
+  new SSEManager(
+    createMockServer({
+      baseUrl: "http://127.0.0.1:8080",
+      pollingTimeout,
+      serverTimeout,
+    }),
+    "",
+  );
+
+describe("SSEManager timeouts", () => {
+  it("should expose the timeouts of its server", () => {
+    const manager = createManager(5678, 1234);
+
+    expect(manager.pollingTimeout).toBe(5678);
+    expect(manager.serverTimeout).toBe(1234);
+  });
 });
 
-describe("SSEManager serverTimeout", () => {
-  it("should use default timeout when not provided", () => {
-    const manager = new SSEManager("http://127.0.0.1:8080", "");
+describe("SSEManager subscribeToStatus", () => {
+  it("should reject after the server's pollingTimeout, not the constant", async () => {
+    vi.useFakeTimers();
+    vi.stubGlobal(
+      "EventSource",
+      class StubEventSource {
+        onopen = null;
+        onerror = null;
+        onmessage = null;
+        close() {}
+      },
+    );
+
+    try {
+      const manager = createManager(5000);
+      const promise = manager.subscribeToStatus("test-model");
+      const expectation = expect(promise).rejects.toThrow(
+        "SSE status timeout for model: test-model",
+      );
 
-    expect((manager as any).serverTimeout).toBe(SERVER_TIMEOUT);
+      // If the timer still used the fixed 60 s constant, advancing 5 s
+      // would not trigger the rejection.
+      await vi.advanceTimersByTimeAsync(5000);
+      await expectation;
+    } finally {
+      vi.unstubAllGlobals();
+      vi.useRealTimers();
+    }
   });
 
-  it("should accept custom serverTimeout", () => {
-    const manager = new SSEManager("http://127.0.0.1:8080", "", 3000);
+  it("should resolve when a terminal status arrives before the timeout", async () => {
+    vi.useFakeTimers();
+    vi.stubGlobal(
+      "EventSource",
+      class StubEventSource {
+        onopen = null;
+        onerror = null;
+        onmessage = null;
+        close() {}
+      },
+    );
+
+    try {
+      const manager = createManager(5000);
+      const promise = manager.subscribeToStatus("test-model");
+      const expectation = expect(promise).resolves.toMatchObject({
+        status: "loaded",
+      });
+
+      manager.subscribeToProgress("test-model", () => {});
+      await vi.advanceTimersByTimeAsync(0);
+
+      // Emit a terminal status through the shared client's dispatch path
+      const client = (manager as any).sseClient;
+      const handler = client.subscribers.get("test-model");
+      handler({
+        event: "status_change",
+        model: "test-model",
+        data: { status: "loaded" },
+      });
 
-    expect((manager as any).serverTimeout).toBe(3000);
+      await expectation;
+    } finally {
+      vi.unstubAllGlobals();
+      vi.useRealTimers();
+    }
   });
 });

package/src/interfaces/auth.ts

@@ -1,6 +0,0 @@
-interface Auth {
-  type: string;
-  key: string;
-}
-
-export type AuthFile = Record<string, Auth>;

package/src/utils/cache.ts

@@ -1,39 +0,0 @@
-/**
- * Generic TTL cache.
- * Entries expire after `ttl` milliseconds from the time they were set.
- */
-export class Cache {
-  private entries = new Map<string, { data: unknown; timestamp: number }>();
-
-  /**
-   * @param ttl Time-to-live in milliseconds
-   */
-  constructor(private readonly ttl: number) {}
-
-  /**
-   * Gets a cached value by key. Returns `undefined` if missing or expired.
-   */
-  get<T>(key: string): T | undefined {
-    const entry = this.entries.get(key);
-    if (!entry) return undefined;
-    if (Date.now() - entry.timestamp > this.ttl) {
-      this.entries.delete(key);
-      return undefined;
-    }
-    return entry.data as T;
-  }
-
-  /**
-   * Stores a value in the cache with the current timestamp.
-   */
-  set(key: string, data: unknown): void {
-    this.entries.set(key, { data, timestamp: Date.now() });
-  }
-
-  /**
-   * Clears all cached entries.
-   */
-  clear(): void {
-    this.entries.clear();
-  }
-}

package/src/utils/mutex.ts

@@ -1,24 +0,0 @@
-/**
- * Ensures only one in-flight operation exists per key.
- * Concurrent callers for the same key share the same promise.
- */
-export class Mutex {
-  private promises = new Map<string, Promise<unknown>>();
-
-  /**
-   * Runs `fn` for the given key, or returns an existing in-flight promise.
-   * Concurrent callers for the same key share the same promise.
-   */
-  getOrCreate<T>(key: string, fn: () => Promise<T>): Promise<T> {
-    const existing = this.promises.get(key);
-    if (existing) {
-      return existing as Promise<T>;
-    }
-
-    const promise = fn().finally(() => {
-      this.promises.delete(key);
-    });
-    this.promises.set(key, promise);
-    return promise;
-  }
-}