gemiterm 2.0.0

package/src/infrastructure/path-utils.ts

@@ -0,0 +1,157 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir, platform, tmpdir } from "node:os";
+
+const STORAGE_STATE_FILE = "storage_state.json";
+const PROFILES_DIR = "profiles";
+const DEFAULT_PROFILE_MARKER = ".default";
+
+function _getConfigDir(): string {
+  const envOverride = process.env.GEMITERM_CONFIG_DIR;
+  if (envOverride) return envOverride;
+
+  if (platform() === "win32") {
+    const appData = process.env.APPDATA;
+    if (appData) return join(appData, "gemiterm");
+  }
+
+  return join(homedir(), "gemiterm");
+}
+
+function resolvePath(...parts: string[]): string {
+  return resolve(join(...parts));
+}
+
+function joinPath(...parts: string[]): string {
+  return join(...parts);
+}
+
+function dirnamePath(path: string): string {
+  return dirname(path);
+}
+
+function getConfigDir(): string {
+  return _getConfigDir();
+}
+
+function getProfilesDir(): string {
+  return join(getConfigDir(), PROFILES_DIR);
+}
+
+function getProfilePath(name: string): string {
+  return join(getProfilesDir(), name, STORAGE_STATE_FILE);
+}
+
+function getProfileDir(name: string): string {
+  return join(getProfilesDir(), name);
+}
+
+function getDefaultProfileMarkerPath(): string {
+  return join(getProfilesDir(), DEFAULT_PROFILE_MARKER);
+}
+
+function getTempFilePath(prefix: string, extension = ".tmp"): string {
+  const unique = `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  return join(tmpdir(), `${unique}${extension}`);
+}
+
+function isWSL(): boolean {
+  if (process.platform !== "linux") {
+    return false;
+  }
+  try {
+    if (existsSync("/proc/version")) {
+      const version = readFileSync("/proc/version", "utf-8").toLowerCase();
+      if (version.includes("microsoft") || version.includes("wsl")) {
+        return true;
+      }
+    }
+  } catch {
+    // ignore — fall through to env var check
+  }
+  const distro = process.env.WSL_DISTRO_NAME;
+  return typeof distro === "string" && distro.length > 0;
+}
+
+function getProjectRoot(importMetaUrl?: string): string {
+  const start = importMetaUrl
+    ? dirname(new URL(importMetaUrl).pathname.replace(/^\/([A-Za-z]:)/, "$1"))
+    : process.cwd();
+  let dir = start;
+  for (let i = 0; i < 32; i++) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  throw new Error(
+    `getProjectRoot: could not find a 'package.json' in any parent of ${start}`,
+  );
+}
+
+interface PackageJson {
+  name: string;
+  version: string;
+  [key: string]: unknown;
+}
+
+const PACKAGE_JSON_FALLBACK: PackageJson = { name: "gemiterm", version: "unknown" };
+
+// Build-time constants injected by `scripts/build.ts` via Bun.build `define`.
+// In dev/test runs they are ambient identifiers that resolve to `undefined`.
+// The dead-code branch below (returning PACKAGE_JSON_FALLBACK) is what
+// guarantees `typeof X === "string"` is false at runtime when no define was
+// injected, and also keeps the dist binary small because Bun's bundler
+// tree-shakes the unused literal when `__GEMITERM_VERSION__` is constant-folded.
+declare const __GEMITERM_VERSION__: string | undefined;
+declare const __GEMITERM_NAME__: string | undefined;
+
+const BUILD_TIME_PACKAGE: PackageJson | null =
+  typeof __GEMITERM_VERSION__ === "string" && __GEMITERM_VERSION__.length > 0
+    ? {
+        name: typeof __GEMITERM_NAME__ === "string" && __GEMITERM_NAME__.length > 0
+          ? __GEMITERM_NAME__
+          : PACKAGE_JSON_FALLBACK.name,
+        version: __GEMITERM_VERSION__,
+      }
+    : null;
+
+function getPackageJson(importMetaUrl?: string): PackageJson {
+  if (BUILD_TIME_PACKAGE !== null) {
+    return BUILD_TIME_PACKAGE;
+  }
+
+  try {
+    const root = getProjectRoot(importMetaUrl);
+    const raw = readFileSync(join(root, "package.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      return parsed as PackageJson;
+    }
+  } catch {
+    // fall through to fallback
+  }
+  return PACKAGE_JSON_FALLBACK;
+}
+
+export {
+  resolvePath,
+  joinPath,
+  dirnamePath,
+  getConfigDir,
+  getProfilesDir,
+  getProfilePath,
+  getProfileDir,
+  getDefaultProfileMarkerPath,
+  getTempFilePath,
+  isWSL,
+  getProjectRoot,
+  getPackageJson,
+  STORAGE_STATE_FILE,
+  PROFILES_DIR,
+  DEFAULT_PROFILE_MARKER,
+};

package/src/infrastructure/storage.ts

@@ -0,0 +1,209 @@
+import { ensureDir, existsFile, readJsonFile, writeTextFile, removeDir, renameDir } from "./io.ts";
+import type { Cookie, ProfileStatus } from "../core/types.ts";
+import {
+  getProfilePath,
+  getProfileDir,
+  getDefaultProfileMarkerPath,
+} from "./path-utils.ts";
+import {
+  getDefaultProfileName,
+  setDefaultProfileName,
+  listProfiles,
+} from "./config.ts";
+
+const COOKIE_EXPIRY_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1000;
+
+interface StorageState {
+  cookies: Cookie[];
+}
+
+function validateCookies(cookies: Cookie[]): boolean {
+  const names = new Set(cookies.map((c) => c.name));
+  return names.has("__Secure-1PSID") && names.has("__Secure-1PSIDTS");
+}
+
+function getCookieExpiryTimestamp(cookies: Cookie[]): number | null {
+  for (const cookie of cookies) {
+    if (cookie.name === "__Secure-1PSIDTS" && cookie.expires > 0) {
+      return cookie.expires * 1000;
+    }
+  }
+  return null;
+}
+
+function checkCookieFreshness(cookies: Cookie[]): boolean {
+  for (const cookie of cookies) {
+    if (cookie.name === "__Secure-1PSIDTS" && cookie.expires > 0) {
+      const threshold = Date.now() + COOKIE_EXPIRY_THRESHOLD_MS;
+      if (cookie.expires * 1000 < threshold) return false;
+    }
+  }
+  return true;
+}
+
+export class CookieStorage {
+  save(profileName: string, cookies: Cookie[]): void {
+    const filePath = getProfilePath(profileName);
+    const state: StorageState = { cookies };
+    writeTextFile(filePath, JSON.stringify(state, null, 2));
+  }
+
+  load(profileName: string): Cookie[] {
+    const filePath = getProfilePath(profileName);
+    if (!existsFile(filePath)) {
+      throw new Error(
+        `No storage state found for profile '${profileName}'. Run 'gemiterm auth' to authenticate.`,
+      );
+    }
+    const state = readJsonFile<StorageState>(filePath);
+    return state.cookies ?? [];
+  }
+
+  delete(profileName: string): void {
+    const dir = getProfileDir(profileName);
+    removeDir(dir);
+  }
+
+  list(): string[] {
+    return listProfiles();
+  }
+}
+
+export class ProfileManager {
+  private readonly cookieStorage: CookieStorage;
+
+  constructor(cookieStorage?: CookieStorage) {
+    this.cookieStorage = cookieStorage ?? new CookieStorage();
+  }
+
+  create(profileName: string): void {
+    const dir = getProfileDir(profileName);
+    if (existsFile(dir)) {
+      throw new Error(`Profile '${profileName}' already exists.`);
+    }
+    const isFirst = listProfiles().length === 0;
+    ensureDir(dir);
+    if (isFirst) {
+      setDefaultProfileName(profileName);
+    }
+  }
+
+  delete(name: string): void {
+    this.cookieStorage.delete(name);
+    if (getDefaultProfileName() === name) {
+      const remaining = listProfiles();
+      if (remaining.length > 0) {
+        setDefaultProfileName(remaining[0]);
+      } else {
+        const marker = getDefaultProfileMarkerPath();
+        if (existsFile(marker)) {
+          removeDir(marker);
+        }
+      }
+    }
+  }
+
+  rename(oldName: string, newName: string): void {
+    const oldDir = getProfileDir(oldName);
+    const newDir = getProfileDir(newName);
+    if (!existsFile(oldDir)) {
+      throw new Error(`Profile '${oldName}' does not exist.`);
+    }
+    if (existsFile(newDir)) {
+      throw new Error(`Profile '${newName}' already exists.`);
+    }
+    renameDir(oldDir, newDir);
+    if (getDefaultProfileName() === oldName) {
+      setDefaultProfileName(newName);
+    }
+  }
+
+  setDefault(name: string): void {
+    if (!existsFile(getProfileDir(name))) {
+      throw new Error(`Profile '${name}' does not exist.`);
+    }
+    setDefaultProfileName(name);
+  }
+
+  getDefault(): string {
+    return getDefaultProfileName();
+  }
+
+  list(): string[] {
+    return listProfiles();
+  }
+
+  getStatus(name: string): ProfileStatus {
+    const defaultName = getDefaultProfileName();
+    const filePath = getProfilePath(name);
+    if (!existsFile(filePath)) {
+      return {
+        name,
+        exists: false,
+        isActive: false,
+        expiresAt: null,
+        isDefault: name === defaultName,
+      };
+    }
+    try {
+      const cookies = this.cookieStorage.load(name);
+      const isActive = validateCookies(cookies) && checkCookieFreshness(cookies);
+      const expiresMs = getCookieExpiryTimestamp(cookies);
+      let expiresAt: string | null = null;
+      if (expiresMs !== null) {
+        expiresAt = new Date(expiresMs).toISOString();
+      }
+      return {
+        name,
+        exists: true,
+        isActive,
+        expiresAt,
+        isDefault: name === defaultName,
+      };
+    } catch {
+      return {
+        name,
+        exists: true,
+        isActive: false,
+        expiresAt: null,
+        isDefault: name === defaultName,
+      };
+    }
+  }
+
+  getAllStatuses(): ProfileStatus[] {
+    const defaultName = getDefaultProfileName();
+    const profiles = listProfiles();
+    return profiles.map((name) => {
+      const status = this.getStatus(name);
+      return { ...status, isDefault: name === defaultName };
+    });
+  }
+
+  hasValidCookies(profileName: string): boolean {
+    try {
+      const cookies = this.cookieStorage.load(profileName);
+      return validateCookies(cookies) && checkCookieFreshness(cookies);
+    } catch {
+      return false;
+    }
+  }
+
+  loadCookiesForApi(profileName: string): { secure1psid: string; secure1psidts: string | null } {
+    const cookies = this.cookieStorage.load(profileName);
+    if (!checkCookieFreshness(cookies)) {
+      throw new Error(
+        `Session for profile '${profileName}' appears expired. Run 'gemiterm auth' to re-authenticate.`,
+      );
+    }
+    const map = new Map(cookies.map((c) => [c.name, c.value]));
+    const secure1psid = map.get("__Secure-1PSID");
+    if (!secure1psid) {
+      throw new Error(`Missing required cookie __Secure-1PSID for profile '${profileName}'.`);
+    }
+    return {
+      secure1psid,
+      secure1psidts: map.get("__Secure-1PSIDTS") ?? null,
+    };
+  }
+}

package/src/infrastructure/validators.ts

@@ -0,0 +1,28 @@
+import { GemitermError } from "../core/errors.ts";
+
+const VALID_PROFILE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+
+export function validateConversationId(id: string): void {
+  if (!id || id.trim().length === 0) {
+    throw new GemitermError("Conversation ID must not be empty.");
+  }
+}
+
+export function parseIsoDate(dateStr: string, fieldName: string): number {
+  const parsed = Date.parse(dateStr);
+  if (Number.isNaN(parsed)) {
+    throw new GemitermError(`Invalid ISO date for '${fieldName}': '${dateStr}'.`);
+  }
+  return parsed;
+}
+
+export function validateProfileName(name: string): void {
+  if (!name || name.trim().length === 0) {
+    throw new GemitermError("Profile name must not be empty.");
+  }
+  if (!VALID_PROFILE_NAME_RE.test(name)) {
+    throw new GemitermError(
+      `Profile name '${name}' contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`,
+    );
+  }
+}

package/src/services/auth-service.ts

@@ -0,0 +1,135 @@
+import chalk from "chalk";
+import type { Cookie, AuthResult } from "../core/types.ts";
+import type { Logger } from "../infrastructure/logger.ts";
+import type { PlaywrightCliDriver } from "./playwright-cli-driver.ts";
+import type { CookieMonitor } from "./cookie-monitor.ts";
+import type { CookieStorage } from "../infrastructure/storage.ts";
+import { ensureConfigDir, getDefaultProfileName } from "../infrastructure/config.ts";
+import { validateProfileName } from "../infrastructure/validators.ts";
+
+const GEMINI_AUTH_URL = "https://gemini.google.com/app";
+const DEFAULT_AUTH_TIMEOUT_MS = 300_000;
+
+export interface AuthServiceDeps {
+  driver: PlaywrightCliDriver;
+  cookieMonitor: CookieMonitor;
+  cookieStorage: CookieStorage;
+  logger: Logger;
+}
+
+export class AuthServiceTimeoutError extends Error {
+  constructor(timeoutMs: number) {
+    super(`Authentication timed out after ${timeoutMs}ms. No auth cookies detected.`);
+    this.name = "AuthServiceTimeoutError";
+  }
+}
+
+export class AuthService {
+  private readonly driver: PlaywrightCliDriver;
+  private readonly cookieMonitor: CookieMonitor;
+  private readonly cookieStorage: CookieStorage;
+  private readonly logger: Logger;
+
+  constructor(deps: AuthServiceDeps) {
+    this.driver = deps.driver;
+    this.cookieMonitor = deps.cookieMonitor;
+    this.cookieStorage = deps.cookieStorage;
+    this.logger = deps.logger;
+  }
+
+  async authenticate(profileName?: string): Promise<AuthResult> {
+    const name = profileName ?? getDefaultProfileName();
+    validateProfileName(name);
+
+    this.logger.info(`Starting authentication for profile: ${name}`);
+
+    try {
+      this.notifyUser(name);
+      await this.launchBrowser(name);
+
+      const cookies = await this.waitForLogin(name, DEFAULT_AUTH_TIMEOUT_MS);
+      await this.extractCookies(name, cookies);
+      const expiresAt = this.getCookieExpiry(cookies);
+      this.confirmAuthSuccess(cookies.length, expiresAt, cookies);
+      return { cookies, expiresAt };
+    } finally {
+      await this.closeBrowser(name);
+    }
+  }
+
+  notifyUser(profileName: string): void {
+    console.log(
+      chalk.cyan(`\n🔍 Opening headed browser → ${GEMINI_AUTH_URL}  (profile: ${profileName})`),
+    );
+    console.log(
+      chalk.dim("   Log in manually — we'll auto-detect and close the browser when you're in.\n"),
+    );
+  }
+
+  async launchBrowser(profileName: string): Promise<void> {
+    this.logger.info(`Launching browser for profile: ${profileName}`);
+    await this.driver.openHeaded(GEMINI_AUTH_URL, profileName, profileName);
+  }
+
+  async waitForLogin(profileName: string, timeoutMs: number): Promise<Cookie[]> {
+    this.logger.info(`Waiting for auth cookies (timeout: ${timeoutMs}ms)...`);
+
+    return new Promise<Cookie[]>((resolve, reject) => {
+      let settled = false;
+
+      const settle = (fn: () => void) => {
+        if (settled) return;
+        settled = true;
+        fn();
+      };
+
+      const timeoutHandle = setTimeout(() => {
+        this.cookieMonitor.stop();
+        settle(() => reject(new AuthServiceTimeoutError(timeoutMs)));
+      }, timeoutMs);
+
+      this.cookieMonitor.start(
+        profileName,
+        (cookies) => {
+          clearTimeout(timeoutHandle);
+          settle(() => resolve(cookies));
+        },
+        timeoutMs,
+      );
+    });
+  }
+
+  async extractCookies(profileName: string, cookies: Cookie[]): Promise<void> {
+    ensureConfigDir();
+    this.logger.info(`Saving ${cookies.length} cookies for profile: ${profileName}`);
+    this.cookieStorage.save(profileName, cookies);
+  }
+
+  confirmAuthSuccess(cookieCount: number, expiresAt: Date | null, cookies: Cookie[] = []): void {
+    console.log(chalk.green(`\n✅ Login auto-detected — saving state…`));
+    console.log(chalk.green(`\nAuthentication successful! (${cookieCount} cookies captured)`));
+    if (expiresAt) {
+      console.log(chalk.dim(`Session expires: ${expiresAt.toLocaleString()}`));
+    }
+    const hasSid = cookies.some((c) => c.name === "__Secure-1PSID");
+    console.log(chalk.dim(`   Has __Secure-1PSID: ${hasSid ? "✅" : "❌"}`));
+  }
+
+  async closeBrowser(profileName: string): Promise<void> {
+    this.logger.info(`Closing browser for profile: ${profileName}`);
+    try {
+      await this.driver.closeSession(profileName);
+    } catch (err) {
+      this.logger.warn(`Failed to close browser: ${err}`);
+    }
+  }
+
+  private getCookieExpiry(cookies: Cookie[]): Date | null {
+    for (const cookie of cookies) {
+      if (cookie.name === "__Secure-1PSIDTS" && cookie.expires > 0) {
+        return new Date(cookie.expires * 1000);
+      }
+    }
+    return null;
+  }
+}

package/src/services/cookie-monitor.ts

@@ -0,0 +1,159 @@
+import type { Cookie } from "../core/types.ts";
+import type { Logger } from "../infrastructure/logger.ts";
+import type { PlaywrightCliDriver } from "./playwright-cli-driver.ts";
+
+const POLL_INTERVAL_MS = 2_000;
+const DEFAULT_TIMEOUT_MS = 300_000;
+
+const REQUIRED_COOKIES = new Set(["__Secure-1PSID", "__Secure-1PSIDTS"]);
+
+const LOGIN_PROBE_JS = `document.querySelector('a[href^="https://accounts.google.com/SignOutOptions"]') !== null`;
+
+type CookiesFoundCallback = (cookies: Cookie[]) => void;
+
+export class CookieMonitorTimeoutError extends Error {
+  constructor(timeoutMs: number) {
+    super(`Cookie monitor timed out after ${timeoutMs}ms`);
+    this.name = "CookieMonitorTimeoutError";
+  }
+}
+
+export class CookieMonitorNotStartedError extends Error {
+  constructor() {
+    super("Cookie monitor has not been started");
+    this.name = "CookieMonitorNotStartedError";
+  }
+}
+
+export interface CookieMonitorDeps {
+  driver: PlaywrightCliDriver;
+  logger: Logger;
+}
+
+export class CookieMonitor {
+  private pollingHandle: ReturnType<typeof setInterval> | null = null;
+  private timeoutHandle: ReturnType<typeof setTimeout> | null = null;
+  private _stopped = false;
+  private _started = false;
+  private readonly driver: PlaywrightCliDriver;
+  private readonly logger: Logger;
+
+  constructor(deps: CookieMonitorDeps) {
+    this.driver = deps.driver;
+    this.logger = deps.logger;
+  }
+
+  get isRunning(): boolean {
+    return this._started && !this._stopped;
+  }
+
+  async start(
+    session: string,
+    onCookiesFound: CookiesFoundCallback,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+  ): Promise<void> {
+    if (this._started) {
+      this.logger.warn("CookieMonitor already started, ignoring duplicate start call");
+      return;
+    }
+
+    this._started = true;
+    this._stopped = false;
+    this.logger.info(`Cookie monitor started for session '${session}' (timeout: ${timeoutMs}ms)`);
+
+    this.timeoutHandle = setTimeout(() => {
+      this.logger.warn("Cookie monitor hard timeout reached");
+      this.stop();
+    }, timeoutMs);
+    this.timeoutHandle.unref();
+
+    this.pollingHandle = setInterval(async () => {
+      if (this._stopped) return;
+      await this.poll(session, onCookiesFound);
+    }, POLL_INTERVAL_MS);
+  }
+
+  stop(): void {
+    if (this._stopped) return;
+    this._stopped = true;
+
+    if (this.pollingHandle !== null) {
+      clearInterval(this.pollingHandle);
+      this.pollingHandle = null;
+    }
+
+    if (this.timeoutHandle !== null) {
+      clearTimeout(this.timeoutHandle);
+      this.timeoutHandle = null;
+    }
+
+    this.logger.info("Cookie monitor stopped");
+  }
+
+  async checkLoggedIn(session: string): Promise<boolean> {
+    try {
+      const result = await this.driver.evalJs(session, LOGIN_PROBE_JS);
+      const loggedIn = result.trim() === "true";
+      if (loggedIn) {
+        this.logger.info("Login detected via sign-out link");
+      }
+      return loggedIn;
+    } catch (err) {
+      this.logger.debug(`checkLoggedIn eval failed: ${err}`);
+      return false;
+    }
+  }
+
+  async checkCookies(session: string): Promise<Cookie[]> {
+    try {
+      const cookies = await this.driver.cookieListFromState(session);
+      const authCookies = cookies.filter((c) => REQUIRED_COOKIES.has(c.name));
+
+      if (authCookies.length === REQUIRED_COOKIES.size) {
+        this.logger.info(`Found all required auth cookies: ${authCookies.map((c) => c.name).join(", ")}`);
+        return authCookies;
+      }
+
+      this.logger.debug(
+        `Auth cookies not yet complete (have: ${authCookies.map((c) => c.name).join(", ") ?? "none"})`,
+      );
+      return [];
+    } catch (err) {
+      this.logger.debug(`checkCookies failed: ${err}`);
+      return [];
+    }
+  }
+
+  private async poll(
+    session: string,
+    onCookiesFound: CookiesFoundCallback,
+  ): Promise<void> {
+    if (this._stopped) return;
+
+    let signal: string;
+    try {
+      signal = await this.driver.evalJs(session, LOGIN_PROBE_JS);
+    } catch {
+      return;
+    }
+
+    if (signal.trim() !== "true") {
+      return;
+    }
+
+    let cookies: Cookie[];
+    try {
+      cookies = await this.driver.cookieListFromState(session);
+    } catch {
+      return;
+    }
+
+    const authCookies = cookies.filter((c) => REQUIRED_COOKIES.has(c.name));
+    if (authCookies.length < REQUIRED_COOKIES.size) {
+      return;
+    }
+
+    this.stop();
+    onCookiesFound(authCookies);
+  }
+}