@getrouter/getrouter-cli 0.1.9 → 0.1.11

package/tests/cmd/codex.test.ts

@@ -15,6 +15,8 @@ const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
 const codexConfigPath = (dir: string) =>
   path.join(dir, ".codex", "config.toml");
 const codexAuthPath = (dir: string) => path.join(dir, ".codex", "auth.json");
+const codexBackupPath = (dir: string) =>
+  path.join(dir, ".getrouter", "codex-backup.json");
 
 const mockConsumer = { id: "c1", apiKey: "key-123" };
 
@@ -274,6 +276,104 @@ describe("codex command", () => {
     expect(auth.OPENAI_API_KEY).toBeUndefined();
   });
 
+  it("uninstall restores previous OPENAI_API_KEY when backup exists", async () => {
+    const dir = makeDir();
+    process.env.HOME = dir;
+    const codexDir = path.join(dir, ".codex");
+    fs.mkdirSync(codexDir, { recursive: true });
+    fs.mkdirSync(path.join(dir, ".getrouter"), { recursive: true });
+    fs.writeFileSync(
+      codexAuthPath(dir),
+      JSON.stringify(
+        {
+          OPENAI_API_KEY: "new-key",
+          _getrouter_codex_backup_openai_api_key: "legacy-backup",
+          _getrouter_codex_installed_openai_api_key: "legacy-installed",
+          OTHER: "keep",
+        },
+        null,
+        2,
+      ),
+    );
+    fs.writeFileSync(
+      codexBackupPath(dir),
+      JSON.stringify(
+        {
+          version: 1,
+          createdAt: "2026-01-01T00:00:00Z",
+          updatedAt: "2026-01-01T00:00:00Z",
+          auth: {
+            previousOpenaiKey: "old-key",
+            installedOpenaiKey: "new-key",
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "codex", "uninstall"]);
+
+    const auth = JSON.parse(fs.readFileSync(codexAuthPath(dir), "utf8"));
+    expect(auth.OPENAI_API_KEY).toBe("old-key");
+    expect(auth._getrouter_codex_backup_openai_api_key).toBeUndefined();
+    expect(auth._getrouter_codex_installed_openai_api_key).toBeUndefined();
+    expect(auth.OTHER).toBe("keep");
+    expect(fs.existsSync(codexBackupPath(dir))).toBe(false);
+  });
+
+  it("uninstall restores previous model_provider and model", async () => {
+    setStdinTTY(true);
+    const dir = makeDir();
+    process.env.HOME = dir;
+    const codexDir = path.join(dir, ".codex");
+    fs.mkdirSync(codexDir, { recursive: true });
+    fs.writeFileSync(
+      codexConfigPath(dir),
+      [
+        'model = "user-model"',
+        'model_reasoning_effort = "low"',
+        'model_provider = "openai"',
+        "",
+        "[model_providers.openai]",
+        'name = "openai"',
+      ].join("\n"),
+    );
+
+    prompts.inject(["gpt-5.2-codex", "extra_high", mockConsumer]);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({
+          consumers: [
+            {
+              id: "c1",
+              name: "dev",
+              enabled: true,
+              createdAt: "2026-01-01T00:00:00Z",
+            },
+          ],
+        }),
+        GetConsumer: vi.fn().mockResolvedValue(mockConsumer),
+      } as unknown as ConsumerService,
+    });
+
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "codex"]);
+    expect(fs.existsSync(codexBackupPath(dir))).toBe(true);
+    await program.parseAsync(["node", "getrouter", "codex", "uninstall"]);
+    expect(fs.existsSync(codexBackupPath(dir))).toBe(false);
+
+    const config = fs.readFileSync(codexConfigPath(dir), "utf8");
+    expect(config).toContain('model = "user-model"');
+    expect(config).toContain('model_reasoning_effort = "low"');
+    expect(config).toContain('model_provider = "openai"');
+    expect(config).toContain("[model_providers.openai]");
+    expect(config).not.toContain("[model_providers.getrouter]");
+    expect(config).not.toContain("_getrouter_codex_backup");
+    expect(config).not.toContain("_getrouter_codex_installed");
+  });
+
   it("uninstall leaves root keys when provider is not getrouter", async () => {
     const dir = makeDir();
     process.env.HOME = dir;

package/tests/cmd/keys.test.ts

@@ -19,6 +19,7 @@ const mockConsumer = {
   apiKey: "abcd1234WXYZ",
   lastAccess: "2026-01-02T00:00:00Z",
   createdAt: "2026-01-01T00:00:00Z",
+  updatedAt: "2026-01-02T00:00:00Z",
 };
 
 const emptyAuthService = {} as AuthService;
@@ -113,6 +114,39 @@ describe("keys command", () => {
     log.mockRestore();
   });
 
+  it("sorts keys by updatedAt desc in list output", async () => {
+    setStdinTTY(false);
+    const consumers = [
+      {
+        ...mockConsumer,
+        id: "c1",
+        name: "older-key",
+        updatedAt: "2026-01-02T00:00:00Z",
+      },
+      {
+        ...mockConsumer,
+        id: "c2",
+        name: "newer-key",
+        updatedAt: "2026-01-03T00:00:00Z",
+      },
+    ];
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({ consumers }),
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys", "list"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output.indexOf("newer-key")).toBeLessThan(
+      output.indexOf("older-key"),
+    );
+    log.mockRestore();
+  });
+
   it("rejects removed get subcommand", async () => {
     setStdinTTY(false);
     const program = createProgram();

package/tests/core/interactive/codex.test.ts

@@ -25,15 +25,14 @@ describe("codex interactive helpers", () => {
       ok: true,
       status: 200,
       json: vi.fn().mockResolvedValue({
-        models: ["new-codex-model-xyz"],
+        models: ["older-codex-model", "newer-codex-model"],
       }),
     });
     vi.stubGlobal("fetch", fetchMock);
 
     const choices = await getCodexModelChoices();
-    expect(
-      choices.some((choice) => choice.value === "new-codex-model-xyz"),
-    ).toBe(true);
+    expect(choices[0]?.value).toBe("newer-codex-model");
+    expect(choices[1]?.value).toBe("older-codex-model");
     expect(String(fetchMock.mock.calls[0]?.[0] ?? "")).toContain(
       "/v1/dashboard/providers/models?tag=codex",
     );

package/tests/core/setup/codex.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { mergeAuthJson, mergeCodexToml } from "../../../src/core/setup/codex";
+import {
+  mergeAuthJson,
+  mergeCodexToml,
+  removeAuthJson,
+  removeCodexConfig,
+} from "../../../src/core/setup/codex";
 
 describe("codex setup helpers", () => {
   it("merges codex toml at root and provider table", () => {
@@ -35,4 +40,85 @@ describe("codex setup helpers", () => {
     expect(output.OPENAI_API_KEY).toBe("key-123");
     expect(output.existing).toBe("keep");
   });
+
+  it("removes getrouter provider section and restores root keys when provided", () => {
+    const input = [
+      'model = "gpt-5.2-codex"',
+      'model_reasoning_effort = "xhigh"',
+      'model_provider = "getrouter"',
+      "",
+      "[model_providers.getrouter]",
+      'name = "getrouter"',
+      "",
+      "[model_providers.openai]",
+      'name = "openai"',
+    ].join("\n");
+
+    const { content, changed } = removeCodexConfig(input, {
+      restoreRoot: {
+        model: '"user-model"',
+        reasoning: '"medium"',
+        provider: '"openai"',
+      },
+    });
+    expect(changed).toBe(true);
+    expect(content).toContain('model = "user-model"');
+    expect(content).toContain('model_reasoning_effort = "medium"');
+    expect(content).toContain('model_provider = "openai"');
+    expect(content).toContain("[model_providers.openai]");
+    expect(content).not.toContain("[model_providers.getrouter]");
+  });
+
+  it("removes root keys when provider is getrouter and no restore is provided", () => {
+    const input = [
+      'model = "gpt-5.2-codex"',
+      'model_reasoning_effort = "xhigh"',
+      'model_provider = "getrouter"',
+      "",
+      "[model_providers.getrouter]",
+      'name = "getrouter"',
+    ].join("\n");
+
+    const { content } = removeCodexConfig(input);
+    expect(content).not.toContain('model = "gpt-5.2-codex"');
+    expect(content).not.toContain('model_reasoning_effort = "xhigh"');
+    expect(content).not.toContain('model_provider = "getrouter"');
+    expect(content).not.toContain("[model_providers.getrouter]");
+  });
+
+  it("restores OPENAI_API_KEY when installed key matches current", () => {
+    const input = {
+      OPENAI_API_KEY: "new-key",
+      OTHER: "keep",
+    } as Record<string, unknown>;
+    const { data, changed } = removeAuthJson(input, {
+      installed: "new-key",
+      restore: "old-key",
+    });
+    expect(changed).toBe(true);
+    expect(data.OPENAI_API_KEY).toBe("old-key");
+    expect(data.OTHER).toBe("keep");
+  });
+
+  it("removes OPENAI_API_KEY when forced and no restore is available", () => {
+    const input = {
+      OPENAI_API_KEY: "new-key",
+      OTHER: "keep",
+    } as Record<string, unknown>;
+    const { data, changed } = removeAuthJson(input, { force: true });
+    expect(changed).toBe(true);
+    expect(data.OPENAI_API_KEY).toBeUndefined();
+    expect(data.OTHER).toBe("keep");
+  });
+
+  it("leaves OPENAI_API_KEY when not forced and not installed", () => {
+    const input = {
+      OPENAI_API_KEY: "user-key",
+      OTHER: "keep",
+    } as Record<string, unknown>;
+    const { data, changed } = removeAuthJson(input);
+    expect(changed).toBe(false);
+    expect(data.OPENAI_API_KEY).toBe("user-key");
+    expect(data.OTHER).toBe("keep");
+  });
 });