gemiterm 2.0.0

package/src/services/playwright-cli-driver.ts

@@ -0,0 +1,269 @@
+import { getProfileDir, getTempFilePath } from "../infrastructure/path-utils.ts";
+import { readJsonFile, removeDir } from "../infrastructure/io.ts";
+import type { Cookie } from "../core/types.ts";
+
+const CLI_BIN_DIRECT = "playwright-cli";
+const CLI_BIN_FALLBACK = "bunx";
+const CLI_PACKAGE = "@playwright/cli";
+const PROBE_TIMEOUT_MS = 5_000;
+const BROWSER_CLOSED_MESSAGE = "not found";
+
+export class PlaywrightCliError extends Error {
+  constructor(command: string, exitCode: number, stderr: string) {
+    super(`playwright-cli '${command}' exited with code ${exitCode}: ${stderr}`);
+    this.name = "PlaywrightCliError";
+  }
+}
+
+export interface PlaywrightRunnerResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export type PlaywrightStrategy = "direct" | "bunx";
+
+export interface PlaywrightRunner {
+  readonly strategy: PlaywrightStrategy;
+  run(args: string[]): Promise<PlaywrightRunnerResult>;
+  spawnDetached(args: string[]): void;
+}
+
+class BunPlaywrightRunner implements PlaywrightRunner {
+  readonly strategy: PlaywrightStrategy;
+  private readonly bin: string[];
+
+  constructor(strategy: PlaywrightStrategy) {
+    this.strategy = strategy;
+    this.bin = strategy === "direct" ? [CLI_BIN_DIRECT] : [CLI_BIN_FALLBACK, CLI_PACKAGE];
+  }
+
+  async run(args: string[]): Promise<PlaywrightRunnerResult> {
+    const proc = Bun.spawn([...this.bin, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return {
+      exitCode: exitCode ?? -1,
+      stdout: stdout.trim(),
+      stderr: stderr.trim(),
+    };
+  }
+
+  spawnDetached(args: string[]): void {
+    const proc = Bun.spawn([...this.bin, ...args], {
+      stdout: "ignore",
+      stderr: "ignore",
+      stdin: "ignore",
+    });
+    proc.exited.catch(() => {});
+  }
+}
+
+export interface PlaywrightCliDriverOptions {
+  logger?: Console;
+  runner?: PlaywrightRunner;
+  profileDirResolver?: (profileName: string) => string;
+}
+
+export class PlaywrightCliDriver {
+  private readonly logger?: Console;
+  private runner: PlaywrightRunner;
+  private readonly profileDirResolver: (profileName: string) => string;
+  private probed = false;
+
+  constructor(opts: PlaywrightCliDriverOptions = {}) {
+    this.logger = opts.logger;
+    this.profileDirResolver = opts.profileDirResolver ?? ((name) => getProfileDir(name));
+    this.runner = opts.runner ?? new BunPlaywrightRunner("direct");
+  }
+
+  async isAvailable(): Promise<boolean> {
+    if (!this.probed) {
+      const ok = await this.probe();
+      this.probed = true;
+      return ok;
+    }
+    return true;
+  }
+
+  get strategy(): PlaywrightStrategy {
+    return this.runner.strategy;
+  }
+
+  async runCli(args: string[]): Promise<string> {
+    const result = await this.runner.run(args);
+    if (result.exitCode !== 0) {
+      throw new PlaywrightCliError(args.join(" "), result.exitCode, result.stderr);
+    }
+    return result.stdout;
+  }
+
+  withSession(session: string, args: string[]): string[] {
+    return [`-s=${session}`, ...args];
+  }
+
+  buildOpenHeadedArgs(url: string, profile: string, session?: string): string[] {
+    const args: string[] = [];
+    if (session) {
+      args.push(`-s=${session}`);
+    }
+    args.push(
+      "open",
+      "--browser=chromium",
+      "--headed",
+      "--persistent",
+      `--profile=${this.profileDirResolver(profile)}`,
+      url,
+    );
+    return args;
+  }
+
+  async openHeaded(url: string, profile: string, session?: string): Promise<void> {
+    const args = this.buildOpenHeadedArgs(url, profile, session);
+    await this.runCli(args);
+  }
+
+  async evalJs(session: string, expression: string): Promise<string> {
+    return this.runCli(this.withSession(session, ["eval", expression, "--raw"]));
+  }
+
+  async cookieList(session: string): Promise<Cookie[]> {
+    const raw = await this.runCli(this.withSession(session, ["cookie-list", "--json"]));
+    return this.parseCookieListOutput(raw);
+  }
+
+  async cookieListFromState(session: string): Promise<Cookie[]> {
+    const tempPath = getTempFilePath("gemiterm-state", ".json");
+    try {
+      await this.stateSave(session, tempPath);
+      const state = readJsonFile<{ cookies?: unknown[] }>(tempPath);
+      const cookies = Array.isArray(state.cookies) ? state.cookies : [];
+      return cookies
+        .filter((c): c is Record<string, unknown> => c !== null && typeof c === "object")
+        .map((c) => this.cookieFromObject(c));
+    } finally {
+      removeDir(tempPath);
+    }
+  }
+
+  async stateSave(session: string, path: string): Promise<void> {
+    await this.runCli(this.withSession(session, ["state-save", path]));
+  }
+
+  async stateLoad(session: string, path: string): Promise<void> {
+    await this.runCli(this.withSession(session, ["state-load", path]));
+  }
+
+  async closeSession(session: string): Promise<void> {
+    try {
+      await this.runCli(this.withSession(session, ["close"]));
+    } catch (err) {
+      if (err instanceof PlaywrightCliError && err.message.toLowerCase().includes(BROWSER_CLOSED_MESSAGE)) {
+        return;
+      }
+      throw err;
+    }
+  }
+
+  async closeAll(): Promise<void> {
+    await this.runCli(["close-all"]);
+  }
+
+  private async probe(): Promise<boolean> {
+    const direct = new BunPlaywrightRunner("direct");
+    if (await this.tryVersion(direct)) {
+      this.runner = direct;
+      return true;
+    }
+    const bunx = new BunPlaywrightRunner("bunx");
+    if (await this.tryVersion(bunx)) {
+      this.runner = bunx;
+      return true;
+    }
+    this.logger?.warn("Neither 'playwright-cli' nor 'bunx @playwright/cli' is available on this system.");
+    return false;
+  }
+
+  private async tryVersion(r: BunPlaywrightRunner): Promise<boolean> {
+    try {
+      const result = await Promise.race([
+        r.run(["--version"]),
+        new Promise<{ exitCode: number }>((_, reject) =>
+          setTimeout(() => reject(new Error("probe timeout")), PROBE_TIMEOUT_MS),
+        ),
+      ]);
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  private parseCookieListOutput(raw: string): Cookie[] {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        return parsed.map((c: Record<string, unknown>) => this.cookieFromObject(c));
+      }
+      if (parsed && typeof parsed === "object" && typeof (parsed as { result?: unknown }).result === "string") {
+        const inner = (parsed as { result: string }).result;
+        if (inner === "No cookies found") return [];
+        try {
+          const innerParsed = JSON.parse(inner);
+          if (Array.isArray(innerParsed)) {
+            return innerParsed.map((c: Record<string, unknown>) => this.cookieFromObject(c));
+          }
+        } catch {
+          // inner was not a JSON array — fall through to the plain-text parser
+        }
+        return this.parseCookieListText(inner);
+      }
+    } catch {
+      // not JSON; treat raw as plain text
+    }
+    return this.parseCookieListText(raw);
+  }
+
+  private parseCookieListText(text: string): Cookie[] {
+    const cookies: Cookie[] = [];
+    const re = /^([^=]+)=(.+) \(domain: ([^,]+), path: (.+)\)$/;
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed === "No cookies found") continue;
+      const match = trimmed.match(re);
+      if (!match) continue;
+      cookies.push(this.cookieFromObject({
+        name: match[1],
+        value: match[2],
+        domain: match[3],
+        path: match[4],
+        expires: -1,
+        httpOnly: false,
+        secure: false,
+        sameSite: "None",
+      }));
+    }
+    return cookies;
+  }
+
+  private cookieFromObject(c: Record<string, unknown>): Cookie {
+    return {
+      name: String(c.name ?? ""),
+      value: String(c.value ?? ""),
+      domain: String(c.domain ?? ""),
+      path: String(c.path ?? "/"),
+      expires: typeof c.expires === "number" ? c.expires : -1,
+      httpOnly: Boolean(c.httpOnly),
+      secure: Boolean(c.secure),
+      sameSite: (["Strict", "Lax", "None"].includes(String(c.sameSite))
+        ? String(c.sameSite)
+        : "None") as Cookie["sameSite"],
+    };
+  }
+}

package/src/services/profile-auth-manager.ts

@@ -0,0 +1,65 @@
+import type { Cookie } from "../core/types.ts";
+import type { Logger } from "../infrastructure/logger.ts";
+import type { ProfileManager } from "../infrastructure/storage.ts";
+import type { CookieStorageService } from "./cookie-storage-service.ts";
+import type { LoadedCookies } from "./cookie-storage-service.ts";
+import type { IGeminiClientService } from "../core/command-handlers.ts";
+import { AuthenticationError } from "../core/errors.ts";
+import { getDefaultProfileName } from "../infrastructure/config.ts";
+import { validateProfileName } from "../infrastructure/validators.ts";
+
+export interface ProfileAuthManagerDeps {
+  profileManager: ProfileManager;
+  cookieStorageService: CookieStorageService;
+  logger: Logger;
+  geminiClient: IGeminiClientService;
+}
+
+export class ProfileAuthManager {
+  private readonly profileManager: ProfileManager;
+  private readonly cookieStorageService: CookieStorageService;
+  private readonly logger: Logger;
+  private readonly geminiClient: IGeminiClientService;
+
+  constructor(deps: ProfileAuthManagerDeps) {
+    this.profileManager = deps.profileManager;
+    this.cookieStorageService = deps.cookieStorageService;
+    this.logger = deps.logger;
+    this.geminiClient = deps.geminiClient;
+  }
+
+  ensureAuthenticated(profileName?: string): LoadedCookies {
+    const name = profileName ?? getDefaultProfileName();
+    validateProfileName(name);
+
+    if (!this.profileManager.hasValidCookies(name)) {
+      throw new AuthenticationError(
+        `No valid session for profile '${name}'. Run 'gemiterm login' to authenticate.`,
+      );
+    }
+
+    this.logger.info(`Profile '${name}' is authenticated`);
+    return this.cookieStorageService.loadCookiesForProfile(name);
+  }
+
+  getActiveProfiles(): string[] {
+    const profiles = this.profileManager.list();
+    return profiles.filter((name) => this.profileManager.hasValidCookies(name));
+  }
+
+  async findProfileForConversation(conversationId: string): Promise<string | null> {
+    const profiles = this.profileManager.list();
+    for (const name of profiles) {
+      try {
+        const hasConversation = await this.geminiClient.profileHasConversation(name, conversationId);
+        if (hasConversation) {
+          return name;
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    return null;
+  }
+}

package/src/services/profile-service.ts

@@ -0,0 +1,121 @@
+import type { AuthResult, ProfileStatus, Cookie } from "../core/types.ts";
+import type { Logger } from "../infrastructure/logger.ts";
+import type { ProfileManager } from "../infrastructure/storage.ts";
+import { validateProfileName } from "../infrastructure/validators.ts";
+import { ensureConfigDir, getDefaultProfileName } from "../infrastructure/config.ts";
+import { AuthenticationError, GemitermError } from "../core/errors.ts";
+
+export class ProfileService {
+  private readonly profileManager: ProfileManager;
+  private readonly logger: Logger;
+
+  constructor(profileManager: ProfileManager, logger: Logger) {
+    this.profileManager = profileManager;
+    this.logger = logger;
+  }
+
+  async authenticate(profileName?: string): Promise<AuthResult> {
+    const name = profileName ?? getDefaultProfileName();
+    validateProfileName(name);
+
+    ensureConfigDir();
+    const profiles = this.profileManager.list();
+
+    if (!profiles.includes(name)) {
+      this.profileManager.create(name);
+      this.logger.info(`Created new profile: ${name}`);
+    }
+
+    if (!this.profileManager.hasValidCookies(name)) {
+      throw new AuthenticationError(
+        `No valid session for profile '${name}'. Run 'gemiterm login' to authenticate.`,
+      );
+    }
+
+    this.logger.info(`Authenticated with profile: ${name}`);
+    const cookies = this.profileManager.loadCookiesForApi(name);
+    const expiresMs = this.getCookieExpiryForProfile(name);
+
+    return {
+      cookies: this.buildCookieArray(cookies),
+      expiresAt: expiresMs !== null ? new Date(expiresMs) : null,
+    };
+  }
+
+  async getProfileStatuses(): Promise<ProfileStatus[]> {
+    ensureConfigDir();
+    return this.profileManager.getAllStatuses();
+  }
+
+  async getAuthStatus(): Promise<{ authenticated: boolean; profileName: string | null }> {
+    const defaultName = getDefaultProfileName();
+    if (!defaultName) {
+      return { authenticated: false, profileName: null };
+    }
+    const isValid = this.profileManager.hasValidCookies(defaultName);
+    return { authenticated: isValid, profileName: isValid ? defaultName : null };
+  }
+
+  async deleteProfile(name: string): Promise<void> {
+    validateProfileName(name);
+    const profiles = this.profileManager.list();
+    if (!profiles.includes(name)) {
+      throw new GemitermError(`Profile '${name}' does not exist.`);
+    }
+    this.profileManager.delete(name);
+    this.logger.info(`Deleted profile: ${name}`);
+  }
+
+  async renameProfile(oldName: string, newName: string): Promise<void> {
+    validateProfileName(oldName);
+    validateProfileName(newName);
+    this.profileManager.rename(oldName, newName);
+    this.logger.info(`Renamed profile: ${oldName} → ${newName}`);
+  }
+
+  async setDefaultProfile(name: string): Promise<void> {
+    validateProfileName(name);
+    this.profileManager.setDefault(name);
+    this.logger.info(`Set default profile: ${name}`);
+  }
+
+  private getCookieExpiryForProfile(profileName: string): number | null {
+    try {
+      const status = this.profileManager.getStatus(profileName);
+      if (!status.expiresAt) return null;
+      return Date.parse(status.expiresAt);
+    } catch {
+      return null;
+    }
+  }
+
+  private buildCookieArray(
+    cookies: { secure1psid: string; secure1psidts: string | null },
+  ): Cookie[] {
+    const result: Cookie[] = [
+      {
+        name: "__Secure-1PSID",
+        value: cookies.secure1psid,
+        domain: ".google.com",
+        path: "/",
+        expires: -1,
+        httpOnly: true,
+        secure: true,
+        sameSite: "None",
+      },
+    ];
+    if (cookies.secure1psidts) {
+      result.push({
+        name: "__Secure-1PSIDTS",
+        value: cookies.secure1psidts,
+        domain: ".google.com",
+        path: "/",
+        expires: -1,
+        httpOnly: true,
+        secure: true,
+        sameSite: "None",
+      });
+    }
+    return result;
+  }
+}

package/tests/cli/auth-command.test.ts

@@ -0,0 +1,220 @@
+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 * as configModule from "../../src/infrastructure/config.ts";
+
+describe("AuthCommand", () => {
+  let command: AuthCommand;
+  let context: CliCommandContext;
+  let listSpy: ReturnType<typeof spyOn>;
+  let defaultProfileSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new AuthCommand();
+    context = { verbose: false, mediator: new Mediator() };
+    listSpy = spyOn(configModule, "listProfiles").mockReturnValue([]);
+    defaultProfileSpy = spyOn(configModule, "getDefaultProfileName").mockReturnValue("default");
+  });
+
+  afterEach(() => {
+    mock.restore();
+    listSpy.mockRestore();
+    defaultProfileSpy.mockRestore();
+  });
+
+  test("has correct name and description", () => {
+    expect(command.name).toBe("auth");
+    expect(command.description).toBe("Authenticate with Google Gemini");
+  });
+
+  describe("execute", () => {
+    test("authenticates with default profile when no profiles exist", async () => {
+      listSpy.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 directly when only one profile exists", async () => {
+      listSpy.mockReturnValue(["my-profile"]);
+
+      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
+      await command.execute([], context);
+
+      expect(authSpy).toHaveBeenCalledWith(
+        expect.anything(),
+        "my-profile",
+        expect.anything(),
+        false,
+      );
+    });
+
+    test("shows profile menu when multiple profiles exist", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const menuSpy = spyOn(command as any, "showProfileMenu").mockResolvedValue(null);
+      await command.execute([], context);
+
+      expect(menuSpy).toHaveBeenCalled();
+    });
+
+    test("authenticates selected profile from menu", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const menuSpy = 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("exits when X is selected in profile menu", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const promptSpy = spyOn(command as any, "promptInput").mockResolvedValue("X");
+      const logSpy = spyOn(console, "log").mockImplementation(() => {});
+
+      await command.execute([], context);
+
+      expect(promptSpy).toHaveBeenCalledWith("Select an option");
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Continuing with current default"));
+      logSpy.mockRestore();
+    });
+
+    test("throws on invalid profile name when adding", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const promptSpy = 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("bad name!!");
+          return Promise.resolve("");
+        },
+      );
+
+      await expect(command.execute([], context)).rejects.toThrow("invalid characters");
+    });
+
+    test("throws when deleting nonexistent profile", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
+        (prompt: string) => {
+          if (prompt.includes("Select")) return Promise.resolve("D");
+          if (prompt.includes("Enter profile name to delete")) return Promise.resolve("ghost");
+          return Promise.resolve("");
+        },
+      );
+
+      await expect(command.execute([], context)).rejects.toThrow("does not exist");
+    });
+
+    test("cancels deletion when user answers no", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
+        (prompt: string) => {
+          if (prompt.includes("Select")) return Promise.resolve("D");
+          if (prompt.includes("Enter profile name to delete")) return Promise.resolve("p1");
+          if (prompt.includes("Delete profile")) return Promise.resolve("n");
+          return Promise.resolve("");
+        },
+      );
+
+      await command.execute([], context);
+    });
+
+    test("renames profile and authenticates with new name", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
+      const mockRename = mock(() => {});
+
+      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
+      const origProto = ProfileManager.prototype.rename;
+      ProfileManager.prototype.rename = mockRename;
+
+      try {
+        const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
+          (prompt: string) => {
+            if (prompt.includes("Select")) return Promise.resolve("R");
+            if (prompt.includes("current profile name")) return Promise.resolve("p1");
+            if (prompt.includes("new profile name")) return Promise.resolve("p1-new");
+            return Promise.resolve("");
+          },
+        );
+
+        await command.execute([], context);
+
+        expect(mockRename).toHaveBeenCalledWith("p1", "p1-new");
+        expect(authSpy).toHaveBeenCalledWith(
+          expect.anything(),
+          "p1-new",
+          expect.anything(),
+          false,
+        );
+      } finally {
+        ProfileManager.prototype.rename = origProto;
+      }
+    });
+
+    test("set default for a profile", async () => {
+      listSpy.mockReturnValue(["p1", "p2"]);
+
+      const logSpy = spyOn(console, "log").mockImplementation(() => {});
+      const setDefaultSpy = spyOn(configModule, "setDefaultProfileName").mockImplementation(() => {});
+      const mockSetDefault = mock(() => {});
+
+      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
+      const origProto = ProfileManager.prototype.setDefault;
+      ProfileManager.prototype.setDefault = mockSetDefault;
+
+      try {
+        const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
+          (prompt: string) => {
+            if (prompt.includes("Select")) return Promise.resolve("S");
+            if (prompt.includes("Enter profile name to set as default")) return Promise.resolve("p2");
+            return Promise.resolve("");
+          },
+        );
+
+        await command.execute([], context);
+
+        expect(mockSetDefault).toHaveBeenCalledWith("p2");
+        expect(setDefaultSpy).toHaveBeenCalledWith("p2");
+      } finally {
+        ProfileManager.prototype.setDefault = origProto;
+        logSpy.mockRestore();
+      }
+    });
+  });
+
+  describe("showProfileMenu", () => {
+    test("returns null for unknown option", async () => {
+      const promptSpy = spyOn(command as any, "promptInput").mockResolvedValue("Z");
+
+      const result = await (command as any).showProfileMenu(["p1"], {
+        getStatus: () => ({ name: "p1", exists: true, isActive: true, expiresAt: null, isDefault: true }),
+      } as any);
+
+      expect(result).toBeNull();
+    });
+  });
+});