saeeol 1.3.0 → 1.3.1

package/test/saeeol/model-info-panel-utils.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test"
+import { avgPrice, fmtCachedPrice, fmtContext, fmtPrice } from "../../src/overlay/components/model-info-panel-utils"
+
+describe("model info panel price formatting", () => {
+  test("fmtPrice returns Free for zero", () => {
+    expect(fmtPrice(0)).toBe("Free")
+  })
+
+  test("fmtPrice uses four decimals for very small prices", () => {
+    expect(fmtPrice(0.0095)).toBe("$0.0095/1M")
+  })
+
+  test("fmtPrice uses two decimals for standard prices", () => {
+    expect(fmtPrice(3)).toBe("$3.00/1M")
+  })
+
+  test("fmtCachedPrice returns cache read price when available", () => {
+    expect(fmtCachedPrice({ input: 3, output: 15, cache: { read: 0.3, write: 0 } })).toBe("$0.30/1M")
+  })
+
+  test("fmtCachedPrice returns Free for free models", () => {
+    expect(fmtCachedPrice({ input: 0, output: 0, cache: { read: 0, write: 0 } })).toBe("Free")
+  })
+
+  test("fmtCachedPrice returns null without cache read", () => {
+    expect(fmtCachedPrice({ input: 3, output: 15, cache: { read: 0, write: 0 } })).toBeNull()
+  })
+
+  test("avgPrice uses cache weighted formula when cache read exists", () => {
+    const val = avgPrice({ input: 3, output: 15, cache: { read: 0.3, write: 0 } })
+    expect(val).toBe(2.31)
+  })
+
+  test("avgPrice uses input and output weighted formula without cache read", () => {
+    const val = avgPrice({ input: 3, output: 15, cache: { read: 0, write: 0 } })
+    expect(val).toBe(4.2)
+  })
+})
+
+describe("model info panel context formatting", () => {
+  test("formats thousands as K", () => {
+    expect(fmtContext(128000)).toBe("128K")
+  })
+
+  test("formats millions as M", () => {
+    expect(fmtContext(1000000)).toBe("1M")
+  })
+
+  test("returns exact value for small contexts", () => {
+    expect(fmtContext(800)).toBe("800")
+  })
+})

package/test/saeeol/model-info-panel.types.test.ts

@@ -0,0 +1,7 @@
+import type { Model as SDKModel } from "@saeeol/sdk/v2"
+import { ModelInfoPanel } from "@/saeeol/components/model-info-panel"
+
+type Assert<T extends true> = T
+type Props = Parameters<typeof ModelInfoPanel>[0]
+
+type _SyncModelMatchesPanel = Assert<SDKModel extends Props["model"] ? true : false>

package/test/saeeol/models-401-fallback.test.ts

@@ -0,0 +1,52 @@
+// Integration: when fetchSaeeolModels returns a 401 error result, ModelCache
+// surfaces the failure and caches empty models (allowing re-auth via /connect).
+// The real 401-fallback unit test lives in packages/gateway/test/api/models.test.ts.
+
+import { test, expect, mock } from "bun:test"
+import path from "path"
+import * as Log from "@saeeol/core/util/log"
+
+Log.init({ print: false })
+
+// Simulate a 401 typed error result from the gateway
+mock.module("@saeeol/gateway", () => ({
+  fetchSaeeolModels: async () => ({
+    models: {},
+    error: { kind: "unauthorized", status: 401 },
+  }),
+  SAEEOL_OPENROUTER_BASE: "https://api.saeeol.ai/api/openrouter",
+}))
+
+mock.module("saeeol-copilot-auth", () => ({ default: () => ({}) }))
+mock.module("saeeol-anthropic-auth", () => ({ default: () => ({}) }))
+mock.module("@gitlab/saeeol-gitlab-auth", () => ({ default: () => ({}) }))
+
+import { tmpdir } from "../fixture/fixture"
+import { Instance } from "../../src/project/instance"
+import { ModelCache } from "../../src/provider/model-cache"
+
+const CONFIG = JSON.stringify({ $schema: "https://app.saeeol.ai/config.json" })
+
+async function withInstance<T>(fn: () => Promise<T>): Promise<T> {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(path.join(dir, "saeeol.json"), CONFIG)
+    },
+  })
+  return Instance.provide({ directory: tmp.path, fn })
+}
+
+test("401 from gateway sets provider as failed in ModelCache", async () => {
+  ModelCache.clear("saeeol")
+  await withInstance(() => ModelCache.fetch("saeeol"))
+  expect(ModelCache.failedProviders()).toContain("saeeol")
+  expect(ModelCache.getFailure("saeeol")).toMatchObject({ kind: "unauthorized", status: 401 })
+})
+
+test("401 from gateway caches empty models (not undefined)", async () => {
+  ModelCache.clear("saeeol")
+  await withInstance(() => ModelCache.fetch("saeeol"))
+  const cached = ModelCache.get("saeeol")
+  expect(cached).toBeDefined()
+  expect(Object.keys(cached!)).toHaveLength(0)
+})

package/test/saeeol/modes-migrator.test.ts

@@ -0,0 +1,320 @@
+import { test, expect, describe } from "bun:test"
+import { ModesMigrator } from "../../src/overlay/modes-migrator"
+import { tmpdir } from "../fixture/fixture"
+import path from "path"
+
+describe("ModesMigrator", () => {
+  describe("isDefaultMode", () => {
+    test("returns true for default modes", () => {
+      expect(ModesMigrator.isDefaultMode("code")).toBe(true)
+      expect(ModesMigrator.isDefaultMode("architect")).toBe(true)
+      expect(ModesMigrator.isDefaultMode("ask")).toBe(true)
+      expect(ModesMigrator.isDefaultMode("debug")).toBe(true)
+      expect(ModesMigrator.isDefaultMode("orchestrator")).toBe(true)
+    })
+
+    test("returns false for custom modes", () => {
+      expect(ModesMigrator.isDefaultMode("translate")).toBe(false)
+      expect(ModesMigrator.isDefaultMode("my-custom-mode")).toBe(false)
+      expect(ModesMigrator.isDefaultMode("reviewer")).toBe(false)
+    })
+  })
+
+  describe("convertPermissions", () => {
+    test("converts simple groups to permissions and denies missing", () => {
+      const groups = ["read", "edit", "command"]
+      const permissions = ModesMigrator.convertPermissions(groups)
+
+      expect(permissions.read).toBe("allow")
+      expect(permissions.edit).toBe("allow")
+      expect(permissions.bash).toBe("allow")
+      expect(permissions.mcp).toBe("deny") // Not in groups, should be denied
+    })
+
+    test("maps browser group to bash permission", () => {
+      const groups = ["browser"]
+      const permissions = ModesMigrator.convertPermissions(groups)
+
+      expect(permissions.bash).toBe("allow")
+      expect(permissions.read).toBe("deny")
+      expect(permissions.edit).toBe("deny")
+      expect(permissions.mcp).toBe("deny")
+    })
+
+    test("maps mcp group to mcp permission", () => {
+      const groups = ["mcp"]
+      const permissions = ModesMigrator.convertPermissions(groups)
+
+      expect(permissions.mcp).toBe("allow")
+      expect(permissions.read).toBe("deny")
+      expect(permissions.edit).toBe("deny")
+      expect(permissions.bash).toBe("deny")
+    })
+
+    test("converts fileRegex groups to restricted permissions", () => {
+      const groups: ModesMigrator.SaeeolMode["groups"] = [
+        "read",
+        ["edit", { fileRegex: "\\.md$", description: "Markdown only" }],
+      ]
+      const permissions = ModesMigrator.convertPermissions(groups)
+
+      expect(permissions.read).toBe("allow")
+      expect(permissions.edit).toEqual({
+        "\\.md$": "allow",
+        "*": "deny",
+      })
+      expect(permissions.bash).toBe("deny")
+      expect(permissions.mcp).toBe("deny")
+    })
+
+    test("handles tuple without fileRegex", () => {
+      const groups: ModesMigrator.SaeeolMode["groups"] = [["edit", {}]]
+      const permissions = ModesMigrator.convertPermissions(groups)
+
+      expect(permissions.edit).toBe("allow")
+      expect(permissions.read).toBe("deny")
+      expect(permissions.bash).toBe("deny")
+      expect(permissions.mcp).toBe("deny")
+    })
+
+    test("passes through unknown groups but still denies standard permissions", () => {
+      const groups = ["custom-group"]
+      const permissions = ModesMigrator.convertPermissions(groups)
+
+      expect(permissions["custom-group"]).toBe("allow")
+      expect(permissions.read).toBe("deny")
+      expect(permissions.edit).toBe("deny")
+      expect(permissions.bash).toBe("deny")
+      expect(permissions.mcp).toBe("deny")
+    })
+
+    test("denies bash and mcp when only read and edit are allowed", () => {
+      const groups = ["read", "edit"]
+      const permissions = ModesMigrator.convertPermissions(groups)
+
+      expect(permissions.read).toBe("allow")
+      expect(permissions.edit).toBe("allow")
+      expect(permissions.bash).toBe("deny")
+      expect(permissions.mcp).toBe("deny")
+    })
+  })
+
+  describe("convertMode", () => {
+    test("converts full mode to agent config", () => {
+      const mode: ModesMigrator.SaeeolMode = {
+        slug: "translate",
+        name: "Translate",
+        roleDefinition: "You are a translator...",
+        customInstructions: "Translate accurately.",
+        groups: ["read", ["edit", { fileRegex: "\\.json$" }]],
+      }
+
+      const agent = ModesMigrator.convertMode(mode)
+
+      expect(agent.mode).toBe("primary")
+      expect(agent.prompt).toBe("You are a translator...\n\nTranslate accurately.")
+      expect(agent.permission?.read).toBe("allow")
+      expect(agent.permission?.edit).toEqual({
+        "\\.json$": "allow",
+        "*": "deny",
+      })
+    })
+
+    test("uses description when available", () => {
+      const mode: ModesMigrator.SaeeolMode = {
+        slug: "test",
+        name: "Test",
+        roleDefinition: "Role",
+        description: "Custom description",
+        groups: [],
+      }
+
+      const agent = ModesMigrator.convertMode(mode)
+      expect(agent.description).toBe("Custom description")
+    })
+
+    test("falls back to whenToUse for description", () => {
+      const mode: ModesMigrator.SaeeolMode = {
+        slug: "test",
+        name: "Test",
+        roleDefinition: "Role",
+        whenToUse: "When to use this mode",
+        groups: [],
+      }
+
+      const agent = ModesMigrator.convertMode(mode)
+      expect(agent.description).toBe("When to use this mode")
+    })
+
+    test("falls back to name for description", () => {
+      const mode: ModesMigrator.SaeeolMode = {
+        slug: "test",
+        name: "Test Mode",
+        roleDefinition: "Role",
+        groups: [],
+      }
+
+      const agent = ModesMigrator.convertMode(mode)
+      expect(agent.description).toBe("Test Mode")
+    })
+
+    test("handles mode without customInstructions", () => {
+      const mode: ModesMigrator.SaeeolMode = {
+        slug: "test",
+        name: "Test",
+        roleDefinition: "You are a test agent.",
+        groups: ["read"],
+      }
+
+      const agent = ModesMigrator.convertMode(mode)
+      expect(agent.prompt).toBe("You are a test agent.")
+    })
+  })
+
+  describe("readModesFile", () => {
+    test("returns empty array for non-existent file", async () => {
+      const modes = await ModesMigrator.readModesFile("/non/existent/path.yaml")
+      expect(modes).toEqual([])
+    })
+
+    test("reads and parses yaml file", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(
+            path.join(dir, "modes.yaml"),
+            `customModes:
+  - slug: translate
+    name: Translate
+    roleDefinition: You are a translator
+    groups:
+      - read
+      - edit`,
+          )
+        },
+      })
+
+      const modes = await ModesMigrator.readModesFile(path.join(tmp.path, "modes.yaml"))
+      expect(modes).toHaveLength(1)
+      expect(modes[0].slug).toBe("translate")
+      expect(modes[0].name).toBe("Translate")
+    })
+
+    test("returns empty array for file without customModes", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(path.join(dir, "modes.yaml"), "someOtherKey: value")
+        },
+      })
+
+      const modes = await ModesMigrator.readModesFile(path.join(tmp.path, "modes.yaml"))
+      expect(modes).toEqual([])
+    })
+  })
+
+  describe("migrate", () => {
+    test("skips default modes", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(
+            path.join(dir, ".saeeolmodes"),
+            `customModes:
+  - slug: code
+    name: Code
+    roleDefinition: Default code mode
+    groups:
+      - read
+      - edit
+  - slug: translate
+    name: Translate
+    roleDefinition: Custom translator
+    groups:
+      - read`,
+          )
+        },
+      })
+
+      const result = await ModesMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
+
+      expect(result.skipped).toHaveLength(1)
+      expect(result.skipped[0].slug).toBe("code")
+      expect(result.agents).toHaveProperty("translate")
+      expect(result.agents).not.toHaveProperty("code")
+    })
+
+    test("deduplicates modes by slug with later entries winning", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          // Create global settings dir
+          const globalDir = path.join(dir, "global-settings")
+          await Bun.write(
+            path.join(globalDir, "custom_modes.yaml"),
+            `customModes:
+  - slug: translate
+    name: Translate Global
+    roleDefinition: Global translator
+    groups:
+      - read`,
+          )
+
+          // Create project .saeeolmodes (should win)
+          await Bun.write(
+            path.join(dir, ".saeeolmodes"),
+            `customModes:
+  - slug: translate
+    name: Translate Project
+    roleDefinition: Project translator
+    groups:
+      - read
+      - edit`,
+          )
+
+          return globalDir
+        },
+      })
+
+      const result = await ModesMigrator.migrate({
+        projectDir: tmp.path,
+        globalSettingsDir: tmp.extra,
+      })
+
+      expect(result.agents.translate.prompt).toBe("Project translator")
+    })
+
+    test("returns empty agents when no custom modes exist", async () => {
+      await using tmp = await tmpdir()
+
+      const result = await ModesMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
+
+      expect(Object.keys(result.agents)).toHaveLength(0)
+      expect(result.skipped).toHaveLength(0)
+    })
+
+    test("migrates multiple custom modes", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(
+            path.join(dir, ".saeeolmodes"),
+            `customModes:
+  - slug: translate
+    name: Translate
+    roleDefinition: Translator
+    groups:
+      - read
+  - slug: reviewer
+    name: Reviewer
+    roleDefinition: Code reviewer
+    groups:
+      - read
+      - edit`,
+          )
+        },
+      })
+
+      const result = await ModesMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
+
+      expect(Object.keys(result.agents)).toHaveLength(2)
+      expect(result.agents).toHaveProperty("translate")
+      expect(result.agents).toHaveProperty("reviewer")
+    })
+  })
+})

package/test/saeeol/nvidia-headers.test.ts

@@ -0,0 +1,74 @@
+import { expect } from "bun:test"
+import path from "path"
+import { Effect, Layer } from "effect"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+import { Env } from "../../src/env"
+import { Provider } from "../../src/provider/provider"
+import { ProviderID } from "../../src/provider/schema"
+
+const it = testEffect(Layer.mergeAll(Provider.defaultLayer, Env.defaultLayer, CrossSpawnSpawner.defaultLayer))
+
+function withNvidiaKey<A, E, R>(self: Effect.Effect<A, E, R>) {
+  return Effect.gen(function* () {
+    const env = yield* Env.Service
+    yield* env.set("NVIDIA_API_KEY", "test-api-key")
+    yield* Effect.addFinalizer(() => env.remove("NVIDIA_API_KEY"))
+    return yield* self
+  })
+}
+
+it.live("nvidia provider includes saeeol billing origin header", () =>
+  provideTmpdirInstance(() =>
+    withNvidiaKey(
+      Provider.Service.use((provider) =>
+        Effect.gen(function* () {
+          const providers = yield* provider.list()
+          const headers = providers[ProviderID.make("nvidia")].options.headers
+
+          expect(headers["HTTP-Referer"]).toBe("https://saeeol.ai/")
+          expect(headers["X-Title"]).toBe("SAEEOL")
+          expect(headers["X-BILLING-INVOKE-ORIGIN"]).toBe("saeeol")
+        }),
+      ),
+    ),
+  ),
+)
+
+it.live("nvidia billing origin header can be overridden from config", () =>
+  provideTmpdirInstance((dir) =>
+    Effect.gen(function* () {
+      yield* Effect.promise(() =>
+        Bun.write(
+          path.join(dir, "saeeol.json"),
+          JSON.stringify({
+            $schema: "https://app.saeeol.ai/config.json",
+            provider: {
+              nvidia: {
+                options: {
+                  headers: {
+                    "X-BILLING-INVOKE-ORIGIN": "CustomOrigin",
+                  },
+                },
+              },
+            },
+          }),
+        ),
+      )
+
+      return yield* withNvidiaKey(
+        Provider.Service.use((provider) =>
+          Effect.gen(function* () {
+            const providers = yield* provider.list()
+            const headers = providers[ProviderID.make("nvidia")].options.headers
+
+            expect(headers["HTTP-Referer"]).toBe("https://saeeol.ai/")
+            expect(headers["X-Title"]).toBe("SAEEOL")
+            expect(headers["X-BILLING-INVOKE-ORIGIN"]).toBe("CustomOrigin")
+          }),
+        ),
+      )
+    }),
+  ),
+)

package/test/saeeol/patch-jsonc.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test"
+import { applyEdits, modify, findNodeAtLocation, parseTree } from "jsonc-parser"
+
+// Replicate patchJsonc logic locally to test it in isolation
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+}
+
+function patchJsonc(input: string, patch: unknown, path: string[] = []): string {
+  if (!isRecord(patch)) {
+    const edits = modify(input, path, patch === null ? undefined : patch, {
+      formattingOptions: { insertSpaces: true, tabSize: 2 },
+    })
+    return applyEdits(input, edits)
+  }
+
+  if (path.length > 0) {
+    const tree = parseTree(input)
+    const node = tree && findNodeAtLocation(tree, path)
+    if (node && node.type !== "object") {
+      const edits = modify(input, path, patch, {
+        formattingOptions: { insertSpaces: true, tabSize: 2 },
+      })
+      return applyEdits(input, edits)
+    }
+  }
+
+  return Object.entries(patch).reduce((result, [key, value]) => {
+    if (value === undefined) return result
+    return patchJsonc(result, value, [...path, key])
+  }, input)
+}
+
+describe("patchJsonc scalar-to-object transition", () => {
+  test("sets object when node does not yet exist", () => {
+    const input = `{ "permission": {} }`
+    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
+    const parsed = JSON.parse(result)
+    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
+  })
+
+  test("transitions permission rule from string to object (the bug scenario)", () => {
+    // bash is stored as a plain string "ask" in the JSONC file
+    const input = `{ "permission": { "bash": "ask" } }`
+    // User adds exception "uname" → "allow"; this would previously throw:
+    // "Can not add index to parent of type string"
+    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
+    const parsed = JSON.parse(result)
+    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
+  })
+
+  test("does not disturb sibling keys when replacing scalar", () => {
+    const input = `{ "permission": { "bash": "ask", "glob": "allow" } }`
+    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
+    const parsed = JSON.parse(result)
+    expect(parsed.permission.glob).toBe("allow")
+    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
+  })
+
+  test("updates existing object permission by adding a new key", () => {
+    const input = `{ "permission": { "bash": { "*": "ask" } } }`
+    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
+    const parsed = JSON.parse(result)
+    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
+  })
+
+  test("plain string permission update still works", () => {
+    const input = `{ "permission": { "bash": "allow" } }`
+    const result = patchJsonc(input, { permission: { bash: "ask" } })
+    const parsed = JSON.parse(result)
+    expect(parsed.permission.bash).toBe("ask")
+  })
+})