gemiterm 2.0.0

package/src/core/query-handlers.ts

@@ -0,0 +1,163 @@
+import type { Query, QueryHandler } from "./mediator.ts";
+import type { ChatInfo, Message, ProfileStatus } from "./types.ts";
+import type { IGeminiClientService } from "./command-handlers.ts";
+
+function extractPayload<T>(query: Query<T>): T {
+  return query.payload;
+}
+
+export interface ListChatsQueryPayload {
+  limit?: number;
+  offset?: number;
+  search?: string;
+  allProfiles?: boolean;
+}
+
+export interface ListChatsQueryResult {
+  chats: ChatInfo[];
+}
+
+export interface FetchChatQueryPayload {
+  conversationId: string;
+}
+
+export interface FetchChatQueryResult {
+  messages: Message[];
+}
+
+export interface GetProfileStatusesQueryPayload {}
+
+export interface GetProfileStatusesQueryResult {
+  statuses: ProfileStatus[];
+}
+
+export interface GetAuthStatusQueryPayload {}
+
+export interface GetAuthStatusQueryResult {
+  authenticated: boolean;
+  profileName: string | null;
+}
+
+export interface ListModelsQueryPayload {}
+
+export interface ListModelsQueryResult {
+  models: string[];
+}
+
+export const QUERY_TYPES = {
+  LIST_CHATS: "list-chats",
+  FETCH_CHAT: "fetch-chat",
+  GET_PROFILE_STATUSES: "get-profile-statuses",
+  GET_AUTH_STATUS: "get-auth-status",
+  LIST_MODELS: "list-models",
+} as const;
+
+export type QueryType = (typeof QUERY_TYPES)[keyof typeof QUERY_TYPES];
+
+export interface IGeminiClientQueryService {
+  listChats(options?: { limit?: number; offset?: number; search?: string }): Promise<ChatInfo[]>;
+  fetchChat(conversationId: string): Promise<Message[]>;
+  listModels(): Promise<string[]>;
+}
+
+export interface IProfileQueryService {
+  getProfileStatuses(): Promise<ProfileStatus[]>;
+  getAuthStatus(): Promise<{ authenticated: boolean; profileName: string | null }>;
+}
+
+export class ListChatsQueryHandler
+  implements QueryHandler<ListChatsQueryPayload, ListChatsQueryResult>
+{
+  readonly queryType = QUERY_TYPES.LIST_CHATS;
+  private readonly getGeminiClient: () => IGeminiClientService;
+  private readonly listProfiles: () => string[];
+
+  constructor(getGeminiClient: () => IGeminiClientService, listProfiles: () => string[]) {
+    this.getGeminiClient = getGeminiClient;
+    this.listProfiles = listProfiles;
+  }
+
+  async handle(query: Query<ListChatsQueryPayload>): Promise<ListChatsQueryResult> {
+    const { limit, offset, search, allProfiles } = extractPayload(query);
+    const options = { limit, offset, search };
+    const client = this.getGeminiClient();
+
+    let chats: ChatInfo[];
+    if (allProfiles) {
+      const profileNames = this.listProfiles();
+      const results = await Promise.all(
+        profileNames.map((name) => client.forProfile(name).listChats(options)),
+      );
+      chats = results.flat();
+      chats.sort((a, b) => b.timestamp - a.timestamp);
+    } else {
+      chats = await client.listChats(options);
+    }
+    return { chats };
+  }
+}
+
+export class FetchChatQueryHandler
+  implements QueryHandler<FetchChatQueryPayload, FetchChatQueryResult>
+{
+  readonly queryType = QUERY_TYPES.FETCH_CHAT;
+  private readonly geminiClient: IGeminiClientQueryService;
+
+  constructor(geminiClient: IGeminiClientQueryService) {
+    this.geminiClient = geminiClient;
+  }
+
+  async handle(query: Query<FetchChatQueryPayload>): Promise<FetchChatQueryResult> {
+    const { conversationId } = extractPayload(query);
+    const messages = await this.geminiClient.fetchChat(conversationId);
+    return { messages };
+  }
+}
+
+export class GetProfileStatusesQueryHandler
+  implements QueryHandler<GetProfileStatusesQueryPayload, GetProfileStatusesQueryResult>
+{
+  readonly queryType = QUERY_TYPES.GET_PROFILE_STATUSES;
+  private readonly profileService: IProfileQueryService;
+
+  constructor(profileService: IProfileQueryService) {
+    this.profileService = profileService;
+  }
+
+  async handle(_query: Query<GetProfileStatusesQueryPayload>): Promise<GetProfileStatusesQueryResult> {
+    const statuses = await this.profileService.getProfileStatuses();
+    return { statuses };
+  }
+}
+
+export class GetAuthStatusQueryHandler
+  implements QueryHandler<GetAuthStatusQueryPayload, GetAuthStatusQueryResult>
+{
+  readonly queryType = QUERY_TYPES.GET_AUTH_STATUS;
+  private readonly profileService: IProfileQueryService;
+
+  constructor(profileService: IProfileQueryService) {
+    this.profileService = profileService;
+  }
+
+  async handle(_query: Query<GetAuthStatusQueryPayload>): Promise<GetAuthStatusQueryResult> {
+    const status = await this.profileService.getAuthStatus();
+    return { authenticated: status.authenticated, profileName: status.profileName };
+  }
+}
+
+export class ListModelsQueryHandler
+  implements QueryHandler<ListModelsQueryPayload, ListModelsQueryResult>
+{
+  readonly queryType = QUERY_TYPES.LIST_MODELS;
+  private readonly geminiClient: IGeminiClientQueryService;
+
+  constructor(geminiClient: IGeminiClientQueryService) {
+    this.geminiClient = geminiClient;
+  }
+
+  async handle(_query: Query<ListModelsQueryPayload>): Promise<ListModelsQueryResult> {
+    const models = await this.geminiClient.listModels();
+    return { models };
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,43 @@
+export interface ProfileStatus {
+  name: string;
+  exists: boolean;
+  isActive: boolean;
+  expiresAt: string | null;
+  isDefault: boolean;
+}
+
+export interface ChatInfo {
+  id: string;
+  title: string;
+  isPinned: boolean;
+  timestamp: number;
+  profile?: string;
+}
+
+export interface Message {
+  role: "user" | "model";
+  content: string;
+  conversationId?: string;
+}
+
+export interface Conversation {
+  id: string;
+  title: string;
+  messages: Message[];
+}
+
+export interface AuthResult {
+  cookies: Cookie[];
+  expiresAt: Date | null;
+}
+
+export interface Cookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  expires: number;
+  httpOnly: boolean;
+  secure: boolean;
+  sameSite: "Strict" | "Lax" | "None";
+}

package/src/infrastructure/cli-table.ts

@@ -0,0 +1,45 @@
+import Table from "cli-table3";
+import chalk from "chalk";
+
+export interface ColumnDef<T> {
+  header: string;
+  width: number;
+  cell: (row: T) => string;
+  align?: "left" | "center" | "right";
+}
+
+export interface RenderTableOptions<T> {
+  columns: ColumnDef<T>[];
+  rows: T[];
+  emptyMessage?: string;
+  footer?: string;
+}
+
+export function renderTable<T>(opts: RenderTableOptions<T>): string {
+  if (opts.rows.length === 0 && opts.emptyMessage) {
+    return chalk.dim(opts.emptyMessage);
+  }
+
+  const head = opts.columns.map((c) => c.header);
+  const colWidths = opts.columns.map((c) => c.width);
+  const colAligns = opts.columns.map((c) => c.align ?? "left");
+
+  const table = new Table({
+    head,
+    colWidths,
+    colAligns,
+    wordWrap: false,
+  });
+
+  for (const row of opts.rows) {
+    const cells = opts.columns.map((c) => c.cell(row));
+    table.push(cells);
+  }
+
+  const lines = [table.toString()];
+  if (opts.footer) {
+    lines.push("");
+    lines.push(chalk.dim(opts.footer));
+  }
+  return lines.join("\n");
+}

package/src/infrastructure/config.ts

@@ -0,0 +1,52 @@
+import {
+  ensureDir,
+  existsFile,
+  isDirectory,
+  listSubdirectories,
+  readTextFile,
+  writeTextFile,
+} from "./io.ts";
+import {
+  getConfigDir,
+  getDefaultProfileMarkerPath,
+  getProfilesDir,
+  dirnamePath,
+  DEFAULT_PROFILE_MARKER,
+} from "./path-utils.ts";
+
+function getDefaultProfileName(): string {
+  const marker = getDefaultProfileMarkerPath();
+  if (existsFile(marker)) {
+    return readTextFile(marker).trim() || "default";
+  }
+  return "default";
+}
+
+function setDefaultProfileName(name: string): void {
+  const marker = getDefaultProfileMarkerPath();
+  ensureDir(dirnamePath(marker));
+  writeTextFile(marker, name);
+}
+
+function listProfiles(): string[] {
+  const profilesPath = getProfilesDir();
+  if (!isDirectory(profilesPath)) return [];
+  return listSubdirectories(profilesPath)
+    .filter((entry) => entry !== DEFAULT_PROFILE_MARKER)
+    .sort();
+}
+
+function ensureConfigDir(): string {
+  const configDir = getConfigDir();
+  ensureDir(configDir);
+  ensureDir(getProfilesDir());
+  return configDir;
+}
+
+export {
+  getConfigDir,
+  getDefaultProfileName,
+  setDefaultProfileName,
+  listProfiles,
+  ensureConfigDir,
+};

package/src/infrastructure/formatters.ts

@@ -0,0 +1,130 @@
+import chalk from "chalk";
+import type { Message, ChatInfo, ProfileStatus } from "../core/types.ts";
+import { renderTable, type ColumnDef } from "./cli-table.ts";
+
+function formatDate(date: Date | string | null): string {
+  if (!date) return "N/A";
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+function formatTimestamp(ts: number): string {
+  return new Date(ts).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+export function formatChatAsMarkdown(
+  messages: Message[],
+  title: string,
+  conversationId?: string,
+  includeMetadata?: boolean,
+): string {
+  const lines: string[] = [];
+
+  lines.push(`# ${title}`);
+  lines.push("");
+
+  if (includeMetadata && conversationId) {
+    lines.push(`> Conversation ID: ${conversationId}`);
+    lines.push(`> Messages: ${messages.length}`);
+    lines.push(`> Exported: ${new Date().toISOString()}`);
+    lines.push("");
+  }
+
+  for (const msg of messages) {
+    const label = msg.role === "user" ? "**You:**" : "**Gemini:**";
+    lines.push(`${label}`);
+    lines.push("");
+    lines.push(msg.content);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export function formatChatAsJson(messages: Message[], conversationId: string): string {
+  return JSON.stringify({ conversationId, messages }, null, 2);
+}
+
+export function formatProfileTable(statuses: ProfileStatus[]): string {
+  const columns: ColumnDef<ProfileStatus>[] = [
+    {
+      header: "NAME",
+      width: 18,
+      cell: (s) => (s.isDefault ? chalk.green(s.name) + chalk.dim(" *") : s.name),
+    },
+    {
+      header: "ACTIVE",
+      width: 10,
+      cell: (s) =>
+        s.isActive
+          ? chalk.green("\u2713 Yes")
+          : s.exists
+            ? chalk.red("\u2717 No")
+            : chalk.dim("\u2014"),
+    },
+    {
+      header: "EXPIRES",
+      width: 22,
+      cell: (s) => {
+        if (s.expiresAt) return formatTimestamp(new Date(s.expiresAt).getTime());
+        if (s.isActive) return chalk.dim("Session");
+        return chalk.dim("N/A");
+      },
+    },
+    {
+      header: "DEFAULT",
+      width: 10,
+      cell: (s) => (s.isDefault ? chalk.green("Yes") : ""),
+    },
+  ];
+
+  return renderTable<ProfileStatus>({
+    columns,
+    rows: statuses,
+    emptyMessage: "No profiles found. Run 'gemiterm login' to create one.",
+    footer: "* = default profile",
+  });
+}
+
+export function formatChatList(chats: ChatInfo[], options?: { includeProfileColumn?: boolean }): string {
+  const includeProfile = options?.includeProfileColumn === true;
+
+  const columns: ColumnDef<ChatInfo>[] = [
+    { header: "ID", width: 24, cell: (c) => chalk.dim(c.id) },
+    { header: "TITLE", width: 40, cell: (c) => c.title },
+    { header: "DATE", width: 22, cell: (c) => formatTimestamp(c.timestamp) },
+    {
+      header: "PIN",
+      width: 6,
+      cell: (c) => (c.isPinned ? chalk.yellow("\uD83D\uDCCC") : ""),
+    },
+  ];
+  if (includeProfile) {
+    columns.push({
+      header: "PROFILE",
+      width: 14,
+      cell: (c) => c.profile ?? "",
+    });
+  }
+
+  return renderTable<ChatInfo>({
+    columns,
+    rows: chats,
+    emptyMessage: "No conversations found.",
+    footer: `Total: ${chats.length} conversation${chats.length !== 1 ? "s" : ""}`,
+  });
+}

package/src/infrastructure/io.ts

@@ -0,0 +1,161 @@
+/**
+ * Canonical home for file-system access in `src/`.
+ *
+ * No other source file in `src/` may import from `node:fs` or `node:path`
+ * directly. The only allowed exception is `src/services/install-browser-service.ts`,
+ * which keeps a `node:path` import for the WSL `9p`/`drvfs` mount parser.
+ *
+ * This module is intentionally small: every function is a thin wrapper around
+ * the corresponding `node:fs` call with consistent semantics (always-recursive
+ * `mkdir`, safe returns, structured errors). New functions should be added
+ * only when at least 2 call sites need them; ad-hoc single-use helpers should
+ * stay in the call site.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+export class IOError extends Error {
+  override readonly name = "IOError";
+  constructor(message: string, public readonly cause?: Error) {
+    super(message);
+  }
+}
+
+function wrap(op: string, path: string, cause?: Error): IOError {
+  return new IOError(`${op} failed for ${path}`, cause);
+}
+
+function ensureDir(path: string): void {
+  try {
+    mkdirSync(path, { recursive: true });
+  } catch (err) {
+    throw wrap("ensureDir", path, err instanceof Error ? err : undefined);
+  }
+}
+
+function existsFile(path: string): boolean {
+  return existsSync(path);
+}
+
+function readTextFile(path: string): string {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch (err) {
+    throw wrap("readTextFile", path, err instanceof Error ? err : undefined);
+  }
+}
+
+/**
+ * Reads the file at `path` and returns its UTF-8 content. On any error
+ * (ENOENT, EACCES, EISDIR), returns the empty string `""` instead of
+ * throwing.
+ *
+ * Note: the `""` return conflates "file does not exist" with "file exists
+ * but is empty". This is appropriate for callers that only need a string
+ * for `.includes()` / `.trim()` checks (for example, the WSL `/proc/version`
+ * probe in `install-browser-service.ts`). Callers that need to distinguish
+ * the two cases should use `readTextFile` and handle the `IOError`.
+ */
+function safeReadTextFile(path: string): string {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+function writeTextFile(path: string, content: string): void {
+  const absolute = resolve(path);
+  const parent = dirname(absolute);
+  ensureDir(parent);
+  try {
+    writeFileSync(absolute, content, "utf-8");
+  } catch (err) {
+    throw wrap("writeTextFile", absolute, err instanceof Error ? err : undefined);
+  }
+}
+
+function readJsonFile<T = unknown>(path: string): T {
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch (err) {
+    throw wrap("readJsonFile", path, err instanceof Error ? err : undefined);
+  }
+  try {
+    return JSON.parse(raw) as T;
+  } catch (err) {
+    throw new IOError(
+      `readJsonFile: invalid JSON in ${path}: ${err instanceof Error ? err.message : String(err)}`,
+      err instanceof Error ? err : undefined,
+    );
+  }
+}
+
+function writeJsonFile(path: string, data: unknown): void {
+  writeTextFile(path, JSON.stringify(data, null, 2));
+}
+
+function removeDir(path: string): void {
+  try {
+    rmSync(path, { recursive: true, force: true });
+  } catch (err) {
+    throw wrap("removeDir", path, err instanceof Error ? err : undefined);
+  }
+}
+
+function renameDir(src: string, dest: string): void {
+  try {
+    renameSync(src, dest);
+  } catch (err) {
+    throw new IOError(
+      `renameDir: ${src} -> ${dest}: ${err instanceof Error ? err.message : String(err)}`,
+      err instanceof Error ? err : undefined,
+    );
+  }
+}
+
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function listSubdirectories(path: string): string[] {
+  if (!existsSync(path)) {
+    return [];
+  }
+  return readdirSync(path).filter((entry) => {
+    try {
+      return statSync(join(path, entry)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
+export {
+  ensureDir,
+  existsFile,
+  readTextFile,
+  safeReadTextFile,
+  writeTextFile,
+  readJsonFile,
+  writeJsonFile,
+  removeDir,
+  renameDir,
+  isDirectory,
+  listSubdirectories,
+};

package/src/infrastructure/logger.ts

@@ -0,0 +1,41 @@
+type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
+
+class Logger {
+  private static verbose = false;
+
+  static setVerbose(enabled: boolean): void {
+    Logger.verbose = enabled;
+  }
+
+  static isVerbose(): boolean {
+    return Logger.verbose;
+  }
+
+  constructor(private readonly module: string) {}
+
+  debug(message: string, ...args: unknown[]): void {
+    if (Logger.verbose) {
+      Logger.output("DEBUG", this.module, message, args);
+    }
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    Logger.output("INFO", this.module, message, args);
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    Logger.output("WARN", this.module, message, args);
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    Logger.output("ERROR", this.module, message, args);
+  }
+
+  private static output(level: LogLevel, module: string, message: string, args: unknown[]): void {
+    const timestamp = new Date().toISOString();
+    const formatted = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    process.stderr.write(`[${timestamp}] [${level}] [${module}] ${formatted}\n`);
+  }
+}
+
+export { Logger };