gemiterm 2.0.0 → 2.1.1

package/tests/infrastructure/storage.test.ts

@@ -1,335 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdirSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { CookieStorage, ProfileManager } from "../../src/infrastructure/storage.ts";
-import type { Cookie } from "../../src/core/types.ts";
-
-const TEST_DIR = join(tmpdir(), "gemiterm-test-storage");
-
-beforeEach(() => {
-  process.env.GEMITERM_CONFIG_DIR = TEST_DIR;
-  mkdirSync(TEST_DIR, { recursive: true });
-});
-
-afterEach(() => {
-  rmSync(TEST_DIR, { recursive: true, force: true });
-  delete process.env.GEMITERM_CONFIG_DIR;
-});
-
-function makeValidCookies(): Cookie[] {
-  const farFuture = Math.floor(Date.now() / 1000) + 365 * 24 * 60 * 60;
-  return [
-    {
-      name: "__Secure-1PSID",
-      value: "test-psid-value",
-      domain: ".google.com",
-      path: "/",
-      expires: farFuture,
-      httpOnly: true,
-      secure: true,
-      sameSite: "Lax",
-    },
-    {
-      name: "__Secure-1PSIDTS",
-      value: "test-psidts-value",
-      domain: ".google.com",
-      path: "/",
-      expires: farFuture,
-      httpOnly: true,
-      secure: true,
-      sameSite: "Lax",
-    },
-  ];
-}
-
-function makeExpiredCookies(): Cookie[] {
-  const past = Math.floor(Date.now() / 1000) - 30 * 24 * 60 * 60;
-  return [
-    {
-      name: "__Secure-1PSID",
-      value: "expired-psid",
-      domain: ".google.com",
-      path: "/",
-      expires: past,
-      httpOnly: true,
-      secure: true,
-      sameSite: "Lax",
-    },
-    {
-      name: "__Secure-1PSIDTS",
-      value: "expired-psidts",
-      domain: ".google.com",
-      path: "/",
-      expires: past,
-      httpOnly: true,
-      secure: true,
-      sameSite: "Lax",
-    },
-  ];
-}
-
-describe("CookieStorage", () => {
-  let storage: CookieStorage;
-
-  beforeEach(() => {
-    storage = new CookieStorage();
-  });
-
-  test("saves and loads cookies for a profile", () => {
-    const cookies = makeValidCookies();
-    storage.save("test-profile", cookies);
-
-    const loaded = storage.load("test-profile");
-    expect(loaded).toHaveLength(2);
-    expect(loaded[0].name).toBe("__Secure-1PSID");
-    expect(loaded[1].name).toBe("__Secure-1PSIDTS");
-  });
-
-  test("throws when loading non-existent profile", () => {
-    expect(() => storage.load("nonexistent")).toThrow("No storage state found");
-  });
-
-  test("deletes profile directory", () => {
-    storage.save("to-delete", makeValidCookies());
-    expect(existsSync(join(TEST_DIR, "profiles", "to-delete"))).toBe(true);
-
-    storage.delete("to-delete");
-    expect(existsSync(join(TEST_DIR, "profiles", "to-delete"))).toBe(false);
-  });
-
-  test("delete is a no-op for non-existent profile", () => {
-    expect(() => storage.delete("nonexistent")).not.toThrow();
-  });
-
-  test("list returns empty array when no profiles exist", () => {
-    expect(storage.list()).toEqual([]);
-  });
-
-  test("list returns saved profile names", () => {
-    storage.save("alpha", makeValidCookies());
-    storage.save("beta", makeValidCookies());
-
-    const names = storage.list();
-    expect(names).toContain("alpha");
-    expect(names).toContain("beta");
-  });
-
-  test("overwrites existing cookies on save", () => {
-    storage.save("overwrite", makeValidCookies());
-    const newCookies = [
-      { ...makeValidCookies()[0], value: "new-value" },
-      { ...makeValidCookies()[1], value: "new-ts-value" },
-    ];
-    storage.save("overwrite", newCookies);
-
-    const loaded = storage.load("overwrite");
-    expect(loaded[0].value).toBe("new-value");
-  });
-});
-
-describe("ProfileManager", () => {
-  let manager: ProfileManager;
-
-  beforeEach(() => {
-    manager = new ProfileManager();
-  });
-
-  test("create creates profile directory", () => {
-    manager.create("new-profile");
-    expect(existsSync(join(TEST_DIR, "profiles", "new-profile"))).toBe(true);
-  });
-
-  test("create sets first profile as default", () => {
-    manager.create("first");
-    expect(manager.getDefault()).toBe("first");
-  });
-
-  test("create does not change default if profiles already exist", () => {
-    manager.create("first");
-    manager.create("second");
-    expect(manager.getDefault()).toBe("first");
-  });
-
-  test("create throws if profile already exists", () => {
-    manager.create("dup");
-    expect(() => manager.create("dup")).toThrow("already exists");
-  });
-
-  test("delete removes profile directory and resets default", () => {
-    manager.create("p1");
-    manager.create("p2");
-    manager.setDefault("p1");
-
-    manager.delete("p1");
-    expect(manager.getDefault()).toBe("p2");
-    expect(manager.list()).not.toContain("p1");
-  });
-
-  test("delete resets default to remaining profile", () => {
-    manager.create("solo");
-    manager.delete("solo");
-    expect(manager.list()).toEqual([]);
-  });
-
-  test("rename moves profile directory", () => {
-    manager.create("old-name");
-    manager.rename("old-name", "new-name");
-
-    expect(manager.list()).toContain("new-name");
-    expect(manager.list()).not.toContain("old-name");
-    expect(existsSync(join(TEST_DIR, "profiles", "new-name"))).toBe(true);
-    expect(existsSync(join(TEST_DIR, "profiles", "old-name"))).toBe(false);
-  });
-
-  test("rename updates default if renamed profile was default", () => {
-    manager.create("default-profile");
-    manager.rename("default-profile", "renamed");
-
-    expect(manager.getDefault()).toBe("renamed");
-  });
-
-  test("rename throws if source does not exist", () => {
-    expect(() => manager.rename("nope", "dest")).toThrow("does not exist");
-  });
-
-  test("rename throws if destination already exists", () => {
-    manager.create("a");
-    manager.create("b");
-    expect(() => manager.rename("a", "b")).toThrow("already exists");
-  });
-
-  test("setDefault throws if profile does not exist", () => {
-    expect(() => manager.setDefault("ghost")).toThrow("does not exist");
-  });
-
-  test("setDefault sets the default profile name", () => {
-    manager.create("p1");
-    manager.create("p2");
-    manager.setDefault("p2");
-    expect(manager.getDefault()).toBe("p2");
-  });
-
-  test("getStatus returns correct data for existing valid profile", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    storage.save("active", makeValidCookies());
-
-    const status = mgr.getStatus("active");
-    expect(status.exists).toBe(true);
-    expect(status.isActive).toBe(true);
-    expect(status.expiresAt).not.toBeNull();
-    expect(status.isDefault).toBe(false);
-  });
-
-  test("getStatus returns inactive for expired cookies", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    storage.save("expired", makeExpiredCookies());
-
-    const status = mgr.getStatus("expired");
-    expect(status.exists).toBe(true);
-    expect(status.isActive).toBe(false);
-  });
-
-  test("getStatus returns active for session cookies (expires: -1)", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    const sessionCookies: Cookie[] = [
-      {
-        name: "__Secure-1PSID",
-        value: "psid",
-        domain: ".google.com",
-        path: "/",
-        expires: -1,
-        httpOnly: true,
-        secure: true,
-        sameSite: "Lax",
-      },
-      {
-        name: "__Secure-1PSIDTS",
-        value: "psidts",
-        domain: ".google.com",
-        path: "/",
-        expires: -1,
-        httpOnly: true,
-        secure: true,
-        sameSite: "Lax",
-      },
-    ];
-    storage.save("session", sessionCookies);
-
-    const status = mgr.getStatus("session");
-    expect(status.exists).toBe(true);
-    expect(status.isActive).toBe(true);
-    expect(status.expiresAt).toBeNull();
-  });
-
-  test("getStatus returns not exists for missing profile", () => {
-    const status = manager.getStatus("missing");
-    expect(status.exists).toBe(false);
-    expect(status.isActive).toBe(false);
-  });
-
-  test("getStatus marks the default profile", () => {
-    manager.create("def");
-    const status = manager.getStatus("def");
-    expect(status.isDefault).toBe(true);
-  });
-
-  test("getAllStatuses returns all profile statuses", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    storage.save("active", makeValidCookies());
-    storage.save("expired", makeExpiredCookies());
-
-    const statuses = mgr.getAllStatuses();
-    expect(statuses).toHaveLength(2);
-    const active = statuses.find((s) => s.name === "active")!;
-    const expired = statuses.find((s) => s.name === "expired")!;
-    expect(active.isActive).toBe(true);
-    expect(expired.isActive).toBe(false);
-  });
-
-  test("hasValidCookies returns true for fresh cookies", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    storage.save("fresh", makeValidCookies());
-
-    expect(mgr.hasValidCookies("fresh")).toBe(true);
-  });
-
-  test("hasValidCookies returns false for expired cookies", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    storage.save("stale", makeExpiredCookies());
-
-    expect(mgr.hasValidCookies("stale")).toBe(false);
-  });
-
-  test("hasValidCookies returns false for missing profile", () => {
-    expect(manager.hasValidCookies("nope")).toBe(false);
-  });
-
-  test("loadCookiesForApi returns cookie values", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    storage.save("api-test", makeValidCookies());
-
-    const result = mgr.loadCookiesForApi("api-test");
-    expect(result.secure1psid).toBe("test-psid-value");
-    expect(result.secure1psidts).toBe("test-psidts-value");
-  });
-
-  test("loadCookiesForApi throws for expired cookies", () => {
-    const storage = new CookieStorage();
-    const mgr = new ProfileManager(storage);
-    storage.save("expired-api", makeExpiredCookies());
-
-    expect(() => mgr.loadCookiesForApi("expired-api")).toThrow("expired");
-  });
-
-  test("loadCookiesForApi throws for missing profile", () => {
-    expect(() => manager.loadCookiesForApi("ghost")).toThrow("No storage state found");
-  });
-});

package/tests/infrastructure/validators.test.ts

@@ -1,67 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  validateConversationId,
-  parseIsoDate,
-  validateProfileName,
-} from "../../src/infrastructure/validators.ts";
-import { GemitermError } from "../../src/core/errors.ts";
-
-describe("validateConversationId", () => {
-  test("does not throw for a valid non-empty id", () => {
-    expect(() => validateConversationId("abc123")).not.toThrow();
-  });
-
-  test("throws for empty string", () => {
-    expect(() => validateConversationId("")).toThrow(GemitermError);
-    expect(() => validateConversationId("")).toThrow("Conversation ID must not be empty");
-  });
-
-  test("throws for whitespace-only string", () => {
-    expect(() => validateConversationId("   ")).toThrow(GemitermError);
-  });
-});
-
-describe("parseIsoDate", () => {
-  test("returns timestamp for valid ISO date", () => {
-    const ts = parseIsoDate("2025-01-15T10:30:00.000Z", "createdAt");
-    expect(typeof ts).toBe("number");
-    expect(ts).toBe(new Date("2025-01-15T10:30:00.000Z").getTime());
-  });
-
-  test("throws for invalid date string", () => {
-    expect(() => parseIsoDate("not-a-date", "field")).toThrow(GemitermError);
-    expect(() => parseIsoDate("not-a-date", "field")).toThrow("Invalid ISO date for 'field'");
-  });
-
-  test("includes field name in error message", () => {
-    expect(() => parseIsoDate("bad", "updatedAt")).toThrow("'updatedAt'");
-  });
-});
-
-describe("validateProfileName", () => {
-  test("does not throw for valid names", () => {
-    expect(() => validateProfileName("default")).not.toThrow();
-    expect(() => validateProfileName("my-profile")).not.toThrow();
-    expect(() => validateProfileName("profile_2")).not.toThrow();
-    expect(() => validateProfileName("ABC123")).not.toThrow();
-  });
-
-  test("throws for empty string", () => {
-    expect(() => validateProfileName("")).toThrow(GemitermError);
-    expect(() => validateProfileName("")).toThrow("Profile name must not be empty");
-  });
-
-  test("throws for whitespace-only string", () => {
-    expect(() => validateProfileName("   ")).toThrow(GemitermError);
-  });
-
-  test("throws for name with spaces", () => {
-    expect(() => validateProfileName("my profile")).toThrow(GemitermError);
-  });
-
-  test("throws for name with special characters", () => {
-    expect(() => validateProfileName("profile@bad")).toThrow(GemitermError);
-    expect(() => validateProfileName("pro/ject")).toThrow(GemitermError);
-    expect(() => validateProfileName("pro.file")).toThrow(GemitermError);
-  });
-});

package/tests/integration/commands/auth.test.ts

@@ -1,186 +0,0 @@
-import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import { AuthCommand } from "../../../src/cli/commands/auth-command.ts";
-import { Mediator } from "../../../src/core/mediator.ts";
-import type { CliCommandContext } from "../../../src/cli/command-registry.ts";
-import { setupTestConfig, teardownTestConfig } from "../../setup.ts";
-import { createMockCookies, mockProfileDir } from "../../fixtures/auth-fixtures.ts";
-import * as configModule from "../../../src/infrastructure/config.ts";
-
-describe("auth command integration", () => {
-  let command: AuthCommand;
-  let context: CliCommandContext;
-  let logSpy: ReturnType<typeof spyOn>;
-  let originalEnv: Record<string, string | undefined>;
-
-  beforeEach(() => {
-    command = new AuthCommand();
-    context = { verbose: false, mediator: new Mediator() };
-    logSpy = spyOn(console, "log").mockImplementation(() => {});
-    originalEnv = {
-      GEMITERM_CONFIG_DIR: process.env.GEMITERM_CONFIG_DIR,
-    };
-    const configDir = setupTestConfig("auth-integration");
-    spyOn(configModule, "getConfigDir").mockReturnValue(configDir);
-    spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
-    spyOn(configModule, "getDefaultProfileName").mockReturnValue("default");
-  });
-
-  afterEach(() => {
-    mock.restore();
-    logSpy.mockRestore();
-    teardownTestConfig(originalEnv);
-  });
-
-  describe("command metadata", () => {
-    test("has correct name and description", () => {
-      expect(command.name).toBe("auth");
-      expect(command.description).toBe("Authenticate with Google Gemini");
-    });
-  });
-
-  describe("auth flow with mock browser", () => {
-    test("creates first profile and authenticates when no profiles exist", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue([]);
-      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
-
-      await command.execute([], context);
-
-      expect(authSpy).toHaveBeenCalledWith(
-        expect.anything(),
-        "default",
-        expect.anything(),
-        true,
-      );
-    });
-
-    test("authenticates with the only profile when one exists", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue(["solo"]);
-      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
-
-      await command.execute([], context);
-
-      expect(authSpy).toHaveBeenCalledWith(
-        expect.anything(),
-        "solo",
-        expect.anything(),
-        false,
-      );
-    });
-
-    test("propagates authentication errors", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue(["default"]);
-      spyOn(command as any, "authenticateWithProfile").mockRejectedValue(
-        new Error("Browser launch failed"),
-      );
-
-      await expect(command.execute([], context)).rejects.toThrow("Browser launch failed");
-    });
-  });
-
-  describe("profile selection menu", () => {
-    test("displays profile menu when multiple profiles exist", async () => {
-      const profiles = ["work", "personal", "dev"];
-
-      spyOn(configModule, "listProfiles").mockReturnValue(profiles);
-      const menuSpy = spyOn(command as any, "showProfileMenu").mockResolvedValue(null);
-
-      await command.execute([], context);
-
-      expect(menuSpy).toHaveBeenCalledWith(profiles, expect.anything());
-    });
-
-    test("menu shows all profile options", async () => {
-      const profiles = ["alpha", "beta"];
-      spyOn(command as any, "promptInput").mockResolvedValue("X");
-
-      const mockProfileManager = {
-        getStatus: mock((name: string) => ({
-          name,
-          exists: true,
-          isActive: true,
-          expiresAt: null,
-          isDefault: name === "alpha",
-        })),
-        create: mock(() => {}),
-        delete: mock(() => {}),
-        rename: mock(() => {}),
-        setDefault: mock(() => {}),
-      };
-
-      await (command as any).showProfileMenu(profiles, mockProfileManager);
-
-      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("[A]");
-      expect(output).toContain("Add new profile");
-      expect(output).toContain("[D]");
-      expect(output).toContain("Delete profile");
-      expect(output).toContain("[S]");
-      expect(output).toContain("Set default");
-      expect(output).toContain("[R]");
-      expect(output).toContain("Rename profile");
-      expect(output).toContain("[X]");
-      expect(output).toContain("Exit");
-    });
-
-    test("selecting a profile from menu triggers authentication", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue(["p1", "p2"]);
-      spyOn(command as any, "showProfileMenu").mockResolvedValue({
-        type: "auth",
-        profileName: "p2",
-      });
-      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
-
-      await command.execute([], context);
-
-      expect(authSpy).toHaveBeenCalledWith(
-        expect.anything(),
-        "p2",
-        expect.anything(),
-        false,
-      );
-    });
-
-    test("exiting menu continues with default profile", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue(["p1", "p2"]);
-      spyOn(command as any, "showProfileMenu").mockResolvedValue(null);
-
-      await command.execute([], context);
-
-      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("Continuing with current default");
-    });
-
-    test("adding profile from menu triggers auth with new name", async () => {
-      const profiles = ["existing"];
-      const newProfileName = "brand-new";
-
-      spyOn(configModule, "listProfiles").mockReturnValue(profiles);
-
-      const mockProfileManager = {
-        create: mock(() => {}),
-        getStatus: mock(() => ({
-          name: "existing",
-          exists: true,
-          isActive: true,
-          expiresAt: null,
-          isDefault: true,
-        })),
-        delete: mock(() => {}),
-        rename: mock(() => {}),
-        setDefault: mock(() => {}),
-      };
-
-      spyOn(command as any, "promptInput").mockImplementation(
-        (prompt: string) => {
-          if (prompt.includes("Select")) return Promise.resolve("A");
-          if (prompt.includes("Enter profile name")) return Promise.resolve(newProfileName);
-          return Promise.resolve("");
-        },
-      );
-
-      const result = await (command as any).showProfileMenu(profiles, mockProfileManager);
-
-      expect(result).toEqual({ type: "auth", profileName: newProfileName });
-    });
-  });
-});