gemiterm 2.0.0

package/tests/fixtures/auth-fixtures.ts

@@ -0,0 +1,98 @@
+import type { Cookie } from "../../src/core/types.ts";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { getTestConfigDir, createTestConfigDir } from "../setup.ts";
+
+const MOCK_COOKIE_DEFAULTS: Omit<Cookie, "name" | "value" | "expires"> = {
+  domain: ".google.com",
+  path: "/",
+  httpOnly: true,
+  secure: true,
+  sameSite: "None",
+};
+
+const FUTURE_EXPIRY = Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60;
+const PAST_EXPIRY = Math.floor(Date.now() / 1000) - 30 * 24 * 60 * 60;
+
+export interface MockCookiesOptions {
+  count?: number;
+  names?: string[];
+  expiry?: number;
+  values?: Record<string, string>;
+}
+
+export function createMockCookies(options: MockCookiesOptions = {}): Cookie[] {
+  const {
+    count = 4,
+    names,
+    expiry = FUTURE_EXPIRY,
+    values = {},
+  } = options;
+
+  const defaultNames = [
+    "__Secure-1PSID",
+    "__Secure-1PSIDTS",
+    "__Secure-1PSIDCC",
+    "NID",
+  ];
+
+  const cookieNames = names ?? defaultNames.slice(0, count);
+
+  return cookieNames.map((name) => ({
+    name,
+    value: values[name] ?? `mock-value-${name}`,
+    ...MOCK_COOKIE_DEFAULTS,
+    expires: expiry,
+  }));
+}
+
+export interface MockStorageStateOptions {
+  cookies?: Cookie[];
+  expiry?: number;
+}
+
+export function createMockStorageState(options: MockStorageStateOptions = {}): object {
+  const cookies = options.cookies ?? createMockCookies({ expiry: options.expiry ?? FUTURE_EXPIRY });
+  return { cookies };
+}
+
+export function createExpiredStorageState(): object {
+  const cookies = createMockCookies({ expiry: PAST_EXPIRY });
+  return { cookies };
+}
+
+export interface MockProfileDirOptions {
+  profileName?: string;
+  configDir?: string;
+  cookies?: Cookie[];
+  expired?: boolean;
+}
+
+export function mockProfileDir(options: MockProfileDirOptions = {}): string {
+  const {
+    profileName = "test-profile",
+    configDir,
+    expired = false,
+  } = options;
+
+  let dir: string;
+  try {
+    dir = configDir ?? getTestConfigDir();
+  } catch {
+    dir = createTestConfigDir();
+  }
+
+  const resolvedDir = resolve(dir);
+  const profileDir = join(resolvedDir, "profiles", profileName);
+  mkdirSync(profileDir, { recursive: true });
+
+  const state = expired
+    ? createExpiredStorageState()
+    : createMockStorageState({ cookies: options.cookies });
+
+  const filePath = join(profileDir, "storage_state.json");
+  writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
+
+  return profileDir;
+}

package/tests/fixtures/chat-fixtures.ts

@@ -0,0 +1,87 @@
+import type { ChatInfo, Message, Conversation } from "../../src/core/types.ts";
+
+export interface MockChatInfoOptions {
+  count?: number;
+  ids?: string[];
+  titles?: string[];
+  pinnedIndices?: number[];
+  baseTimestamp?: number;
+}
+
+export function createMockChatList(options: MockChatInfoOptions = {}): ChatInfo[] {
+  const {
+    count = 3,
+    ids,
+    titles,
+    pinnedIndices = [],
+    baseTimestamp = Date.now(),
+  } = options;
+
+  const defaultIds = ["conv-abc123", "conv-def456", "conv-ghi789", "conv-jkl012", "conv-mno345"];
+  const defaultTitles = [
+    "Chat about TypeScript",
+    "Pinned conversation",
+    "Bun runtime overview",
+    "Testing strategies",
+    "Deployment options",
+  ];
+
+  return Array.from({ length: count }, (_, i) => ({
+    id: ids?.[i] ?? defaultIds[i] ?? `conv-${i}`,
+    title: titles?.[i] ?? defaultTitles[i] ?? `Untitled chat ${i + 1}`,
+    isPinned: pinnedIndices.includes(i),
+    timestamp: baseTimestamp - i * 86400000,
+  }));
+}
+
+export interface MockMessageOptions {
+  count?: number;
+  conversationId?: string;
+  roles?: Array<"user" | "model">;
+  contents?: string[];
+}
+
+export function createMockMessageHistory(options: MockMessageOptions = {}): Message[] {
+  const {
+    count = 4,
+    conversationId,
+    roles,
+    contents,
+  } = options;
+
+  const defaultRoles: Array<"user" | "model"> = ["user", "model", "user", "model"];
+  const defaultContents = [
+    "Hello, Gemini!",
+    "Hi there! How can I help you today?",
+    "Tell me about TypeScript.",
+    "TypeScript is a typed superset of JavaScript.",
+  ];
+
+  return Array.from({ length: count }, (_, i) => ({
+    role: roles?.[i] ?? defaultRoles[i % defaultRoles.length],
+    content: contents?.[i] ?? defaultContents[i % defaultContents.length],
+    ...(conversationId ? { conversationId } : {}),
+  }));
+}
+
+export interface MockConversationOptions {
+  id?: string;
+  title?: string;
+  messages?: Message[];
+  messageCount?: number;
+}
+
+export function createMockConversation(options: MockConversationOptions = {}): Conversation {
+  const {
+    id = "conv-abc123",
+    title = "Chat about TypeScript",
+    messages,
+    messageCount = 4,
+  } = options;
+
+  return {
+    id,
+    title,
+    messages: messages ?? createMockMessageHistory({ count: messageCount, conversationId: id }),
+  };
+}

package/tests/infrastructure/cli-table.test.ts

@@ -0,0 +1,107 @@
+import { describe, test, expect } from "bun:test";
+import { renderTable, type ColumnDef } from "../../src/infrastructure/cli-table.ts";
+
+interface Row {
+  name: string;
+  age: number;
+}
+
+describe("renderTable", () => {
+  test("returns dim emptyMessage for empty rows", () => {
+    const out = renderTable<Row>({
+      columns: [
+        { header: "Name", width: 10, cell: (r) => r.name },
+        { header: "Age", width: 5, cell: (r) => String(r.age) },
+      ],
+      rows: [],
+      emptyMessage: "Nothing here",
+    });
+    expect(out).toContain("Nothing here");
+    expect(out).not.toContain("Name");
+  });
+
+  test("renders header row with column names", () => {
+    const out = renderTable<Row>({
+      columns: [
+        { header: "Name", width: 10, cell: (r) => r.name },
+        { header: "Age", width: 5, cell: (r) => String(r.age) },
+      ],
+      rows: [{ name: "Alice", age: 30 }],
+    });
+    expect(out).toContain("Name");
+    expect(out).toContain("Age");
+  });
+
+  test("renders data rows with cell values", () => {
+    const out = renderTable<Row>({
+      columns: [
+        { header: "Name", width: 10, cell: (r) => r.name },
+        { header: "Age", width: 5, cell: (r) => String(r.age) },
+      ],
+      rows: [
+        { name: "Alice", age: 30 },
+        { name: "Bob", age: 25 },
+      ],
+    });
+    expect(out).toContain("Alice");
+    expect(out).toContain("30");
+    expect(out).toContain("Bob");
+    expect(out).toContain("25");
+  });
+
+  test("includes Unicode box-drawing borders", () => {
+    const out = renderTable<Row>({
+      columns: [
+        { header: "Name", width: 10, cell: (r) => r.name },
+        { header: "Age", width: 5, cell: (r) => String(r.age) },
+      ],
+      rows: [{ name: "Alice", age: 30 }],
+    });
+    expect(out).toMatch(/[\u2500-\u257f]/);
+  });
+
+  test("appends footer when provided", () => {
+    const out = renderTable<Row>({
+      columns: [
+        { header: "Name", width: 10, cell: (r) => r.name },
+        { header: "Age", width: 5, cell: (r) => String(r.age) },
+      ],
+      rows: [{ name: "Alice", age: 30 }],
+      footer: "Total: 1",
+    });
+    expect(out).toContain("Total: 1");
+  });
+
+  test("does not crash with zero columns", () => {
+    const out = renderTable<Row>({
+      columns: [],
+      rows: [{ name: "Alice", age: 30 }],
+    });
+    expect(typeof out).toBe("string");
+  });
+
+  test("handles zero rows with no emptyMessage", () => {
+    const out = renderTable<Row>({
+      columns: [
+        { header: "Name", width: 10, cell: (r) => r.name },
+        { header: "Age", width: 5, cell: (r) => String(r.age) },
+      ],
+      rows: [],
+    });
+    expect(out).toContain("Name");
+  });
+
+  test("respects optional PROFILE-style spread-in column", () => {
+    const includeExtra = true;
+    const columns: ColumnDef<Row & { extra?: string }>[] = [
+      { header: "Name", width: 10, cell: (r) => r.name },
+      ...(includeExtra ? [{ header: "Extra", width: 8, cell: (r: Row & { extra?: string }) => r.extra ?? "" }] : []),
+    ];
+    const out = renderTable({
+      columns,
+      rows: [{ name: "Alice", age: 30, extra: "yes" }],
+    });
+    expect(out).toContain("Extra");
+    expect(out).toContain("yes");
+  });
+});

package/tests/infrastructure/formatters.test.ts

@@ -0,0 +1,202 @@
+import { describe, test, expect } from "bun:test";
+import {
+  formatChatAsMarkdown,
+  formatChatAsJson,
+  formatProfileTable,
+  formatChatList,
+} from "../../src/infrastructure/formatters.ts";
+import type { Message, ChatInfo, ProfileStatus } from "../../src/core/types.ts";
+
+function makeMessages(): Message[] {
+  return [
+    { role: "user", content: "Hello, Gemini!" },
+    { role: "model", content: "Hi there! How can I help you today?" },
+    { role: "user", content: "Tell me about TypeScript." },
+    { role: "model", content: "TypeScript is a typed superset of JavaScript." },
+  ];
+}
+
+function makeChats(): ChatInfo[] {
+  return [
+    { id: "abc123", title: "Chat about TypeScript", isPinned: false, timestamp: Date.now() },
+    { id: "def456", title: "Pinned conversation", isPinned: true, timestamp: Date.now() - 86400000 },
+  ];
+}
+
+function makeStatuses(): ProfileStatus[] {
+  return [
+    {
+      name: "default",
+      exists: true,
+      isActive: true,
+      expiresAt: new Date(Date.now() + 7 * 86400000).toISOString(),
+      isDefault: true,
+    },
+    {
+      name: "expired-profile",
+      exists: true,
+      isActive: false,
+      expiresAt: new Date(Date.now() - 86400000).toISOString(),
+      isDefault: false,
+    },
+    {
+      name: "missing-cookies",
+      exists: true,
+      isActive: false,
+      expiresAt: null,
+      isDefault: false,
+    },
+  ];
+}
+
+describe("formatChatAsMarkdown", () => {
+  test("renders messages with proper markdown headers", () => {
+    const messages = makeMessages();
+    const result = formatChatAsMarkdown(messages, "Test Chat");
+
+    expect(result).toContain("# Test Chat");
+    expect(result).toContain("**You:**");
+    expect(result).toContain("**Gemini:**");
+    expect(result).toContain("Hello, Gemini!");
+    expect(result).toContain("TypeScript is a typed superset of JavaScript.");
+  });
+
+  test("includes separator lines between messages", () => {
+    const result = formatChatAsMarkdown(makeMessages(), "Title");
+    const separatorCount = (result.match(/^---$/gm) ?? []).length;
+    expect(separatorCount).toBe(4);
+  });
+
+  test("includes metadata when includeMetadata is true and conversationId provided", () => {
+    const result = formatChatAsMarkdown(
+      makeMessages(),
+      "Meta Chat",
+      "conv-xyz",
+      true,
+    );
+
+    expect(result).toContain("> Conversation ID: conv-xyz");
+    expect(result).toContain("> Messages: 4");
+    expect(result).toContain("> Exported:");
+  });
+
+  test("omits metadata when includeMetadata is false", () => {
+    const result = formatChatAsMarkdown(
+      makeMessages(),
+      "No Meta",
+      "conv-xyz",
+      false,
+    );
+
+    expect(result).not.toContain("> Conversation ID:");
+    expect(result).not.toContain("> Messages:");
+  });
+
+  test("handles empty messages array", () => {
+    const result = formatChatAsMarkdown([], "Empty Chat");
+    expect(result).toContain("# Empty Chat");
+    expect(result).not.toContain("**You:**");
+    expect(result).not.toContain("**Gemini:**");
+  });
+});
+
+describe("formatChatAsJson", () => {
+  test("returns valid JSON with conversationId and messages", () => {
+    const messages = makeMessages();
+    const result = formatChatAsJson(messages, "conv-123");
+
+    const parsed = JSON.parse(result);
+    expect(parsed.conversationId).toBe("conv-123");
+    expect(parsed.messages).toHaveLength(4);
+    expect(parsed.messages[0].role).toBe("user");
+    expect(parsed.messages[0].content).toBe("Hello, Gemini!");
+  });
+
+  test("handles empty messages array", () => {
+    const result = formatChatAsJson([], "conv-empty");
+    const parsed = JSON.parse(result);
+    expect(parsed.conversationId).toBe("conv-empty");
+    expect(parsed.messages).toEqual([]);
+  });
+});
+
+describe("formatProfileTable", () => {
+  test("renders profile statuses in table format", () => {
+    const statuses = makeStatuses();
+    const result = formatProfileTable(statuses);
+
+    expect(result).toContain("NAME");
+    expect(result).toContain("ACTIVE");
+    expect(result).toContain("EXPIRES");
+    expect(result).toContain("DEFAULT");
+    expect(result).toContain("default");
+    expect(result).toContain("expired-profile");
+  });
+
+  test("shows active checkmark for active profile", () => {
+    const statuses = makeStatuses();
+    const result = formatProfileTable(statuses);
+    expect(result).toContain("\u2713");
+  });
+
+  test("shows inactive X for inactive profile", () => {
+    const statuses = makeStatuses();
+    const result = formatProfileTable(statuses);
+    expect(result).toContain("\u2717");
+  });
+
+  test("shows default marker note", () => {
+    const result = formatProfileTable(makeStatuses());
+    expect(result).toContain("default profile");
+  });
+
+  test("returns message when no profiles exist", () => {
+    const result = formatProfileTable([]);
+    expect(result).toContain("No profiles found");
+  });
+
+  test("shows N/A for missing expiry date", () => {
+    const statuses: ProfileStatus[] = [
+      {
+        name: "no-expiry",
+        exists: true,
+        isActive: true,
+        expiresAt: null,
+        isDefault: false,
+      },
+    ];
+    const result = formatProfileTable(statuses);
+    expect(result).toContain("no-expiry");
+  });
+});
+
+describe("formatChatList", () => {
+  test("renders chat list in table format", () => {
+    const chats = makeChats();
+    const result = formatChatList(chats);
+
+    expect(result).toContain("ID");
+    expect(result).toContain("TITLE");
+    expect(result).toContain("DATE");
+    expect(result).toContain("abc123");
+    expect(result).toContain("Chat about TypeScript");
+  });
+
+  test("shows total count footer", () => {
+    const result = formatChatList(makeChats());
+    expect(result).toContain("Total: 2 conversations");
+  });
+
+  test("shows singular when only one chat", () => {
+    const chats: ChatInfo[] = [
+      { id: "solo", title: "Solo chat", isPinned: false, timestamp: Date.now() },
+    ];
+    const result = formatChatList(chats);
+    expect(result).toContain("Total: 1 conversation");
+  });
+
+  test("returns message when no chats exist", () => {
+    const result = formatChatList([]);
+    expect(result).toContain("No conversations found");
+  });
+});

package/tests/infrastructure/io.test.ts

@@ -0,0 +1,197 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  ensureDir,
+  existsFile,
+  readTextFile,
+  safeReadTextFile,
+  writeTextFile,
+  readJsonFile,
+  writeJsonFile,
+  removeDir,
+  renameDir,
+  isDirectory,
+  listSubdirectories,
+  IOError,
+} from "../../src/infrastructure/io.ts";
+
+const TEST_ROOT = join(tmpdir(), `gemiterm-io-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+beforeEach(() => {
+  ensureDir(TEST_ROOT);
+});
+
+afterEach(() => {
+  try {
+    removeDir(TEST_ROOT);
+  } catch {
+    // ignore
+  }
+});
+
+describe("IOError", () => {
+  test("has correct name and message", () => {
+    const err = new IOError("boom");
+    expect(err.name).toBe("IOError");
+    expect(err.message).toBe("boom");
+    expect(err.cause).toBeUndefined();
+  });
+
+  test("preserves cause", () => {
+    const cause = new Error("underlying");
+    const err = new IOError("wrapper", cause);
+    expect(err.cause).toBe(cause);
+  });
+});
+
+describe("ensureDir", () => {
+  test("creates a directory that does not exist", () => {
+    const dir = join(TEST_ROOT, "new-dir");
+    expect(existsFile(dir)).toBe(false);
+    ensureDir(dir);
+    expect(existsFile(dir)).toBe(true);
+    expect(isDirectory(dir)).toBe(true);
+  });
+
+  test("creates nested directories recursively", () => {
+    const dir = join(TEST_ROOT, "a", "b", "c");
+    expect(existsFile(dir)).toBe(false);
+    ensureDir(dir);
+    expect(isDirectory(dir)).toBe(true);
+    expect(isDirectory(join(TEST_ROOT, "a", "b"))).toBe(true);
+    expect(isDirectory(join(TEST_ROOT, "a"))).toBe(true);
+  });
+
+  test("is a no-op on an existing directory", () => {
+    ensureDir(TEST_ROOT);
+    expect(() => ensureDir(TEST_ROOT)).not.toThrow();
+  });
+});
+
+describe("existsFile", () => {
+  test("returns true for an existing file", () => {
+    const file = join(TEST_ROOT, "marker.txt");
+    ensureDir(TEST_ROOT);
+    writeTextFile(file, "x");
+    expect(existsFile(file)).toBe(true);
+  });
+
+  test("returns false for a missing file", () => {
+    expect(existsFile(join(TEST_ROOT, "nope.txt"))).toBe(false);
+  });
+});
+
+describe("readTextFile", () => {
+  test("reads an existing file as UTF-8", () => {
+    const file = join(TEST_ROOT, "read.txt");
+    writeTextFile(file, "hello");
+    expect(readTextFile(file)).toBe("hello");
+  });
+
+  test("throws IOError on a missing file", () => {
+    expect(() => readTextFile(join(TEST_ROOT, "nope.txt"))).toThrow(IOError);
+  });
+});
+
+describe("safeReadTextFile", () => {
+  test("returns the content of an existing file", () => {
+    const file = join(TEST_ROOT, "safe.txt");
+    writeTextFile(file, "content");
+    expect(safeReadTextFile(file)).toBe("content");
+  });
+
+  test("returns the empty string on a missing file", () => {
+    expect(safeReadTextFile(join(TEST_ROOT, "nope.txt"))).toBe("");
+  });
+});
+
+describe("writeTextFile", () => {
+  test("writes a new file", () => {
+    const file = join(TEST_ROOT, "out.txt");
+    writeTextFile(file, "data");
+    expect(existsFile(file)).toBe(true);
+    expect(readTextFile(file)).toBe("data");
+  });
+
+  test("creates nested directories that do not exist", () => {
+    const file = join(TEST_ROOT, "nested", "deep", "out.txt");
+    writeTextFile(file, "data");
+    expect(readTextFile(file)).toBe("data");
+  });
+});
+
+describe("readJsonFile and writeJsonFile", () => {
+  test("round-trips a JSON object", () => {
+    const file = join(TEST_ROOT, "obj.json");
+    const original = { a: 1, b: ["x", "y"], c: { nested: true } };
+    writeJsonFile(file, original);
+    const read = readJsonFile<typeof original>(file);
+    expect(read).toEqual(original);
+  });
+
+  test("readJsonFile throws on missing file", () => {
+    expect(() => readJsonFile(join(TEST_ROOT, "missing.json"))).toThrow(IOError);
+  });
+});
+
+describe("removeDir", () => {
+  test("removes a directory recursively", () => {
+    const dir = join(TEST_ROOT, "rm");
+    ensureDir(dir);
+    writeTextFile(join(dir, "f.txt"), "x");
+    expect(existsFile(dir)).toBe(true);
+    removeDir(dir);
+    expect(existsFile(dir)).toBe(false);
+  });
+
+  test("is a no-op on a missing path", () => {
+    expect(() => removeDir(join(TEST_ROOT, "nope"))).not.toThrow();
+  });
+});
+
+describe("renameDir", () => {
+  test("renames a directory", () => {
+    const src = join(TEST_ROOT, "src");
+    const dest = join(TEST_ROOT, "dest");
+    ensureDir(src);
+    expect(isDirectory(src)).toBe(true);
+    renameDir(src, dest);
+    expect(isDirectory(src)).toBe(false);
+    expect(isDirectory(dest)).toBe(true);
+  });
+
+  test("throws when source is missing", () => {
+    expect(() => renameDir(join(TEST_ROOT, "nope"), join(TEST_ROOT, "dest"))).toThrow(IOError);
+  });
+});
+
+describe("isDirectory", () => {
+  test("returns true for a directory", () => {
+    expect(isDirectory(TEST_ROOT)).toBe(true);
+  });
+
+  test("returns false for a file", () => {
+    const file = join(TEST_ROOT, "f.txt");
+    writeTextFile(file, "x");
+    expect(isDirectory(file)).toBe(false);
+  });
+
+  test("returns false for a missing path", () => {
+    expect(isDirectory(join(TEST_ROOT, "nope"))).toBe(false);
+  });
+});
+
+describe("listSubdirectories", () => {
+  test("returns only subdirectory names", () => {
+    ensureDir(join(TEST_ROOT, "a"));
+    ensureDir(join(TEST_ROOT, "b"));
+    writeTextFile(join(TEST_ROOT, "not-a-dir.txt"), "x");
+    const subs = listSubdirectories(TEST_ROOT).sort();
+    expect(subs).toEqual(["a", "b"]);
+  });
+
+  test("returns an empty array for a missing path", () => {
+    expect(listSubdirectories(join(TEST_ROOT, "nope"))).toEqual([]);
+  });
+});