pi-llama-cpp 0.15.0 → 0.16.0

package/tests/settings/settings.test.ts

@@ -48,309 +48,111 @@ vi.mock("node:fs/promises", () => ({
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { access } from "node:fs/promises";
 
-describe("URL resolution fallback chain", () => {
-  const mockGetAgentDir = vi.mocked(getAgentDir);
-  const mockGetProjectSettings = vi.mocked(
-    mockSettingsManager.getProjectSettings,
-  );
-  const mockGetGlobalSettings = vi.mocked(
-    mockSettingsManager.getGlobalSettings,
-  );
-
-  afterEach(() => {
-    delete process.env.LLAMA_SERVER_URL;
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    // Default: no settings found
-    mockGetProjectSettings.mockReturnValue({});
-    mockGetGlobalSettings.mockReturnValue({});
-    manager = createSettingsManager();
-  });
-
-  it("should return default URL when no config is found", async () => {
-    // Ensure env var is not set (and not inherited from environment)
-    delete process.env.LLAMA_SERVER_URL;
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual([LLAMA_SERVER_URL]);
-  });
-
-  it("should prioritize env variable over project config", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://localhost:9999",
-    });
-    process.env.LLAMA_SERVER_URL = "http://env-url:8080";
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual(["http://env-url:8080"]);
-  });
-
-  it("should use env variable when no other config exists", async () => {
-    process.env.LLAMA_SERVER_URL = "http://env-url:8080";
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual(["http://env-url:8080"]);
-  });
-
-  it("should use legacy llamaServerUrl when env is not set", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://project:9999",
-    });
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual(["http://project:9999"]);
-  });
-
-  it("should use global settings when no project config or env exists", async () => {
-    mockGetGlobalSettings.mockReturnValue({
-      llamaServerUrl: "http://global:8080",
-    });
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual(["http://global:8080"]);
-  });
-
-  it("should strip trailing slashes from resolved URL", async () => {
-    process.env.LLAMA_SERVER_URL = "http://localhost:8080/";
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual(["http://localhost:8080"]);
-  });
-
-  it("should cache the resolved URL on subsequent calls", async () => {
-    process.env.LLAMA_SERVER_URL = "http://first:8080";
-
-    const result1 = await manager.resolveUrls();
-    const result2 = await manager.resolveUrls();
-
-    expect(result1).toEqual(["http://first:8080"]);
-    expect(result2).toEqual(["http://first:8080"]);
-  });
-
-  it("should handle multiple URLs separated by semicolons", async () => {
-    process.env.LLAMA_SERVER_URL = "http://first:8080;http://second:9090/";
-
-    const result = await manager.resolveUrls();
-
-    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 manager = createSettingsManager();
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual([LLAMA_SERVER_URL]);
-    expect(manager.takeWarnings()).toEqual([
-      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
-    ]);
-    expect(manager.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 manager = createSettingsManager();
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual(["http://good:8080"]);
-    expect(manager.takeWarnings()).toEqual([
-      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
-    ]);
-    expect(manager.takeWarnings()).toEqual([]); // drained
-  });
-});
-
-describe("llamaSettings.servers resolution", () => {
+describe("API key resolution", () => {
   const mockGetAgentDir = vi.mocked(getAgentDir);
-  const mockGetProjectSettings = vi.mocked(
-    mockSettingsManager.getProjectSettings,
-  );
-  const mockGetGlobalSettings = vi.mocked(
-    mockSettingsManager.getGlobalSettings,
-  );
 
-  afterEach(() => {
-    delete process.env.LLAMA_SERVER_URL;
-  });
+  afterEach(() => {});
 
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    mockGetProjectSettings.mockReturnValue({});
-    mockGetGlobalSettings.mockReturnValue({});
+    mockReadStoredCredential.mockReturnValue(undefined);
     manager = createSettingsManager();
   });
 
-  it("should resolve URLs from llamaSettings.servers in project config", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [
-          { url: "http://project-server:8080" },
-          { url: "http://project-server2:9090" },
-        ],
-      },
-    });
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual([
-      "http://project-server:8080",
-      "http://project-server2:9090",
-    ]);
-  });
-
-  it("should prioritize project servers over global servers", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://project:8080" }],
-      },
-    });
-    mockGetGlobalSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://global:9090" }],
-      },
-    });
+  it("should return placeholder when credential is not found", () => {
+    mockReadStoredCredential.mockReturnValue(undefined);
 
-    const result = await manager.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://project:8080"]);
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
-  it("should use global servers when no project servers exist", async () => {
-    mockGetGlobalSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://global:8080" }],
-      },
-    });
+  it("should return placeholder when apiKey is missing from credential", () => {
+    mockReadStoredCredential.mockReturnValue({});
 
-    const result = await manager.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://global:8080"]);
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
-  it("should prioritize env variable over servers", async () => {
-    process.env.LLAMA_SERVER_URL = "http://env:8080";
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://server:9090" }],
-      },
-    });
+  it("should return the key when present in credential", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "test-api-key" });
 
-    const result = await manager.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://env:8080"]);
+    expect(result).toEqual("test-api-key");
   });
 
-  it("should use servers when env is not set", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://server:9090" }],
-      },
-    });
+  it("should call readStoredCredential with the provider ID", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "test-key" });
 
-    const result = await manager.resolveUrls();
+    manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://server:9090"]);
+    expect(mockReadStoredCredential).toHaveBeenCalledWith(
+      "llama-server=http://127.0.0.1:8080",
+    );
   });
 
-  it("should prioritize servers over legacy llamaServerUrl", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://legacy:8080",
-      llamaSettings: {
-        servers: [{ url: "http://server:9090" }],
-      },
-    });
+  it("should resolve $VAR env reference from process.env", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$MY_API_KEY" });
+    process.env.MY_API_KEY = "env-resolved-key";
 
-    const result = await manager.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://server:9090"]);
+    expect(result).toBe("env-resolved-key");
+    delete process.env.MY_API_KEY;
   });
 
-  it("should use legacy llamaServerUrl when servers is empty", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaServerUrl: "http://legacy:8080",
-      llamaSettings: {
-        servers: [],
-      },
-    });
+  it("should resolve ${VAR} braced env reference from process.env", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "${MY_API_KEY}" });
+    process.env.MY_API_KEY = "braced-resolved-key";
 
-    const result = await manager.resolveUrls();
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(["http://legacy:8080"]);
+    expect(result).toBe("braced-resolved-key");
+    delete process.env.MY_API_KEY;
   });
 
-  it("should strip trailing slashes from server URLs", async () => {
-    mockGetProjectSettings.mockReturnValue({
-      llamaSettings: {
-        servers: [{ url: "http://localhost:8080/" }],
-      },
+  it("should prefer credential.env over process.env", () => {
+    mockReadStoredCredential.mockReturnValue({
+      key: "$MY_KEY",
+      env: { MY_KEY: "credential-env-value" },
     });
-
-    const result = await manager.resolveUrls();
-
-    expect(result).toEqual(["http://localhost:8080"]);
-  });
-});
-
-describe("API key resolution", () => {
-  const mockGetAgentDir = vi.mocked(getAgentDir);
-
-  afterEach(() => {});
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    mockReadStoredCredential.mockReturnValue(undefined);
-    manager = createSettingsManager();
-  });
-
-  it("should return placeholder when credential is not found", () => {
-    mockReadStoredCredential.mockReturnValue(undefined);
+    process.env.MY_KEY = "process-env-value";
 
     const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(API_KEY_PLACEHOLDER);
+    expect(result).toBe("credential-env-value");
+    delete process.env.MY_KEY;
   });
 
-  it("should return placeholder when apiKey is missing from credential", () => {
-    mockReadStoredCredential.mockReturnValue({});
+  it("should return placeholder when env var is not set", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$UNSET_VAR" });
+    delete process.env.UNSET_VAR;
 
     const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual(API_KEY_PLACEHOLDER);
+    expect(result).toBe(API_KEY_PLACEHOLDER);
   });
 
-  it("should return the key when present in credential", () => {
-    mockReadStoredCredential.mockReturnValue({ key: "test-api-key" });
+  // Shell command tests are covered by Pi core's resolve-config-value tests.
+  // The local implementation delegates to execSync which is tested there.
+
+  it("should escape $$ as literal $", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$$LITERAL" });
 
     const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result).toEqual("test-api-key");
+    expect(result).toBe("$LITERAL");
   });
 
-  it("should call readStoredCredential with the provider ID", () => {
-    mockReadStoredCredential.mockReturnValue({ key: "test-key" });
+  it("should escape $! as literal !", () => {
+    mockReadStoredCredential.mockReturnValue({ key: "$!LITERAL" });
 
-    manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
+    const result = manager.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(mockReadStoredCredential).toHaveBeenCalledWith(
-      "llama-server=http://127.0.0.1:8080",
-    );
+    expect(result).toBe("!LITERAL");
   });
 });
 

package/tests/utils/credentialResolver.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { CredentialResolver } from "../../src/utils/credentialResolver";
+
+describe("CredentialResolver", () => {
+  const resolver = new CredentialResolver();
+
+  describe("resolve", () => {
+    it("returns placeholder for empty key", () => {
+      expect(resolver.resolve("")).toBe("sk-placeholder");
+      expect(resolver.resolve(undefined as any)).toBe("sk-placeholder");
+    });
+
+    it("returns literal key as-is", () => {
+      expect(resolver.resolve("sk-abc123")).toBe("sk-abc123");
+      expect(resolver.resolve("plain-key-without-dollars")).toBe(
+        "plain-key-without-dollars",
+      );
+    });
+
+    it("resolves escape sequences $$", () => {
+      expect(resolver.resolve("$$literal")).toBe("$literal");
+    });
+
+    it("resolves escape sequences $!", () => {
+      expect(resolver.resolve("$!bang")).toBe("!bang");
+    });
+
+    it("resolves $VAR from credential.env", () => {
+      expect(resolver.resolve("$MY_KEY", { MY_KEY: "from-env" })).toBe(
+        "from-env",
+      );
+    });
+
+    it("resolves ${VAR} from credential.env", () => {
+      expect(resolver.resolve("${MY_KEY}", { MY_KEY: "from-env" })).toBe(
+        "from-env",
+      );
+    });
+
+    it("resolves $VAR from process.env as fallback", () => {
+      process.env.TEST_PROCESS_VAR = "process-value";
+      expect(resolver.resolve("$TEST_PROCESS_VAR")).toBe("process-value");
+      delete process.env.TEST_PROCESS_VAR;
+    });
+
+    it("prioritizes credential.env over process.env", () => {
+      process.env.PREF_KEY = "process-value";
+      expect(
+        resolver.resolve("$PREF_KEY", { PREF_KEY: "credential-value" }),
+      ).toBe("credential-value");
+      delete process.env.PREF_KEY;
+    });
+
+    it("returns placeholder when env var is missing", () => {
+      expect(resolver.resolve("$UNSET_VAR")).toBe("sk-placeholder");
+      expect(resolver.resolve("${UNSET_VAR}", { OTHER_KEY: "value" })).toBe(
+        "sk-placeholder",
+      );
+    });
+
+    it("returns placeholder for invalid env var syntax", () => {
+      expect(resolver.resolve("$123invalid")).toBe("sk-placeholder");
+      expect(resolver.resolve("$has-dash")).toBe("sk-placeholder");
+    });
+  });
+});

package/tests/utils/urlResolver.test.ts

@@ -0,0 +1,116 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { UrlResolver } from "../../src/utils/urlResolver";
+
+function createResolver(
+  getLlamaSettings: () => Promise<Record<string, unknown>>,
+  getMergedSettings: () => Promise<Record<string, unknown>>,
+) {
+  return new UrlResolver({ getLlamaSettings, getMergedSettings });
+}
+
+describe("UrlResolver", () => {
+  beforeEach(() => {
+    delete process.env.LLAMA_SERVER_URL;
+  });
+
+  describe("resolveUrls", () => {
+    it("falls back to default when nothing is configured", async () => {
+      const resolver = createResolver(
+        () => Promise.resolve({}),
+        () => Promise.resolve({}),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://127.0.0.1:8080"]);
+    });
+
+    it("prioritizes env variable over all config sources", async () => {
+      process.env.LLAMA_SERVER_URL = "http://env:9090";
+      const resolver = createResolver(
+        () =>
+          Promise.resolve({
+            servers: [{ url: "http://servers:8080" }],
+          }),
+        () => Promise.resolve({ llamaServerUrl: "http://legacy:7070" }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://env:9090"]);
+    });
+
+    it("prioritizes llamaSettings.servers over legacy llamaServerUrl", async () => {
+      const resolver = createResolver(
+        () =>
+          Promise.resolve({
+            servers: [{ url: "http://servers:8080" }],
+          }),
+        () => Promise.resolve({ llamaServerUrl: "http://legacy:7070" }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://servers:8080"]);
+    });
+
+    it("falls back to legacy when servers is empty", async () => {
+      const resolver = createResolver(
+        () => Promise.resolve({ servers: [] }),
+        () => Promise.resolve({ llamaServerUrl: "http://legacy:7070" }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://legacy:7070"]);
+    });
+
+    it("returns empty arrays from settings when values are falsy", async () => {
+      const resolver = createResolver(
+        () => Promise.resolve({ servers: undefined }),
+        () => Promise.resolve({ llamaServerUrl: undefined }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://127.0.0.1:8080"]);
+    });
+  });
+
+  describe("warnings", () => {
+    it("collects warnings for invalid env URLs", async () => {
+      process.env.LLAMA_SERVER_URL = "invalid-url;http://good:8080";
+      const resolver = createResolver(
+        () => Promise.resolve({}),
+        () => Promise.resolve({}),
+      );
+
+      await resolver.resolveUrls();
+      expect(resolver.takeWarnings()).toEqual([
+        "Ignoring invalid server URL 'invalid-url' (needs http(s)://)",
+      ]);
+    });
+
+    it("collects warnings for invalid server URLs", async () => {
+      const resolver = createResolver(
+        () =>
+          Promise.resolve({
+            servers: [{ url: "bad-url" }, { url: "http://good:8080" }],
+          }),
+        () => Promise.resolve({}),
+      );
+
+      await resolver.resolveUrls();
+      expect(resolver.takeWarnings()).toEqual([
+        "Ignoring invalid server URL 'bad-url' (needs http(s)://)",
+      ]);
+    });
+
+    it("clears warnings after takeWarnings()", async () => {
+      process.env.LLAMA_SERVER_URL = "bad;http://good:8080";
+      const resolver = createResolver(
+        () => Promise.resolve({}),
+        () => Promise.resolve({}),
+      );
+
+      await resolver.resolveUrls();
+      expect(resolver.takeWarnings()).toHaveLength(1);
+      expect(resolver.takeWarnings()).toEqual([]);
+    });
+  });
+});