saeeol 1.2.4 → 1.2.7

package/test/plugin/codex.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  parseJwtClaims,
-  extractAccountIdFromClaims,
-  extractAccountId,
-  type IdTokenClaims,
-} from "../../src/plugin/codex"
-
-function createTestJwt(payload: object): string {
-  const header = Buffer.from(JSON.stringify({ alg: "none" })).toString("base64url")
-  const body = Buffer.from(JSON.stringify(payload)).toString("base64url")
-  return `${header}.${body}.sig`
-}
-
-describe("plugin.codex", () => {
-  describe("parseJwtClaims", () => {
-    test("parses valid JWT with claims", () => {
-      const payload = { email: "test@example.com", chatgpt_account_id: "acc-123" }
-      const jwt = createTestJwt(payload)
-      const claims = parseJwtClaims(jwt)
-      expect(claims).toEqual(payload)
-    })
-
-    test("returns undefined for JWT with less than 3 parts", () => {
-      expect(parseJwtClaims("invalid")).toBeUndefined()
-      expect(parseJwtClaims("only.two")).toBeUndefined()
-    })
-
-    test("returns undefined for invalid base64", () => {
-      expect(parseJwtClaims("a.!!!invalid!!!.b")).toBeUndefined()
-    })
-
-    test("returns undefined for invalid JSON payload", () => {
-      const header = Buffer.from("{}").toString("base64url")
-      const invalidJson = Buffer.from("not json").toString("base64url")
-      expect(parseJwtClaims(`${header}.${invalidJson}.sig`)).toBeUndefined()
-    })
-  })
-
-  describe("extractAccountIdFromClaims", () => {
-    test("extracts chatgpt_account_id from root", () => {
-      const claims: IdTokenClaims = { chatgpt_account_id: "acc-root" }
-      expect(extractAccountIdFromClaims(claims)).toBe("acc-root")
-    })
-
-    test("extracts chatgpt_account_id from nested https://api.openai.com/auth", () => {
-      const claims: IdTokenClaims = {
-        "https://api.openai.com/auth": { chatgpt_account_id: "acc-nested" },
-      }
-      expect(extractAccountIdFromClaims(claims)).toBe("acc-nested")
-    })
-
-    test("prefers root over nested", () => {
-      const claims: IdTokenClaims = {
-        chatgpt_account_id: "acc-root",
-        "https://api.openai.com/auth": { chatgpt_account_id: "acc-nested" },
-      }
-      expect(extractAccountIdFromClaims(claims)).toBe("acc-root")
-    })
-
-    test("extracts from organizations array as fallback", () => {
-      const claims: IdTokenClaims = {
-        organizations: [{ id: "org-123" }, { id: "org-456" }],
-      }
-      expect(extractAccountIdFromClaims(claims)).toBe("org-123")
-    })
-
-    test("returns undefined when no accountId found", () => {
-      const claims: IdTokenClaims = { email: "test@example.com" }
-      expect(extractAccountIdFromClaims(claims)).toBeUndefined()
-    })
-  })
-
-  describe("extractAccountId", () => {
-    test("extracts from id_token first", () => {
-      const idToken = createTestJwt({ chatgpt_account_id: "from-id-token" })
-      const accessToken = createTestJwt({ chatgpt_account_id: "from-access-token" })
-      expect(
-        extractAccountId({
-          id_token: idToken,
-          access_token: accessToken,
-          refresh_token: "rt",
-        }),
-      ).toBe("from-id-token")
-    })
-
-    test("falls back to access_token when id_token has no accountId", () => {
-      const idToken = createTestJwt({ email: "test@example.com" })
-      const accessToken = createTestJwt({
-        "https://api.openai.com/auth": { chatgpt_account_id: "from-access" },
-      })
-      expect(
-        extractAccountId({
-          id_token: idToken,
-          access_token: accessToken,
-          refresh_token: "rt",
-        }),
-      ).toBe("from-access")
-    })
-
-    test("returns undefined when no tokens have accountId", () => {
-      const token = createTestJwt({ email: "test@example.com" })
-      expect(
-        extractAccountId({
-          id_token: token,
-          access_token: token,
-          refresh_token: "rt",
-        }),
-      ).toBeUndefined()
-    })
-
-    test("handles missing id_token", () => {
-      const accessToken = createTestJwt({ chatgpt_account_id: "acc-123" })
-      expect(
-        extractAccountId({
-          id_token: "",
-          access_token: accessToken,
-          refresh_token: "rt",
-        }),
-      ).toBe("acc-123")
-    })
-  })
-})

package/test/plugin/github-copilot-models.test.ts

@@ -1,261 +0,0 @@
-import { afterEach, expect, mock, test } from "bun:test"
-import { CopilotModels } from "@/plugin/github-copilot/models"
-import { CopilotAuthPlugin } from "@/plugin/github-copilot/copilot"
-
-const originalFetch = globalThis.fetch
-
-afterEach(() => {
-  globalThis.fetch = originalFetch
-})
-
-test("preserves temperature support from existing provider models", async () => {
-  globalThis.fetch = mock(() =>
-    Promise.resolve(
-      new Response(
-        JSON.stringify({
-          data: [
-            {
-              model_picker_enabled: true,
-              id: "gpt-4o",
-              name: "GPT-4o",
-              version: "gpt-4o-2024-05-13",
-              capabilities: {
-                family: "gpt",
-                limits: {
-                  max_context_window_tokens: 64000,
-                  max_output_tokens: 16384,
-                  max_prompt_tokens: 64000,
-                },
-                supports: {
-                  streaming: true,
-                  tool_calls: true,
-                },
-              },
-            },
-            {
-              model_picker_enabled: true,
-              id: "brand-new",
-              name: "Brand New",
-              version: "brand-new-2026-04-01",
-              capabilities: {
-                family: "test",
-                limits: {
-                  max_context_window_tokens: 32000,
-                  max_output_tokens: 8192,
-                  max_prompt_tokens: 32000,
-                },
-                supports: {
-                  streaming: true,
-                  tool_calls: false,
-                },
-              },
-            },
-          ],
-        }),
-        { status: 200 },
-      ),
-    ),
-  ) as unknown as typeof fetch
-
-  const models = await CopilotModels.get(
-    "https://api.githubcopilot.com",
-    {},
-    {
-      "gpt-4o": {
-        id: "gpt-4o",
-        providerID: "github-copilot",
-        api: {
-          id: "gpt-4o",
-          url: "https://api.githubcopilot.com",
-          npm: "@ai-sdk/openai-compatible",
-        },
-        name: "GPT-4o",
-        family: "gpt",
-        capabilities: {
-          temperature: true,
-          reasoning: false,
-          attachment: true,
-          toolcall: true,
-          input: {
-            text: true,
-            audio: false,
-            image: true,
-            video: false,
-            pdf: false,
-          },
-          output: {
-            text: true,
-            audio: false,
-            image: false,
-            video: false,
-            pdf: false,
-          },
-          interleaved: false,
-        },
-        cost: {
-          input: 0,
-          output: 0,
-          cache: {
-            read: 0,
-            write: 0,
-          },
-        },
-        limit: {
-          context: 64000,
-          output: 16384,
-        },
-        options: {},
-        headers: {},
-        release_date: "2024-05-13",
-        variants: {},
-        status: "active",
-      },
-    },
-  )
-
-  expect(models["gpt-4o"].capabilities.temperature).toBe(true)
-  expect(models["brand-new"].capabilities.temperature).toBe(true)
-})
-
-test("clears existing variants so refreshed models calculate provider-specific variants", async () => {
-  globalThis.fetch = mock(() =>
-    Promise.resolve(
-      new Response(
-        JSON.stringify({
-          data: [
-            {
-              model_picker_enabled: true,
-              id: "claude-opus-4.7",
-              name: "Claude Opus 4.7",
-              version: "claude-opus-4.7-2026-04-16",
-              supported_endpoints: ["/v1/messages"],
-              capabilities: {
-                family: "claude-opus",
-                limits: {
-                  max_context_window_tokens: 144000,
-                  max_output_tokens: 64000,
-                  max_prompt_tokens: 128000,
-                },
-                supports: {
-                  adaptive_thinking: true,
-                  streaming: true,
-                  tool_calls: true,
-                },
-              },
-            },
-          ],
-        }),
-        { status: 200 },
-      ),
-    ),
-  ) as unknown as typeof fetch
-
-  const models = await CopilotModels.get(
-    "https://api.githubcopilot.com",
-    {},
-    {
-      "claude-opus-4.7": {
-        id: "claude-opus-4.7",
-        providerID: "github-copilot",
-        api: {
-          id: "claude-opus-4.7",
-          url: "https://api.githubcopilot.com",
-          npm: "@ai-sdk/github-copilot",
-        },
-        name: "Claude Opus 4.7",
-        family: "claude-opus",
-        capabilities: {
-          temperature: true,
-          reasoning: true,
-          attachment: true,
-          toolcall: true,
-          input: {
-            text: true,
-            audio: false,
-            image: true,
-            video: false,
-            pdf: false,
-          },
-          output: {
-            text: true,
-            audio: false,
-            image: false,
-            video: false,
-            pdf: false,
-          },
-          interleaved: false,
-        },
-        cost: {
-          input: 0,
-          output: 0,
-          cache: {
-            read: 0,
-            write: 0,
-          },
-        },
-        limit: {
-          context: 144000,
-          input: 128000,
-          output: 64000,
-        },
-        options: {},
-        headers: {},
-        release_date: "2026-04-16",
-        variants: {
-          low: {
-            reasoningEffort: "low",
-          },
-        },
-        status: "active",
-      },
-    },
-  )
-
-  expect(models["claude-opus-4.7"].api.npm).toBe("@ai-sdk/anthropic")
-  expect(models["claude-opus-4.7"].variants).toBeUndefined()
-})
-
-test("remaps fallback oauth model urls to the enterprise host", async () => {
-  globalThis.fetch = mock(() => Promise.reject(new Error("timeout"))) as unknown as typeof fetch
-
-  const hooks = await CopilotAuthPlugin({
-    client: {} as never,
-    project: {} as never,
-    directory: "",
-    worktree: "",
-    experimental_workspace: {
-      register() {},
-    },
-    serverUrl: new URL("https://example.com"),
-    $: {} as never,
-  })
-
-  const models = await hooks.provider!.models!(
-    {
-      id: "github-copilot",
-      models: {
-        claude: {
-          id: "claude",
-          providerID: "github-copilot",
-          api: {
-            id: "claude-sonnet-4.5",
-            url: "https://api.githubcopilot.com/v1",
-            npm: "@ai-sdk/anthropic",
-          },
-        },
-      },
-    } as never,
-    {
-      auth: {
-        type: "oauth",
-        refresh: "token",
-        access: "token",
-        expires: Date.now() + 60_000,
-        enterpriseUrl: "ghe.example.com",
-      } as never,
-    },
-  )
-
-  expect(models.claude.api.url).toBe("https://copilot-api.ghe.example.com")
-  expect(models.claude.api.npm).toBe("@ai-sdk/github-copilot")
-})

package/test/plugin/install-concurrency.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-
-import { Process } from "@/util/process"
-import { Filesystem } from "@/util/filesystem"
-import { tmpdir } from "../fixture/fixture"
-
-const root = path.join(import.meta.dir, "../..")
-const worker = path.join(import.meta.dir, "../fixture/plug-worker.ts")
-
-type Msg = {
-  dir: string
-  target: string
-  mod: string
-  holdMs?: number
-}
-
-function run(msg: Msg) {
-  return Process.run([process.execPath, worker, JSON.stringify(msg)], {
-    cwd: root,
-    nothrow: true,
-  })
-}
-
-async function plugin(dir: string, kinds: Array<"server" | "tui">) {
-  const p = path.join(dir, "plugin")
-  const server = kinds.includes("server")
-  const tui = kinds.includes("tui")
-  const exports: Record<string, string> = {}
-  if (server) exports["./server"] = "./server.js"
-  if (tui) exports["./tui"] = "./tui.js"
-  await fs.mkdir(p, { recursive: true })
-  await Bun.write(
-    path.join(p, "package.json"),
-    JSON.stringify(
-      {
-        name: "acme",
-        version: "1.0.0",
-        ...(server ? { main: "./server.js" } : {}),
-        ...(Object.keys(exports).length ? { exports } : {}),
-      },
-      null,
-      2,
-    ),
-  )
-  return p
-}
-
-async function read(file: string) {
-  return Filesystem.readJson<{ plugin?: unknown[] }>(file)
-}
-
-function mods(prefix: string, n: number) {
-  return Array.from({ length: n }, (_, i) => `${prefix}-${i}@1.0.0`)
-}
-
-function expectPlugins(list: unknown[] | undefined, expectMods: string[]) {
-  expect(Array.isArray(list)).toBe(true)
-  const hit = (list ?? []).filter((item): item is string => typeof item === "string")
-  expect(hit.length).toBe(expectMods.length)
-  expect(new Set(hit)).toEqual(new Set(expectMods))
-}
-
-describe("plugin.install.concurrent", () => {
-  test("serializes concurrent server config updates across processes", async () => {
-    await using tmp = await tmpdir()
-    const target = await plugin(tmp.path, ["server"])
-    const all = mods("mod-server", 12)
-
-    const out = await Promise.all(
-      all.map((mod) =>
-        run({
-          dir: tmp.path,
-          target,
-          mod,
-          holdMs: 30,
-        }),
-      ),
-    )
-
-    expect(out.map((x) => x.code)).toEqual(Array.from({ length: all.length }, () => 0))
-    expect(out.map((x) => x.stderr.toString()).filter(Boolean)).toEqual([])
-
-    const cfg = await read(path.join(tmp.path, ".saeeol", "saeeol.jsonc"))
-    expectPlugins(cfg.plugin, all)
-  }, 25_000)
-
-  test("serializes concurrent server+tui config updates across processes", async () => {
-    await using tmp = await tmpdir()
-    const target = await plugin(tmp.path, ["server", "tui"])
-    const all = mods("mod-both", 10)
-
-    const out = await Promise.all(
-      all.map((mod) =>
-        run({
-          dir: tmp.path,
-          target,
-          mod,
-          holdMs: 30,
-        }),
-      ),
-    )
-
-    expect(out.map((x) => x.code)).toEqual(Array.from({ length: all.length }, () => 0))
-    expect(out.map((x) => x.stderr.toString()).filter(Boolean)).toEqual([])
-
-    const server = await read(path.join(tmp.path, ".saeeol", "saeeol.jsonc"))
-    const tui = await read(path.join(tmp.path, ".saeeol", "tui.jsonc"))
-    expectPlugins(server.plugin, all)
-    expectPlugins(tui.plugin, all)
-  }, 25_000)
-
-  test("preserves updates when existing config uses .json", async () => {
-    await using tmp = await tmpdir()
-    const target = await plugin(tmp.path, ["server"])
-    const cfg = path.join(tmp.path, ".saeeol", "saeeol.json")
-    await fs.mkdir(path.dirname(cfg), { recursive: true })
-    await Bun.write(cfg, JSON.stringify({ plugin: ["seed@1.0.0"] }, null, 2))
-
-    const next = mods("mod-json", 8)
-    const out = await Promise.all(
-      next.map((mod) =>
-        run({
-          dir: tmp.path,
-          target,
-          mod,
-          holdMs: 30,
-        }),
-      ),
-    )
-
-    expect(out.map((x) => x.code)).toEqual(Array.from({ length: next.length }, () => 0))
-    expect(out.map((x) => x.stderr.toString()).filter(Boolean)).toEqual([])
-
-    const json = await read(cfg)
-    expectPlugins(json.plugin, ["seed@1.0.0", ...next])
-    expect(await Filesystem.exists(path.join(tmp.path, ".saeeol", "saeeol.jsonc"))).toBe(false)
-  }, 25_000)
-})