gemiterm 2.0.0

package/src/services/cookie-storage-service.ts

@@ -0,0 +1,74 @@
+import type { Cookie } from "../core/types.ts";
+import type { CookieStorage } from "../infrastructure/storage.ts";
+import type { Logger } from "../infrastructure/logger.ts";
+
+const COOKIE_EXPIRY_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1000;
+const REQUIRED_COOKIE_NAMES = new Set(["__Secure-1PSID", "__Secure-1PSIDTS"]);
+
+export interface LoadedCookies {
+  secure_1psid: string;
+  secure_1psidts: string | null;
+}
+
+export interface CookieStorageServiceDeps {
+  cookieStorage: CookieStorage;
+  logger: Logger;
+}
+
+export class CookieStorageService {
+  private readonly cookieStorage: CookieStorage;
+  private readonly logger: Logger;
+
+  constructor(deps: CookieStorageServiceDeps) {
+    this.cookieStorage = deps.cookieStorage;
+    this.logger = deps.logger;
+  }
+
+  loadCookiesForProfile(profileName: string): LoadedCookies {
+    const cookies = this.cookieStorage.load(profileName);
+    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}'. Run 'gemiterm auth' to re-authenticate.`,
+      );
+    }
+    return {
+      secure_1psid: secure1psid,
+      secure_1psidts: map.get("__Secure-1PSIDTS") ?? null,
+    };
+  }
+
+  validateCookies(cookies: Cookie[]): boolean {
+    const names = new Set(cookies.map((c) => c.name));
+    for (const required of REQUIRED_COOKIE_NAMES) {
+      if (!names.has(required)) return false;
+    }
+    return true;
+  }
+
+  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;
+  }
+
+  getCookieExpiry(cookies: Cookie[]): Date | null {
+    const expiresMs = this.getCookieExpiryMs(cookies);
+    if (expiresMs === null) return null;
+    return new Date(expiresMs);
+  }
+
+  private getCookieExpiryMs(cookies: Cookie[]): number | null {
+    for (const cookie of cookies) {
+      if (cookie.name === "__Secure-1PSIDTS" && cookie.expires > 0) {
+        return cookie.expires * 1000;
+      }
+    }
+    return null;
+  }
+}

package/src/services/gemini-client-wrapper.ts

@@ -0,0 +1,239 @@
+import {
+  type ChatInfo as RawChatInfo,
+  type ChatHistory,
+  type ChatSession,
+  type AvailableModel as RawAvailableModel,
+  type InitOptions,
+  type StartChatOptions,
+  type SendMessageOptions,
+  GeminiClient,
+  AuthError,
+  APIError,
+  TimeoutError,
+  UsageLimitExceeded,
+  ModelInvalid,
+  TemporarilyBlocked,
+  GeminiError,
+} from "gemini-reverse";
+import type { ChatInfo, Message } from "../core/types.ts";
+import type { IGeminiClientService } from "../core/command-handlers.ts";
+import type { IGeminiClientQueryService } from "../core/query-handlers.ts";
+import type { Logger } from "../infrastructure/logger.ts";
+import type { CookieStorageService } from "./cookie-storage-service.ts";
+import { GeminiAPIError, AuthenticationError } from "../core/errors.ts";
+
+interface GeminiClientConfig {
+  secure1psid: string;
+  secure1psidts?: string | null;
+}
+
+export class GeminiClientService
+  implements IGeminiClientService, IGeminiClientQueryService
+{
+  private client: GeminiClient | null = null;
+  private initPromise: Promise<void> | null = null;
+  private initialized = false;
+  readonly logger: Logger;
+  readonly cookieStorageService?: CookieStorageService;
+  readonly profileName?: string;
+
+  constructor(config: GeminiClientConfig, logger: Logger, cookieStorageService?: CookieStorageService, profileName?: string) {
+    this.logger = logger;
+    this.cookieStorageService = cookieStorageService;
+    this.profileName = profileName;
+    this.client = new GeminiClient({
+      secure_1psid: config.secure1psid,
+      secure_1psidts: config.secure1psidts ?? null,
+    });
+  }
+
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.client!.init({
+      timeout: 300_000,
+      autoClose: false,
+      autoRefresh: true,
+      refreshInterval: 540_000,
+    });
+    await this.initPromise;
+    this.initialized = true;
+  }
+
+  private toDomainChatInfo(raw: RawChatInfo, profileName?: string): ChatInfo {
+    return {
+      id: raw.cid,
+      title: raw.title,
+      isPinned: raw.is_pinned,
+      timestamp: raw.timestamp * 1000,
+      ...(profileName ? { profile: profileName } : {}),
+    };
+  }
+
+  private toDomainMessages(history: ChatHistory, conversationId: string): Message[] {
+    return history.turns.map((turn) => ({
+      role: turn.role,
+      content: turn.text,
+      conversationId,
+    }));
+  }
+
+  private toDomainModelName(model: RawAvailableModel): string {
+    return model.display_name || model.model_name || model.model_id;
+  }
+
+  private translateError(e: unknown): GeminiAPIError | AuthenticationError {
+    if (e instanceof AuthError) {
+      return new AuthenticationError(
+        "Session expired or invalid. Please run 'gemiterm login' again.",
+      );
+    }
+    if (e instanceof TimeoutError) {
+      return new GeminiAPIError("Request to Gemini timed out");
+    }
+    if (e instanceof UsageLimitExceeded) {
+      return new GeminiAPIError("Gemini usage limit reached; try again later or switch model");
+    }
+    if (e instanceof TemporarilyBlocked) {
+      return new GeminiAPIError("Temporarily blocked by Gemini; try a proxy or wait");
+    }
+    if (e instanceof ModelInvalid) {
+      return new GeminiAPIError("Model is invalid or unavailable");
+    }
+    if (e instanceof APIError) {
+      const err = new GeminiAPIError(e.message);
+      err.cause = e;
+      return err;
+    }
+    if (e instanceof GeminiError) {
+      const err = new GeminiAPIError(e.message);
+      err.cause = e;
+      return err;
+    }
+    return new GeminiAPIError("Unexpected error: " + String(e));
+  }
+
+  forProfile(profileName: string): GeminiClientService {
+    if (!this.cookieStorageService) {
+      throw new Error("CookieStorageService is required for forProfile");
+    }
+    const cookies = this.cookieStorageService.loadCookiesForProfile(profileName);
+    return new GeminiClientService(
+      { secure1psid: cookies.secure_1psid, secure1psidts: cookies.secure_1psidts },
+      this.logger,
+      this.cookieStorageService,
+      profileName,
+    );
+  }
+
+  async profileHasConversation(profileName: string, conversationId: string): Promise<boolean> {
+    try {
+      const profileClient = this.forProfile(profileName);
+      const chats = await profileClient.listChats();
+      return chats.some((chat) => chat.id === conversationId);
+    } catch {
+      return false;
+    }
+  }
+
+  async listChats(options?: {
+    limit?: number;
+    offset?: number;
+    search?: string;
+  }): Promise<ChatInfo[]> {
+    await this.init();
+    try {
+      const raw = this.client!.listChats();
+      let chats: ChatInfo[] = (raw ?? []).map((c) => this.toDomainChatInfo(c, this.profileName));
+
+      if (options?.search) {
+        const query = options.search.toLowerCase();
+        chats = chats.filter((c) => c.title.toLowerCase().includes(query));
+      }
+
+      chats.sort((a, b) => b.timestamp - a.timestamp);
+
+      if (options?.offset) {
+        chats = chats.slice(options.offset);
+      }
+      if (options?.limit) {
+        chats = chats.slice(0, options.limit);
+      }
+
+      return chats;
+    } catch (e) {
+      const err = this.translateError(e);
+      this.logger.debug(`listChats failed: ${e}`);
+      throw err;
+    }
+  }
+
+  async fetchChat(conversationId: string): Promise<Message[]> {
+    await this.init();
+    try {
+      const history = await this.client!.readChat(conversationId);
+      if (!history) return [];
+      return this.toDomainMessages(history, conversationId);
+    } catch (e) {
+      const err = this.translateError(e);
+      this.logger.debug(`fetchChat failed: ${e}`);
+      throw err;
+    }
+  }
+
+  async deleteChat(conversationId: string): Promise<void> {
+    await this.init();
+    try {
+      await this.client!.deleteChat(conversationId);
+    } catch (e) {
+      const err = this.translateError(e);
+      this.logger.debug(`deleteChat failed: ${e}`);
+      throw err;
+    }
+  }
+
+  async sendMessage(conversationId: string, message: string): Promise<string> {
+    await this.init();
+    try {
+      const session = this.client!.startChat({ cid: conversationId });
+      const output = await session.sendMessage({ prompt: message });
+      return output.text.toString();
+    } catch (e) {
+      const err = this.translateError(e);
+      this.logger.debug(`sendMessage failed: ${e}`);
+      throw err;
+    }
+  }
+
+  async startNewChat(message: string): Promise<{ response: string; conversationId: string }> {
+    await this.init();
+    try {
+      const session = this.client!.startChat();
+      const output = await session.sendMessage({ prompt: message });
+      return {
+        response: output.text.toString(),
+        conversationId: session.cid,
+      };
+    } catch (e) {
+      const err = this.translateError(e);
+      this.logger.debug(`startNewChat failed: ${e}`);
+      throw err;
+    }
+  }
+
+  async listModels(): Promise<string[]> {
+    await this.init();
+    try {
+      const raw = this.client!.listModels();
+      return (raw ?? []).map((m) => this.toDomainModelName(m));
+    } catch (e) {
+      const err = this.translateError(e);
+      this.logger.debug(`listModels failed: ${e}`);
+      throw err;
+    }
+  }
+
+  isAuthenticated(): boolean {
+    return this.initialized;
+  }
+}

package/src/services/install-browser-service.ts

@@ -0,0 +1,205 @@
+import { existsFile, safeReadTextFile } from "../infrastructure/io.ts";
+import { isWSL } from "../infrastructure/path-utils.ts";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { PlaywrightCliError } from "./playwright-cli-driver.ts";
+import { Logger } from "../infrastructure/logger.ts";
+
+const BROWSER_NAMES = ["chromium"];
+
+interface BrowserCheckResult {
+  found: boolean;
+  browserName: string;
+  path?: string;
+}
+
+export class InstallBrowserError extends Error {
+  constructor(message: string, public readonly cause?: Error) {
+    super(message);
+    this.name = "InstallBrowserError";
+  }
+}
+
+interface WindowsKnownDirs {
+  programFiles: string;
+  localAppData: string;
+}
+
+function getWindowsKnownDirs(): WindowsKnownDirs {
+  const programFiles = process.env["ProgramFiles(x86)"] ?? process.env["ProgramFiles"] ?? "C:\\Program Files";
+  const localAppData = process.env["LOCALAPPDATA"] ?? join(process.env["USERPROFILE"] ?? "C:\\Users", "AppData", "Local");
+  return { programFiles, localAppData };
+}
+
+export class InstallBrowserService {
+  private readonly logger: Logger;
+
+  constructor(logger?: Logger) {
+    this.logger = logger ?? new Logger("install-browser-service");
+  }
+
+  async install(): Promise<void> {
+    this.logger.info("Checking for existing browser installations...");
+
+    const existing = this.findSystemBrowser();
+    if (existing.found) {
+      this.logger.info(`Found existing browser: ${existing.browserName} at ${existing.path}`);
+      console.log(`Using existing ${existing.browserName} installation.`);
+      return;
+    }
+
+    console.log("No suitable browser found. Installing Chromium via Playwright...");
+    this.logger.info("Running: bunx @playwright/cli install chromium");
+
+    try {
+      const output = await this.runInstall();
+      this.logger.info(`Browser installation output: ${output}`);
+      console.log("Chromium installed successfully.");
+    } catch (error) {
+      if (error instanceof PlaywrightCliError) {
+        throw new InstallBrowserError(error.message, error);
+      }
+      throw new InstallBrowserError(
+        `Failed to install Chromium: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : undefined,
+      );
+    }
+  }
+
+  findSystemBrowser(): BrowserCheckResult {
+    if (process.platform === "win32") {
+      return this.findWindowsBrowser();
+    }
+    if (process.platform === "linux") {
+      return this.findLinuxBrowser();
+    }
+    return { found: false, browserName: "none" };
+  }
+
+  private findWindowsBrowser(): BrowserCheckResult {
+    const { programFiles, localAppData } = getWindowsKnownDirs();
+    const candidates = [
+      { name: "Microsoft Edge", paths: [
+        join(localAppData, "Microsoft", "Edge", "Application", "msedge.exe"),
+        join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"),
+      ]},
+      { name: "Google Chrome", paths: [
+        join(localAppData, "Google", "Chrome", "Application", "chrome.exe"),
+        join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+      ]},
+    ];
+
+    for (const candidate of candidates) {
+      for (const path of candidate.paths) {
+        if (existsFile(path)) {
+          return { found: true, browserName: candidate.name, path };
+        }
+      }
+    }
+
+    return { found: false, browserName: "none" };
+  }
+
+  private findLinuxBrowser(): BrowserCheckResult {
+    const candidates = [
+      { name: "Google Chrome", path: "/usr/bin/google-chrome" },
+      { name: "Google Chrome (Beta)", path: "/usr/bin/google-chrome-beta" },
+      { name: "Chromium", path: "/usr/bin/chromium" },
+      { name: "Chromium Browser", path: "/usr/bin/chromium-browser" },
+      { name: "Microsoft Edge", path: "/usr/bin/microsoft-edge" },
+    ];
+
+    for (const candidate of candidates) {
+      if (existsFile(candidate.path)) {
+        return { found: true, browserName: candidate.name, path: candidate.path };
+      }
+    }
+
+    if (isWSL()) {
+      return this.findWslBrowser();
+    }
+
+    return { found: false, browserName: "none" };
+  }
+
+  private findWslBrowser(): BrowserCheckResult {
+    const windowsRoot = this.getWslWindowsRoot();
+    if (!windowsRoot) {
+      return { found: false, browserName: "none" };
+    }
+
+    const edgePath = join(windowsRoot, "Program Files (x86)", "Microsoft", "Edge", "Application", "msedge.exe");
+    const chromePath = join(windowsRoot, "Program Files", "Google", "Chrome", "Application", "chrome.exe");
+
+    if (existsFile(edgePath)) {
+      return { found: true, browserName: "Microsoft Edge (Windows via WSL)", path: edgePath };
+    }
+    if (existsFile(chromePath)) {
+      return { found: true, browserName: "Google Chrome (Windows via WSL)", path: chromePath };
+    }
+
+    return { found: false, browserName: "none" };
+  }
+
+  private getWslWindowsRoot(): string | null {
+    const mountOutput = safeReadTextFile("/proc/mounts");
+    if (!mountOutput) {
+      return null;
+    }
+    const lines = mountOutput.split("\n");
+    for (const line of lines) {
+      if (line.includes("9p") && line.includes("drvfs")) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 2) {
+          const mountPoint = parts[1];
+          if (mountPoint.endsWith("/")) {
+            return mountPoint.slice(0, -1);
+          }
+          return mountPoint;
+        }
+      }
+    }
+    return null;
+  }
+
+  private async runInstall(): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      const proc = spawn("bunx", ["@playwright/cli", "install", ...BROWSER_NAMES], {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: process.platform === "win32",
+        env: { ...process.env },
+      });
+
+      const stdoutChunks: Buffer[] = [];
+      const stderrChunks: Buffer[] = [];
+
+      proc.stdout.on("data", (chunk: Buffer) => {
+        stdoutChunks.push(chunk);
+        const text = chunk.toString("utf-8");
+        this.logger.debug(text.trimEnd());
+      });
+
+      proc.stderr.on("data", (chunk: Buffer) => {
+        stderrChunks.push(chunk);
+        const text = chunk.toString("utf-8");
+        this.logger.debug(text.trimEnd());
+      });
+
+      proc.on("error", (err: Error) => {
+        reject(new InstallBrowserError(`Failed to spawn install process: ${err.message}`, err));
+      });
+
+      proc.on("close", (code) => {
+        const stdout = Buffer.concat(stdoutChunks).toString("utf-8").trim();
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+
+        if (code !== 0) {
+          reject(new PlaywrightCliError("install chromium", code ?? -1, stderr));
+          return;
+        }
+
+        resolve(stdout);
+      });
+    });
+  }
+}