gemiterm 2.0.0

package/src/cli/index.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env bun
+
+import { CommandRegistry } from "./command-registry.ts";
+import { Logger } from "../infrastructure/logger.ts";
+import { Mediator } from "../core/mediator.ts";
+import { showHelp } from "./commands/help.ts";
+import { GeminiClientService } from "../services/gemini-client-wrapper.ts";
+import { CookieStorageService } from "../services/cookie-storage-service.ts";
+import { ProfileAuthManager } from "../services/profile-auth-manager.ts";
+import { CookieStorage, ProfileManager } from "../infrastructure/storage.ts";
+import { getDefaultProfileName, listProfiles, ensureConfigDir } from "../infrastructure/config.ts";
+import { getPackageJson } from "../infrastructure/path-utils.ts";
+import { AuthenticationError } from "../core/errors.ts";
+import {
+  AuthenticateCommandHandler,
+  DeleteProfileCommandHandler,
+  RenameProfileCommandHandler,
+  SetDefaultProfileCommandHandler,
+  DeleteConversationCommandHandler,
+  SendMessageCommandHandler,
+  StartNewChatCommandHandler,
+} from "../core/command-handlers.ts";
+import {
+  ListChatsQueryHandler,
+  FetchChatQueryHandler,
+  GetProfileStatusesQueryHandler,
+  GetAuthStatusQueryHandler,
+  ListModelsQueryHandler,
+} from "../core/query-handlers.ts";
+
+const pkg = getPackageJson(import.meta.url);
+
+interface GlobalFlags {
+  verbose: boolean;
+  version: boolean;
+  help: boolean;
+}
+
+function parseGlobalFlags(args: string[]): { flags: GlobalFlags; remaining: string[] } {
+  const flags: GlobalFlags = {
+    verbose: process.env.GEMITERM_VERBOSE === "true",
+    version: false,
+    help: false,
+  };
+  const remaining: string[] = [];
+
+  for (const arg of args) {
+    if (arg === "--verbose" || arg === "-v") {
+      flags.verbose = true;
+    } else if (arg === "--version") {
+      flags.version = true;
+    } else if (arg === "--help" || arg === "-h") {
+      if (remaining.length === 0) {
+        flags.help = true;
+      } else {
+        remaining.push(arg);
+      }
+    } else {
+      remaining.push(arg);
+    }
+  }
+
+  return { flags, remaining };
+}
+
+async function setupMediator(mediator: Mediator): Promise<ProfileAuthManager> {
+  const logger = new Logger("mediator");
+  const cookieStorage = new CookieStorage();
+  const profileManager = new ProfileManager(cookieStorage);
+
+  const profileQueryService = {
+    async getProfileStatuses() {
+      return profileManager.getAllStatuses();
+    },
+    async getAuthStatus() {
+      const profiles = listProfiles();
+      if (profiles.length === 0) {
+        return { authenticated: false, profileName: null };
+      }
+      const defaultName = getDefaultProfileName();
+      const isValid = profileManager.hasValidCookies(defaultName);
+      return { authenticated: isValid, profileName: defaultName };
+    },
+  };
+
+  const cookieStorageService = new CookieStorageService({ cookieStorage, logger });
+  let geminiClient: GeminiClientService | null = null;
+
+  function getGeminiClient(): GeminiClientService {
+    if (geminiClient) return geminiClient;
+    const profiles = listProfiles();
+    if (profiles.length === 0) {
+      throw new AuthenticationError();
+    }
+    const profileName = getDefaultProfileName();
+    try {
+      const cookieData = profileManager.loadCookiesForApi(profileName);
+      geminiClient = new GeminiClientService(
+        { secure1psid: cookieData.secure1psid, secure1psidts: cookieData.secure1psidts },
+        logger,
+        cookieStorageService,
+        profileName,
+      );
+      return geminiClient;
+    } catch {
+      throw new AuthenticationError();
+    }
+  }
+
+  const factoryClient = new GeminiClientService({ secure1psid: "" }, logger, cookieStorageService);
+  try { await factoryClient.init(); } catch { /* factory: init deferred until first real profile call */ }
+  const profileAuthManager = new ProfileAuthManager({ profileManager, cookieStorageService, logger, geminiClient: factoryClient });
+
+  mediator.registerQueryHandler(new GetAuthStatusQueryHandler(profileQueryService));
+  mediator.registerQueryHandler(new GetProfileStatusesQueryHandler(profileQueryService));
+  mediator.registerQueryHandler(new ListChatsQueryHandler(getGeminiClient, listProfiles));
+  mediator.registerQueryHandler(new FetchChatQueryHandler({
+    async listChats(options) { return getGeminiClient().listChats(options); },
+    async fetchChat(id) { return getGeminiClient().fetchChat(id); },
+    async listModels() { return getGeminiClient().listModels(); },
+  }));
+  mediator.registerQueryHandler(new ListModelsQueryHandler({
+    async listChats(options) { return getGeminiClient().listChats(options); },
+    async fetchChat(id) { return getGeminiClient().fetchChat(id); },
+    async listModels() { return getGeminiClient().listModels(); },
+  }));
+  mediator.registerCommandHandler(new AuthenticateCommandHandler(null as any));
+  mediator.registerCommandHandler(new DeleteProfileCommandHandler(null as any));
+  mediator.registerCommandHandler(new RenameProfileCommandHandler(null as any));
+  mediator.registerCommandHandler(new SetDefaultProfileCommandHandler(null as any));
+  mediator.registerCommandHandler(new DeleteConversationCommandHandler({
+    async deleteChat(id) { return getGeminiClient().deleteChat(id); },
+    async sendMessage(id, msg) { return getGeminiClient().sendMessage(id, msg); },
+    async startNewChat(msg) { return getGeminiClient().startNewChat(msg); },
+    async profileHasConversation(name, id) { return getGeminiClient().profileHasConversation(name, id); },
+    forProfile(name) { return getGeminiClient().forProfile(name); },
+    async listChats(options) { return getGeminiClient().listChats(options); },
+  }));
+  mediator.registerCommandHandler(new SendMessageCommandHandler({
+    async deleteChat(id) { return getGeminiClient().deleteChat(id); },
+    async sendMessage(id, msg) { return getGeminiClient().sendMessage(id, msg); },
+    async startNewChat(msg) { return getGeminiClient().startNewChat(msg); },
+    async profileHasConversation(name, id) { return getGeminiClient().profileHasConversation(name, id); },
+    forProfile(name) { return getGeminiClient().forProfile(name); },
+    async listChats(options) { return getGeminiClient().listChats(options); },
+  }));
+  mediator.registerCommandHandler(new StartNewChatCommandHandler({
+    async deleteChat(id) { return getGeminiClient().deleteChat(id); },
+    async sendMessage(id, msg) { return getGeminiClient().sendMessage(id, msg); },
+    async startNewChat(msg) { return getGeminiClient().startNewChat(msg); },
+    async profileHasConversation(name, id) { return getGeminiClient().profileHasConversation(name, id); },
+    forProfile(name) { return getGeminiClient().forProfile(name); },
+    async listChats(options) { return getGeminiClient().listChats(options); },
+  }));
+
+  return profileAuthManager;
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const logger = new Logger("cli");
+  const { flags, remaining } = parseGlobalFlags(args);
+
+  if (flags.verbose) {
+    Logger.setVerbose(true);
+  }
+
+  if (flags.version) {
+    console.log(`gemiterm v${pkg.version}`);
+    process.exit(0);
+  }
+
+  const registry = new CommandRegistry();
+  registry.registerAllCommands();
+
+  if (remaining.length === 0) {
+    showHelp(registry);
+    process.exit(0);
+  }
+
+  const mediator = new Mediator();
+  const profileAuthManager = await setupMediator(mediator);
+
+  const subcommand = remaining[0];
+  const subcommandArgs = remaining.slice(1);
+
+  const handler = registry.getHandler(subcommand);
+  if (!handler) {
+    const known = registry.getRegisteredNames();
+    if (known.length > 0) {
+      console.error(`Unknown command: '${subcommand}'`);
+      console.error(`Did you mean one of: ${known.join(", ")}?`);
+    } else {
+      console.error(`Unknown command: '${subcommand}'`);
+      console.error("Run 'gemiterm --help' for available commands.");
+    }
+    process.exit(1);
+  }
+
+  try {
+    await handler.execute(subcommandArgs, { verbose: flags.verbose, mediator, profileAuthManager });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Command '${subcommand}' failed: ${message}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(`Fatal error: ${error}`);
+  process.exit(1);
+});

package/src/cli/utils/interactive-prompt.ts

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import { createInterface } from "node:readline";
+
+export interface MessageHandlerResult {
+  response: string;
+}
+
+export type MessageHandler = (message: string) => Promise<MessageHandlerResult>;
+
+export interface InteractiveLoopOptions {
+  profileName?: string | null;
+}
+
+export async function runInteractiveLoop(
+  messageHandler: MessageHandler,
+  options: InteractiveLoopOptions = {},
+): Promise<void> {
+  const profileLabel = options.profileName ?? "default";
+  console.log(chalk.dim(`Starting chat session (profile: ${chalk.cyan(profileLabel)})`));
+  console.log(chalk.dim("Type your message and press Enter. Type /exit to quit.\n"));
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const prompt = (): void => {
+    rl.question(chalk.green.bold("You: "), async (input) => {
+      const trimmed = input.trim();
+
+      if (trimmed === "/exit" || trimmed === "/quit") {
+        rl.close();
+        return;
+      }
+
+      if (!trimmed) {
+        prompt();
+        return;
+      }
+
+      try {
+        const result = await messageHandler(trimmed);
+        console.log(chalk.blue.bold("Model:"));
+        console.log(result.response);
+        console.log("");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        console.log("");
+      }
+
+      prompt();
+    });
+  };
+
+  prompt();
+
+  await new Promise<void>((resolve) => {
+    rl.on("close", () => {
+      console.log(chalk.dim("\nGoodbye."));
+      resolve();
+    });
+  });
+}

package/src/core/command-handlers.ts

@@ -0,0 +1,240 @@
+import type { Command, CommandHandler } from "./mediator.ts";
+import type { AuthResult, ChatInfo } from "./types.ts";
+import { AuthenticationError } from "./errors.ts";
+
+function extractPayload<T>(command: Command<T>): T {
+  return command.payload;
+}
+
+export interface AuthenticateCommandPayload {
+  profileName?: string;
+}
+
+export interface AuthenticateCommandResult {
+  success: boolean;
+  cookieCount: number;
+  expiresAt: string | null;
+}
+
+export interface DeleteProfileCommandPayload {
+  profileName: string;
+}
+
+export interface DeleteProfileCommandResult {
+  success: boolean;
+}
+
+export interface RenameProfileCommandPayload {
+  oldName: string;
+  newName: string;
+}
+
+export interface RenameProfileCommandResult {
+  success: boolean;
+}
+
+export interface SetDefaultProfileCommandPayload {
+  profileName: string;
+}
+
+export interface SetDefaultProfileCommandResult {
+  success: boolean;
+}
+
+export interface DeleteConversationCommandPayload {
+  conversationId: string;
+  profileName?: string;
+}
+
+export interface DeleteConversationCommandResult {
+  success: boolean;
+}
+
+export interface SendMessageCommandPayload {
+  conversationId: string;
+  message: string;
+  profileName?: string;
+}
+
+export interface SendMessageCommandResult {
+  response: string;
+}
+
+export interface StartNewChatCommandPayload {
+  message: string;
+  profileName?: string;
+}
+
+export interface StartNewChatCommandResult {
+  response: string;
+  conversationId: string;
+}
+
+export const COMMAND_TYPES = {
+  AUTHENTICATE: "authenticate",
+  DELETE_PROFILE: "delete-profile",
+  RENAME_PROFILE: "rename-profile",
+  SET_DEFAULT_PROFILE: "set-default-profile",
+  DELETE_CONVERSATION: "delete-conversation",
+  SEND_MESSAGE: "send-message",
+  START_NEW_CHAT: "start-new-chat",
+} as const;
+
+export type CommandType = (typeof COMMAND_TYPES)[keyof typeof COMMAND_TYPES];
+
+export interface IProfileService {
+  authenticate(profileName?: string): Promise<AuthResult>;
+  deleteProfile(name: string): Promise<void>;
+  renameProfile(oldName: string, newName: string): Promise<void>;
+  setDefaultProfile(name: string): Promise<void>;
+}
+
+export interface IGeminiClientService {
+  deleteChat(conversationId: string): Promise<void>;
+  sendMessage(conversationId: string, message: string): Promise<string>;
+  startNewChat(message: string): Promise<{ response: string; conversationId: string }>;
+  profileHasConversation(profileName: string, conversationId: string): Promise<boolean>;
+  forProfile(profileName: string): IGeminiClientService;
+  listChats(options?: { limit?: number; offset?: number; search?: string }): Promise<ChatInfo[]>;
+}
+
+export class AuthenticateCommandHandler
+  implements CommandHandler<AuthenticateCommandPayload, AuthenticateCommandResult>
+{
+  readonly commandType = COMMAND_TYPES.AUTHENTICATE;
+  private readonly profileService: IProfileService;
+
+  constructor(profileService: IProfileService) {
+    this.profileService = profileService;
+  }
+
+  async handle(command: Command<AuthenticateCommandPayload>): Promise<AuthenticateCommandResult> {
+    const { profileName } = extractPayload(command);
+    try {
+      const result = await this.profileService.authenticate(profileName);
+      return {
+        success: true,
+        cookieCount: result.cookies.length,
+        expiresAt: result.expiresAt?.toISOString() ?? null,
+      };
+    } catch (error) {
+      if (error instanceof AuthenticationError) {
+        return { success: false, cookieCount: 0, expiresAt: null };
+      }
+      throw error;
+    }
+  }
+}
+
+export class DeleteProfileCommandHandler
+  implements CommandHandler<DeleteProfileCommandPayload, DeleteProfileCommandResult>
+{
+  readonly commandType = COMMAND_TYPES.DELETE_PROFILE;
+  private readonly profileService: IProfileService;
+
+  constructor(profileService: IProfileService) {
+    this.profileService = profileService;
+  }
+
+  async handle(command: Command<DeleteProfileCommandPayload>): Promise<DeleteProfileCommandResult> {
+    const { profileName } = extractPayload(command);
+    await this.profileService.deleteProfile(profileName);
+    return { success: true };
+  }
+}
+
+export class RenameProfileCommandHandler
+  implements CommandHandler<RenameProfileCommandPayload, RenameProfileCommandResult>
+{
+  readonly commandType = COMMAND_TYPES.RENAME_PROFILE;
+  private readonly profileService: IProfileService;
+
+  constructor(profileService: IProfileService) {
+    this.profileService = profileService;
+  }
+
+  async handle(command: Command<RenameProfileCommandPayload>): Promise<RenameProfileCommandResult> {
+    const { oldName, newName } = extractPayload(command);
+    await this.profileService.renameProfile(oldName, newName);
+    return { success: true };
+  }
+}
+
+export class SetDefaultProfileCommandHandler
+  implements
+    CommandHandler<SetDefaultProfileCommandPayload, SetDefaultProfileCommandResult>
+{
+  readonly commandType = COMMAND_TYPES.SET_DEFAULT_PROFILE;
+  private readonly profileService: IProfileService;
+
+  constructor(profileService: IProfileService) {
+    this.profileService = profileService;
+  }
+
+  async handle(
+    command: Command<SetDefaultProfileCommandPayload>,
+  ): Promise<SetDefaultProfileCommandResult> {
+    const { profileName } = extractPayload(command);
+    await this.profileService.setDefaultProfile(profileName);
+    return { success: true };
+  }
+}
+
+export class DeleteConversationCommandHandler
+  implements
+    CommandHandler<DeleteConversationCommandPayload, DeleteConversationCommandResult>
+{
+  readonly commandType = COMMAND_TYPES.DELETE_CONVERSATION;
+  private readonly geminiClient: IGeminiClientService;
+
+  constructor(geminiClient: IGeminiClientService) {
+    this.geminiClient = geminiClient;
+  }
+
+  async handle(
+    command: Command<DeleteConversationCommandPayload>,
+  ): Promise<DeleteConversationCommandResult> {
+    const { conversationId, profileName } = extractPayload(command);
+    const client = profileName ? this.geminiClient.forProfile(profileName) : this.geminiClient;
+    await client.deleteChat(conversationId);
+    return { success: true };
+  }
+}
+
+export class SendMessageCommandHandler
+  implements CommandHandler<SendMessageCommandPayload, SendMessageCommandResult>
+{
+  readonly commandType = COMMAND_TYPES.SEND_MESSAGE;
+  private readonly geminiClient: IGeminiClientService;
+
+  constructor(geminiClient: IGeminiClientService) {
+    this.geminiClient = geminiClient;
+  }
+
+  async handle(command: Command<SendMessageCommandPayload>): Promise<SendMessageCommandResult> {
+    const { conversationId, message, profileName } = extractPayload(command);
+    const client = profileName ? this.geminiClient.forProfile(profileName) : this.geminiClient;
+    const response = await client.sendMessage(conversationId, message);
+    return { response };
+  }
+}
+
+export class StartNewChatCommandHandler
+  implements CommandHandler<StartNewChatCommandPayload, StartNewChatCommandResult>
+{
+  readonly commandType = COMMAND_TYPES.START_NEW_CHAT;
+  private readonly geminiClient: IGeminiClientService;
+
+  constructor(geminiClient: IGeminiClientService) {
+    this.geminiClient = geminiClient;
+  }
+
+  async handle(
+    command: Command<StartNewChatCommandPayload>,
+  ): Promise<StartNewChatCommandResult> {
+    const { message, profileName } = extractPayload(command);
+    const client = profileName ? this.geminiClient.forProfile(profileName) : this.geminiClient;
+    const result = await client.startNewChat(message);
+    return { response: result.response, conversationId: result.conversationId };
+  }
+}

package/src/core/errors.ts

@@ -0,0 +1,41 @@
+export class GemitermError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "GemitermError";
+  }
+}
+
+export class AuthenticationError extends GemitermError {
+  constructor(message = "Not authenticated. Please run 'gemiterm login' first.") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+}
+
+export class CookieExpiredError extends GemitermError {
+  constructor(message = "Session has expired. Please run 'gemiterm login' again.") {
+    super(message);
+    this.name = "CookieExpiredError";
+  }
+}
+
+export class GeminiAPIError extends GemitermError {
+  constructor(message: string) {
+    super(message);
+    this.name = "GeminiAPIError";
+  }
+}
+
+export class ConversationNotFoundError extends GemitermError {
+  constructor(conversationId: string) {
+    super(`Conversation '${conversationId}' not found.`);
+    this.name = "ConversationNotFoundError";
+  }
+}
+
+export class ConversationPendingError extends GemitermError {
+  constructor(message = "Conversation operation is still pending.") {
+    super(message);
+    this.name = "ConversationPendingError";
+  }
+}

package/src/core/mediator.ts

@@ -0,0 +1,58 @@
+export interface Query<TPayload = unknown> {
+  readonly type: string;
+  readonly payload: TPayload;
+}
+
+export interface Command<TPayload = unknown> {
+  readonly type: string;
+  readonly payload: TPayload;
+}
+
+export interface QueryHandler<TPayload, TResult> {
+  readonly queryType: string;
+  handle(query: Query<TPayload>): Promise<TResult>;
+}
+
+export interface CommandHandler<TPayload, TResult> {
+  readonly commandType: string;
+  handle(command: Command<TPayload>): Promise<TResult>;
+}
+
+type HandlerLike = {
+  type: string;
+  handle(message: Query | Command): Promise<unknown>;
+};
+
+export class Mediator {
+  private queryHandlers = new Map<string, HandlerLike>();
+  private commandHandlers = new Map<string, HandlerLike>();
+
+  registerQueryHandler<TPayload, TResult>(
+    handler: QueryHandler<TPayload, TResult>,
+  ): void {
+    if (this.queryHandlers.has(handler.queryType)) {
+      throw new Error(`Query handler already registered for type: ${handler.queryType}`);
+    }
+    this.queryHandlers.set(handler.queryType, handler as unknown as HandlerLike);
+  }
+
+  registerCommandHandler<TPayload, TResult>(
+    handler: CommandHandler<TPayload, TResult>,
+  ): void {
+    if (this.commandHandlers.has(handler.commandType)) {
+      throw new Error(`Command handler already registered for type: ${handler.commandType}`);
+    }
+    this.commandHandlers.set(
+      handler.commandType,
+      handler as unknown as HandlerLike,
+    );
+  }
+
+  async send<TResult>(message: Query | Command): Promise<TResult> {
+    const handler = this.queryHandlers.get(message.type) ?? this.commandHandlers.get(message.type);
+    if (!handler) {
+      throw new Error(`No handler registered for message type: ${message.type}`);
+    }
+    return handler.handle(message) as Promise<TResult>;
+  }
+}