pi-llama-cpp 0.9.2 → 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

@@ -0,0 +1,98 @@
+import { describe, expect, it, vi } from "vitest";
+import { SSEManager } from "../src/sse/manager";
+import { createMockServer } from "./mocks";
+
+/**
+ * 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 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",
+      );
+
+      // 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 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" },
+      });
+
+      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/resolver.ts

@@ -1,149 +0,0 @@
-import { ApiKeyCredential, ModelThinkingLevel } from "@earendil-works/pi-ai";
-import {
-  getAgentDir,
-  readStoredCredential,
-  SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import {
-  API_KEY_PLACEHOLDER,
-  DEFAULT_LLAMA_SERVER_URL,
-  DEFAULT_THINKING_BUDGETS,
-} from "./constants";
-
-export class ConfigResolver {
-  private warnings: string[] = [];
-
-  private cachedUrls: string[] = [];
-  private settingsManager = SettingsManager.create(
-    process.cwd(),
-    getAgentDir(),
-  );
-
-  /**
-   * Resolves the llama-server URL by searching in the global settings.json
-   */
-  private async resolveGlobalUrl(): Promise<string | null> {
-    const settings = this.settingsManager.getGlobalSettings();
-    const { llamaServerUrl = null } = settings as Record<string, string>;
-
-    return llamaServerUrl;
-  }
-
-  /**
-   * Resolves the llama-server URL by searching in the project's .pi/settings.json
-   */
-  private async resolveProjectUrl(): Promise<string | null> {
-    // Warn the user for deprecation
-    try {
-      const filePath = join(process.cwd(), ".pi", "llama-server.json");
-      const { url = null } = JSON.parse(await readFile(filePath, "utf-8"));
-
-      const messages = [
-        "[pi-llama-cpp]",
-        "The project-level `.pi/llama-server.json` file has been deprecated.",
-        "It will work for now, but you must follow these instructions as soon as possible:",
-        '- Move your url to the project-level `.pi/settings.json` file as {"llamaServerUrl": "<url>"}.',
-        "- Remove the old `.pi/llama-server.json` file.",
-      ];
-
-      this.warnings.push(messages.join("\n"));
-
-      return url;
-    } catch {
-      // No old file available, continue as normal
-    }
-
-    const settings = this.settingsManager.getProjectSettings();
-    const { llamaServerUrl = null } = settings as Record<string, string>;
-
-    return llamaServerUrl;
-  }
-
-  /**
-   * Resolves the llama-server URL from the environment
-   */
-  private async resolveEnvUrl(): Promise<string | null> {
-    return process.env.LLAMA_SERVER_URL ?? null;
-  }
-
-  /**
-   * Tries all possible ways to retrieve the llama-server URL(s)
-   */
-  private async extractJoinedUrls(): Promise<string> {
-    // 1. per-project config
-    let response = await this.resolveProjectUrl();
-    if (response) return response;
-
-    // 2. env
-    response = await this.resolveEnvUrl();
-    if (response) return response;
-
-    // 3. global settings
-    response = await this.resolveGlobalUrl();
-    if (response) return response;
-
-    // 4. default
-    return DEFAULT_LLAMA_SERVER_URL;
-  }
-
-  /**
-   * Resolves URLs where llama-servers are running (cached)
-   */
-  async resolveUrls(): Promise<string[]> {
-    if (this.cachedUrls.length > 0) return this.cachedUrls;
-
-    const raw = await this.extractJoinedUrls();
-    const urls = raw
-      .split(";")
-      .map((u) => u.trim())
-      .filter((u) => u.length > 0)
-      .map((u) => u.replace(/\/+$/, ""));
-
-    this.cachedUrls = urls;
-    return this.cachedUrls;
-  }
-
-  /**
-   * Resolves API key for the provider ID using Pi's stored credentials
-   */
-  resolveApiKey(providerId: string): string {
-    const credential = readStoredCredential(providerId) as ApiKeyCredential;
-    return credential?.key ?? API_KEY_PLACEHOLDER;
-  }
-
-  /**
-   * Returns warnings collected during URL resolution.
-   */
-  getWarnings(): string[] {
-    const warnings = [...this.warnings];
-    this.warnings.length = 0;
-
-    return warnings;
-  }
-
-  /*
-   * Resolves the current thinking level from Pi.
-   *
-   * @returns Selected level
-   */
-  resolveThinkingLevel(): ModelThinkingLevel | undefined {
-    return this.settingsManager.getDefaultThinkingLevel();
-  }
-
-  /**
-   * Resolves the effective thinking budgets from settings
-   *
-   * @returns Thinking budgets
-   */
-  resolveThinkingBudgets(): Record<ModelThinkingLevel, number> {
-    const settingsBudgets = this.settingsManager.getThinkingBudgets() ?? {};
-    const availableBudgets = {
-      ...DEFAULT_THINKING_BUDGETS,
-      ...settingsBudgets,
-    };
-
-    return availableBudgets;
-  }
-}

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;
-  }
-}