@wenathlan/getry 2.0.154 → 2.0.155

package/tests/provider.models.test.ts

@@ -0,0 +1,250 @@
+/**
+ * @file models.test.ts
+ * @description
+ *  Tests for the models module of maene (`../models.js`). Confirms the
+ *  logical->physical routing helpers (`routeModelViaOmniRoute`,
+ *  `mapModelFor9Router`) plus catalog smoke checks: catalog presence,
+ *  lookup determinism, unknown-id fallback.
+ *
+ *  Runs on the vitest runner with `node:assert/strict` assertions. Imports only leaf modules; the
+ *  models module pulls only `node:crypto` + `node:os`.
+ */
+
+import assert from "node:assert/strict";
+import { it as test } from "vitest";
+
+import {
+  ALL_MODELS_WITH_PREFIX,
+  ANTIGRAVITY_MODELS,
+  DEFAULT_MODEL,
+  FALLBACKS,
+  GEMINICLI_MODELS,
+  getModel,
+  hasModel,
+  isCLIOnly,
+  listBareModelIds,
+  listModelIds,
+  MODEL_ALIASES_2026_08_25,
+  MODEL_CATALOG_2026_08_25,
+  MODEL_CATALOG_GROUPED,
+  MODEL_MAP_2026_08_25,
+  MODELS_2026,
+  mapModelFor9Router,
+  normalizeModelId,
+  OMNIROUTE_FALLBACK_MODEL,
+  routeModelViaOmniRoute,
+  SEARCH_MODEL,
+} from "../models.js";
+
+test("MODEL_CATALOG_2026_08_25 is a frozen non-empty array", () => {
+  try {
+    assert.ok(Array.isArray(MODEL_CATALOG_2026_08_25), "must be an array");
+    assert.ok(MODEL_CATALOG_2026_08_25.length > 0, "must have entries");
+    assert.equal(Object.isFrozen(MODEL_CATALOG_2026_08_25), true, "must be frozen");
+  } catch (err) {
+    assert.fail(`MODEL_CATALOG check failed: ${(err as Error).message}`);
+  }
+});
+
+test("MODEL_MAP_2026_08_25 is a Map that resolves every catalog id", () => {
+  try {
+    assert.ok(MODEL_MAP_2026_08_25 instanceof Map, "MODEL_MAP must be a Map");
+    for (const m of MODEL_CATALOG_2026_08_25) {
+      const got = MODEL_MAP_2026_08_25.get(m.id.toLowerCase());
+      assert.ok(got, `MODEL_MAP must contain id ${m.id}`);
+    }
+  } catch (err) {
+    assert.fail(`MODEL_MAP check failed: ${(err as Error).message}`);
+  }
+});
+
+test("getModel resolves known ids and returns undefined for unknown", () => {
+  try {
+    const a = getModel("gemini-3.7-flash");
+    assert.ok(a, "gemini-3.7-flash must resolve");
+    assert.equal(a?.id, "gemini-3.7-flash");
+
+    const b = getModel("claude-opus-4-6-thinking");
+    assert.ok(b, "claude-opus-4-6-thinking must resolve");
+    assert.equal(b?.id, "claude-opus-4-6-thinking");
+
+    // antigravity- prefixed variant of the same id must resolve too.
+    const c = getModel("antigravity-gemini-3.7-flash");
+    assert.ok(c, "antigravity- prefixed alias must resolve");
+
+    // unknown id returns undefined.
+    const z = getModel("not-a-real-model-id");
+    assert.equal(z, undefined, "unknown id must return undefined");
+
+    // empty/null must not throw.
+    assert.equal(getModel(""), undefined);
+    assert.equal(getModel(null as unknown as string), undefined);
+  } catch (err) {
+    assert.fail(`getModel check failed: ${(err as Error).message}`);
+  }
+});
+
+test("hasModel mirrors getModel", () => {
+  try {
+    assert.equal(hasModel("gemini-3.7-flash"), true);
+    assert.equal(hasModel("claude-opus-4-6-thinking"), true);
+    assert.equal(hasModel("not-real"), false);
+  } catch (err) {
+    assert.fail(`hasModel check failed: ${(err as Error).message}`);
+  }
+});
+
+test("routeModelViaOmniRoute returns the physical id + group + endpoint list for known ids", () => {
+  try {
+    const r = routeModelViaOmniRoute("gemini-3.7-flash");
+    assert.ok(r, "must return a routing result");
+    assert.equal(r.physicalId, "gemini-3.7-flash", "physicalId must match the input id for a known model");
+    assert.ok(r.group === "antigravity" || r.group === "gemini-cli", "group must be a known ModelGroup");
+    assert.ok(Array.isArray(r.endpoints), "endpoints must be an array");
+    assert.ok(r.endpoints.length > 0, "endpoints must be non-empty");
+    assert.equal(typeof r.prodOnly, "boolean", "prodOnly must be boolean");
+    assert.equal(typeof r.fallbackAllowed, "boolean", "fallbackAllowed must be boolean");
+  } catch (err) {
+    assert.fail(`routeModelViaOmniRoute known-id check failed: ${(err as Error).message}`);
+  }
+});
+
+test("routeModelViaOmniRoute round-trip: same id twice -> same result", () => {
+  try {
+    const a = routeModelViaOmniRoute("gemini-3.7-flash");
+    const b = routeModelViaOmniRoute("gemini-3.7-flash");
+    assert.deepEqual(a, b, "routing must be deterministic across calls");
+  } catch (err) {
+    assert.fail(`routeModelViaOmniRoute round-trip check failed: ${(err as Error).message}`);
+  }
+});
+
+test("routeModelViaOmniRoute unknown id falls back to OMNIROUTE_FALLBACK_MODEL on gemini-cli pool", () => {
+  try {
+    const r = routeModelViaOmniRoute("does-not-exist-xyz");
+    assert.equal(r.physicalId, OMNIROUTE_FALLBACK_MODEL, "unknown id must fall back to OMNIROUTE_FALLBACK_MODEL");
+    assert.equal(r.group, "gemini-cli", "fallback group must be gemini-cli");
+    assert.equal(r.prodOnly, true, "fallback must be prod-only (skip sandbox)");
+    assert.equal(r.fallbackAllowed, false, "fallback must disallow project fallback (403 risk)");
+  } catch (err) {
+    assert.fail(`routeModelViaOmniRoute unknown-id check failed: ${(err as Error).message}`);
+  }
+});
+
+test("mapModelFor9Router returns provider + model + group for known ids", () => {
+  try {
+    const m = mapModelFor9Router("gemini-3.7-flash");
+    assert.ok(m, "must return a 9router mapping");
+    assert.equal(typeof m.provider, "string", "provider must be string");
+    assert.equal(typeof m.model, "string", "model must be string");
+    assert.ok(m.group === "antigravity" || m.group === "gemini-cli", "group must be a known ModelGroup");
+    // For a known id, .model should equal the canonical id.
+    assert.equal(m.model, "gemini-3.7-flash");
+  } catch (err) {
+    assert.fail(`mapModelFor9Router known-id check failed: ${(err as Error).message}`);
+  }
+});
+
+test("mapModelFor9Router unknown id falls back to normalized id + gemini-cli group", () => {
+  try {
+    const m = mapModelFor9Router("gpt-4-turbo");
+    assert.equal(m.provider, "google", "unknown id must default provider to google");
+    assert.equal(m.group, "gemini-cli", "unknown id must default group to gemini-cli");
+    assert.equal(m.model, "gpt-4-turbo", "unknown id model must be the normalized id");
+  } catch (err) {
+    assert.fail(`mapModelFor9Router unknown-id check failed: ${(err as Error).message}`);
+  }
+});
+
+test("normalizeModelId strips antigravity- prefix and lowercases", () => {
+  try {
+    assert.equal(normalizeModelId("Antigravity-Gemini-3.7-Flash"), "gemini-3.7-flash");
+    assert.equal(normalizeModelId("gemini-3.7-flash"), "gemini-3.7-flash");
+    assert.equal(normalizeModelId("  gemini-3.7-flash  "), "gemini-3.7-flash");
+  } catch (err) {
+    assert.fail(`normalizeModelId check failed: ${(err as Error).message}`);
+  }
+});
+
+test("listModelIds and listBareModelIds return non-empty arrays of strings", () => {
+  try {
+    const all = listModelIds();
+    assert.ok(Array.isArray(all));
+    assert.ok(all.length > 0);
+
+    const bare = listBareModelIds();
+    assert.ok(Array.isArray(bare));
+    assert.ok(bare.length > 0);
+
+    // listBareModelIds must not contain antigravity- prefixed ids.
+    assert.ok(!bare.some((id) => id.startsWith("antigravity-")), "bare ids must not have antigravity- prefix");
+  } catch (err) {
+    assert.fail(`list ids check failed: ${(err as Error).message}`);
+  }
+});
+
+test("isCLIOnly flags gemini-3+ / preview / customtools models", () => {
+  try {
+    assert.equal(isCLIOnly("gemini-3.7-flash-preview"), true, "preview must be CLI-only");
+    assert.equal(isCLIOnly("gemini-3.6-flash"), true, "3.6 must be CLI-only");
+    assert.equal(isCLIOnly("gemini-3.1-pro-preview-customtools"), true, "customtools must be CLI-only");
+    // antigravity-pool bare ids (not preview, not 3+) should be NOT CLI-only.
+    assert.equal(isCLIOnly("gpt-oss-120b-medium"), false, "gpt-oss must NOT be CLI-only");
+  } catch (err) {
+    assert.fail(`isCLIOnly check failed: ${(err as Error).message}`);
+  }
+});
+
+test("MODEL_ALIASES_2026_08_25 is a Map", () => {
+  try {
+    assert.ok(MODEL_ALIASES_2026_08_25 instanceof Map, "MODEL_ALIASES must be a Map");
+    // antigravity- prefixed aliases are part of the alias map.
+    assert.ok(MODEL_ALIASES_2026_08_25.size >= 0, "size must be a number (may be 0 if no aliases)");
+  } catch (err) {
+    assert.fail(`MODEL_ALIASES check failed: ${(err as Error).message}`);
+  }
+});
+
+test("MODEL_CATALOG_GROUPED exposes per-group / per-level slices", () => {
+  try {
+    assert.equal(typeof MODEL_CATALOG_GROUPED, "object");
+    assert.ok(Array.isArray(MODEL_CATALOG_GROUPED.antigravity), "antigravity slice must be array");
+    assert.ok(Array.isArray(MODEL_CATALOG_GROUPED["gemini-cli"]), "gemini-cli slice must be array");
+    assert.ok(Array.isArray(MODEL_CATALOG_GROUPED.preview), "preview slice must be array");
+    assert.ok(Array.isArray(MODEL_CATALOG_GROUPED.stable), "stable slice must be array");
+  } catch (err) {
+    assert.fail(`MODEL_CATALOG_GROUPED check failed: ${(err as Error).message}`);
+  }
+});
+
+test("DEFAULT_MODEL + SEARCH_MODEL + FALLBACKS are sensible constant strings", () => {
+  try {
+    assert.equal(typeof DEFAULT_MODEL, "string");
+    assert.equal(typeof SEARCH_MODEL, "string");
+    assert.ok(DEFAULT_MODEL.startsWith("antigravity-"), "DEFAULT_MODEL must be antigravity- prefixed");
+    assert.ok(SEARCH_MODEL.startsWith("gemini-"), "SEARCH_MODEL must be a bare gemini id");
+
+    assert.equal(typeof FALLBACKS, "object");
+    assert.equal(FALLBACKS.project, "rising-fact-p41fc");
+    assert.equal(FALLBACKS.version, "1.19.2");
+    assert.ok(FALLBACKS.ua.startsWith("antigravity/"), "FALLBACKS.ua must start with antigravity/");
+  } catch (err) {
+    assert.fail(`DEFAULT_MODEL / SEARCH_MODEL / FALLBACKS check failed: ${(err as Error).message}`);
+  }
+});
+
+test("MODELS_2026 + ANTIGRAVITY_MODELS + GEMINICLI_MODELS + ALL_MODELS_WITH_PREFIX arrays are non-empty", () => {
+  try {
+    assert.ok(Array.isArray(MODELS_2026) && MODELS_2026.length > 0);
+    assert.ok(Array.isArray(ANTIGRAVITY_MODELS) && ANTIGRAVITY_MODELS.length > 0);
+    assert.ok(Array.isArray(GEMINICLI_MODELS) && GEMINICLI_MODELS.length > 0);
+    assert.ok(Array.isArray(ALL_MODELS_WITH_PREFIX) && ALL_MODELS_WITH_PREFIX.length > 0);
+
+    // Every antigravity id must start with antigravity-.
+    for (const id of ANTIGRAVITY_MODELS) {
+      assert.ok(id.startsWith("antigravity-"), `id ${id} must be antigravity- prefixed`);
+    }
+  } catch (err) {
+    assert.fail(`flat catalog arrays check failed: ${(err as Error).message}`);
+  }
+});

package/tests/provider.oauth.test.ts

@@ -0,0 +1,150 @@
+/**
+ * @file oauth.test.ts
+ * @description
+ *  Tests for the pure PKCE / crypto helpers exported from the consolidated
+ *  authentication module (`../auth.js`, v2.1.14 merge of oauth.ts +
+ *  antigravity-cli.ts into auth.ts). Strictly tests ONLY the pure functions
+ *  (`generatePKCE`, `buildAuthUrl`, `extractCodeFromUrl`,
+ *  `isValidTokenResponse`) — does NOT trigger the OAuth server flow, does NOT
+ *  spin up a callback server, does NOT call out to the network.
+ *
+ *  Per RFC 7636: the verifier is a high-entropy base64url string of length
+ *  43..128; the challenge is BASE64URL(SHA256(verifier_ascii_bytes)) with
+ *  no padding. maene's `generatePKCE` uses 64 random bytes -> 86 chars,
+ *  method "S256".
+ *
+ *  Runs on the vitest runner with `node:assert/strict` assertions. Imports only leaf modules; the
+ *  consolidated auth module pulls only `node:*` builtins + global fetch.
+ */
+
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { it as test } from "vitest";
+
+import { buildAuthUrl, extractCodeFromUrl, generatePKCE, isValidTokenResponse } from "../oauth.js";
+
+test("generatePKCE returns a non-empty verifier + base64url S256 challenge + method S256", () => {
+  try {
+    const pkce = generatePKCE();
+    assert.ok(pkce, "generatePKCE must return an object");
+    assert.equal(typeof pkce.verifier, "string", "verifier must be a string");
+    assert.ok(pkce.verifier.length >= 43, "verifier must be >= 43 chars per RFC 7636");
+    assert.ok(pkce.verifier.length <= 128, "verifier must be <= 128 chars per RFC 7636");
+    assert.equal(typeof pkce.challenge, "string", "challenge must be a string");
+    assert.ok(pkce.challenge.length > 0, "challenge must be non-empty");
+    assert.equal(pkce.method, "S256", "method must be S256");
+
+    // Verifier must be base64url: no '+', '/', or '='.
+    assert.ok(!/[+/=]/.test(pkce.verifier), "verifier must be base64url (no +, /, =)");
+
+    // Challenge must be base64url too.
+    assert.ok(!/[+/=]/.test(pkce.challenge), "challenge must be base64url (no +, /, =)");
+  } catch (err) {
+    assert.fail(`generatePKCE shape check failed: ${(err as Error).message}`);
+  }
+});
+
+test("generatePKCE challenge equals base64url(sha256(verifier_ascii))", () => {
+  try {
+    const pkce = generatePKCE();
+    // RFC 7636 S256: challenge = base64url(SHA256(verifier ASCII bytes)).
+    const expected = createHash("sha256")
+      .update(pkce.verifier) // ASCII bytes of the verifier string
+      .digest("base64url");
+    assert.equal(pkce.challenge, expected, "challenge must match RFC 7636 S256");
+  } catch (err) {
+    assert.fail(`generatePKCE S256 check failed: ${(err as Error).message}`);
+  }
+});
+
+test("generatePKCE verifier + challenge are unique across two calls", () => {
+  try {
+    const a = generatePKCE();
+    const b = generatePKCE();
+    assert.notEqual(a.verifier, b.verifier, "two verifiers must differ (cryptographic randomness)");
+    assert.notEqual(a.challenge, b.challenge, "two challenges must differ");
+  } catch (err) {
+    assert.fail(`generatePKCE uniqueness check failed: ${(err as Error).message}`);
+  }
+});
+
+test("buildAuthUrl builds a valid OAuth URL with state, client_id, and PKCE challenge", () => {
+  try {
+    const pkce = generatePKCE();
+    const url = buildAuthUrl(pkce, "http://127.0.0.1:12345/callback");
+    assert.ok(url.startsWith("https://accounts.google.com/"), "must target Google OAuth");
+    const parsed = new URL(url);
+    assert.ok(parsed.searchParams.get("client_id"), "client_id must be present and non-empty");
+    assert.equal(parsed.searchParams.get("response_type"), "code");
+    assert.equal(parsed.searchParams.get("redirect_uri"), "http://127.0.0.1:12345/callback");
+    assert.equal(parsed.searchParams.get("code_challenge"), pkce.challenge);
+    assert.equal(parsed.searchParams.get("code_challenge_method"), "S256");
+    assert.equal(parsed.searchParams.get("access_type"), "offline");
+    assert.ok(parsed.searchParams.get("state"), "state must be present and non-empty");
+  } catch (err) {
+    assert.fail(`buildAuthUrl check failed: ${(err as Error).message}`);
+  }
+});
+
+test("buildAuthUrl works without a PKCE pair (state-only Gemini CLI parity)", () => {
+  try {
+    const url = buildAuthUrl(null, "http://127.0.0.1:9999/callback");
+    const parsed = new URL(url);
+    assert.equal(parsed.searchParams.get("code_challenge"), null, "code_challenge must be absent when no PKCE");
+    assert.equal(
+      parsed.searchParams.get("code_challenge_method"),
+      null,
+      "code_challenge_method must be absent when no PKCE",
+    );
+    assert.ok(parsed.searchParams.get("state"), "state must still be present");
+  } catch (err) {
+    assert.fail(`buildAuthUrl no-PKCE check failed: ${(err as Error).message}`);
+  }
+});
+
+test("extractCodeFromUrl extracts the authorization code from a callback URL", () => {
+  try {
+    const code = extractCodeFromUrl("http://127.0.0.1:12345/callback?code=4/0AX4-abcdef&state=st");
+    assert.equal(code, "4/0AX4-abcdef");
+  } catch (err) {
+    assert.fail(`extractCodeFromUrl valid check failed: ${(err as Error).message}`);
+  }
+});
+
+test("extractCodeFromUrl returns null when no code param is present", () => {
+  try {
+    const code = extractCodeFromUrl("http://127.0.0.1:12345/callback?error=access_denied");
+    assert.equal(code, null, "must return null when there is no code");
+  } catch (err) {
+    assert.fail(`extractCodeFromUrl no-code check failed: ${(err as Error).message}`);
+  }
+});
+
+test("isValidTokenResponse accepts well-formed objects and rejects malformed ones", () => {
+  try {
+    // The actual validator requires access_token (string), expires_at (number),
+    // and expires_in (number). It does NOT require token_type.
+    assert.ok(
+      isValidTokenResponse({ access_token: "abc", expires_at: 1234, expires_in: 3600 }),
+      "well-formed token response (access_token + expires_at + expires_in) must be valid",
+    );
+
+    // null/empty/string — all falsy return values (the impl short-circuits
+    // via `obj && ...`, so null returns null, not strictly false).
+    assert.ok(!isValidTokenResponse(null), "null must be falsy/invalid");
+    assert.ok(!isValidTokenResponse({}), "empty object must be invalid (missing access_token)");
+    assert.ok(!isValidTokenResponse("string"), "string must be invalid");
+
+    // Missing one of the required number fields must also fail.
+    assert.ok(!isValidTokenResponse({ access_token: "abc", expires_in: 3600 }), "missing expires_at must be invalid");
+  } catch (err) {
+    assert.fail(`isValidTokenResponse check failed: ${(err as Error).message}`);
+  }
+});
+
+test("oauth module import smoke (does not throw on side-effect-free import)", () => {
+  // The act of importing the module already happened at the top of this file.
+  // If the module had any module-eval-time error, this test file would never
+  // have loaded. So this test is a no-op smoke assertion.
+  assert.ok(true, "oauth module imported without throwing");
+});

package/tests/providercli.test.ts

@@ -0,0 +1,84 @@
+/**
+ * providercli — the provider account console smoke (the ownership move of
+ * the gateway ownership wave, step 5): the console family answers from the
+ * getry owner now, and this lane pins the load-bearing seams of the move —
+ * the help text renders, the accounts path resolver agrees with the
+ * accounts owner's own resolution, the opencode model definitions answer
+ * from the models owner with the catalog shape, and the twin deletion
+ * (getDefaultAccountManager behind the historical getAccountManager name)
+ * answers the accounts owner's real manager. No network, no browser.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import {
+  buildOpenCodeModelDefinitions,
+  getAccountManager,
+  printHelp,
+  providercli,
+  resolveAccountsPath,
+  runproviderfamily,
+} from "../providercli.js";
+import { getDefaultAccountManager, resolveAccountsPath as accountsResolveAccountsPath } from "../accounts.js";
+import { MODELS_2026_CATALOG } from "../models.js";
+
+describe("providercli smoke", () => {
+  it("renders the help text", () => {
+    const logged: string[] = [];
+    const spy = vi.spyOn(console, "log").mockImplementation((...parts: unknown[]) => {
+      logged.push(parts.join(" "));
+    });
+    try {
+      printHelp();
+    } finally {
+      spy.mockRestore();
+    }
+    const text = logged.join("\n");
+    expect(text).toContain("devthink provider CLI (unified merge)");
+    expect(text).toContain("Usage:");
+    expect(text).toContain("cli.ts <command> [subcommand] [flags]");
+  });
+
+  it("resolves the accounts path the accounts owner resolves", () => {
+    expect(resolveAccountsPath()).toBe(accountsResolveAccountsPath());
+    expect(resolveAccountsPath()).toContain("antigravity-accounts.json");
+  });
+
+  it("builds the opencode model definitions with the catalog shape", () => {
+    const defs = buildOpenCodeModelDefinitions();
+    expect(defs.pluginList).toEqual(["devthink"]);
+    for (const entry of MODELS_2026_CATALOG) {
+      expect(defs.providerModels[entry.id]).toBeDefined();
+      expect(defs.providerModels[entry.id].antigravity.endpoint).toContain("cloudcode-pa.googleapis.com");
+      expect(defs.topLevelModels[`antigravity/${entry.id}`]).toBeDefined();
+    }
+    expect(Object.keys(defs.topLevelModels).length).toBeGreaterThan(MODELS_2026_CATALOG.length);
+  });
+
+  it("answers the account manager from the accounts owner (the twin deletion)", () => {
+    expect(typeof getAccountManager).toBe("function");
+    const mgr = getAccountManager({ disableBackgroundTimer: true });
+    // the twin raced the real manager on the same file; the owner answers
+    // the real class now — the singleton and the direct call agree
+    const direct = getDefaultAccountManager({ disableBackgroundTimer: true });
+    expect(mgr).toBe(direct);
+    expect(typeof mgr.listAccounts).toBe("function");
+    expect(typeof mgr.getValidAccessToken).toBe("function");
+  });
+
+  it("exposes the family entry and the providercli compat const", async () => {
+    expect(typeof runproviderfamily).toBe("function");
+    expect(typeof providercli.runCLI).toBe("function");
+    expect(typeof providercli.interactiveMenu).toBe("function");
+    // the family entry answers --help without a tty, without network
+    const logged: string[] = [];
+    const spy = vi.spyOn(console, "log").mockImplementation((...parts: unknown[]) => {
+      logged.push(parts.join(" "));
+    });
+    try {
+      await runproviderfamily(["--help"]);
+    } finally {
+      spy.mockRestore();
+    }
+    expect(logged.join("\n")).toContain("devthink provider CLI (unified merge)");
+  });
+});