gemiterm 2.0.0

package/src/cli/commands/auth-command.ts

@@ -0,0 +1,179 @@
+import chalk from "chalk";
+import { createInterface } from "node:readline";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import { CookieStorage, ProfileManager } from "../../infrastructure/storage.ts";
+import { PlaywrightCliDriver } from "../../services/playwright-cli-driver.ts";
+import { CookieMonitor } from "../../services/cookie-monitor.ts";
+import { AuthService } from "../../services/auth-service.ts";
+import { getDefaultProfileName, listProfiles, setDefaultProfileName } from "../../infrastructure/config.ts";
+import { GemitermError } from "../../core/errors.ts";
+import { validateProfileName } from "../../infrastructure/validators.ts";
+import { formatProfileTable } from "../../infrastructure/formatters.ts";
+
+export class AuthCommand implements CliCommand {
+  readonly name = "auth";
+  readonly description = "Authenticate with Google Gemini";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    if (args.includes("--help") || args.includes("-h")) {
+      this.showUsage();
+      return;
+    }
+
+    const logger = new Logger("auth-command");
+    logger.debug("Executing auth command", args);
+
+    const cookieStorage = new CookieStorage();
+    const profileManager = new ProfileManager(cookieStorage);
+    const driver = new PlaywrightCliDriver();
+    const cookieMonitor = new CookieMonitor({ driver, logger });
+    const authService = new AuthService({
+      driver,
+      cookieMonitor,
+      cookieStorage,
+      logger,
+    });
+
+    const profiles = listProfiles();
+    logger.debug("Found profiles", profiles);
+
+    if (profiles.length === 0) {
+      logger.debug("No profiles exist, creating first profile and authenticating");
+      await this.authenticateWithProfile(authService, getDefaultProfileName(), profileManager, true);
+      return;
+    }
+
+    if (profiles.length === 1) {
+      logger.debug("Single profile found, authenticating with", profiles[0]);
+      await this.authenticateWithProfile(authService, profiles[0], profileManager, false);
+      return;
+    }
+
+    const selected = await this.showProfileMenu(profiles, profileManager);
+    if (selected === null) {
+      console.log(chalk.dim("Continuing with current default profile."));
+      return;
+    }
+
+    if (selected.type === "auth") {
+      logger.debug("Authenticating with profile", selected.profileName);
+      await this.authenticateWithProfile(authService, selected.profileName, profileManager, false);
+    }
+  }
+
+  private async showProfileMenu(
+    profiles: string[],
+    profileManager: ProfileManager,
+  ): Promise<{ type: "auth"; profileName: string } | null> {
+    console.log(chalk.bold("\nProfile Management"));
+    console.log("");
+
+    const statuses = profiles.map((name) => profileManager.getStatus(name));
+    console.log(formatProfileTable(statuses));
+
+    const options = [
+      { key: "A", label: "Add new profile" },
+      { key: "D", label: "Delete profile" },
+      { key: "S", label: "Set default" },
+      { key: "R", label: "Rename profile" },
+      { key: "X", label: "Exit and continue with current default" },
+    ];
+
+    for (const opt of options) {
+      console.log(`  ${chalk.cyan(`[${opt.key}]`)} ${opt.label}`);
+    }
+    console.log("");
+
+    const answer = await this.promptInput("Select an option");
+    const choice = answer.toUpperCase().trim();
+
+    switch (choice) {
+      case "A": {
+        const name = await this.promptInput("Enter profile name");
+        validateProfileName(name.trim());
+        if (listProfiles().includes(name.trim())) {
+          throw new GemitermError(`Profile '${name.trim()}' already exists.`);
+        }
+        profileManager.create(name.trim());
+        console.log(chalk.green(`Profile '${name.trim()}' created.`));
+        return { type: "auth", profileName: name.trim() };
+      }
+      case "D": {
+        const name = await this.promptInput("Enter profile name to delete");
+        const trimmed = name.trim();
+        if (!profiles.includes(trimmed)) {
+          throw new GemitermError(`Profile '${trimmed}' does not exist.`);
+        }
+        const confirm = await this.promptInput(`Delete profile '${trimmed}'? [y/N]`);
+        if (confirm.toLowerCase().startsWith("y")) {
+          profileManager.delete(trimmed);
+          console.log(chalk.green(`Profile '${trimmed}' deleted.`));
+        } else {
+          console.log(chalk.dim("Cancelled."));
+        }
+        return null;
+      }
+      case "S": {
+        const name = await this.promptInput("Enter profile name to set as default");
+        const trimmed = name.trim();
+        if (!profiles.includes(trimmed)) {
+          throw new GemitermError(`Profile '${trimmed}' does not exist.`);
+        }
+        profileManager.setDefault(trimmed);
+        setDefaultProfileName(trimmed);
+        console.log(chalk.green(`Default profile set to '${trimmed}'.`));
+        return null;
+      }
+      case "R": {
+        const oldName = await this.promptInput("Enter current profile name");
+        const oldTrimmed = oldName.trim();
+        if (!profiles.includes(oldTrimmed)) {
+          throw new GemitermError(`Profile '${oldTrimmed}' does not exist.`);
+        }
+        const newName = await this.promptInput("Enter new profile name");
+        const newTrimmed = newName.trim();
+        validateProfileName(newTrimmed);
+        profileManager.rename(oldTrimmed, newTrimmed);
+        console.log(chalk.green(`Profile renamed: ${oldTrimmed} → ${newTrimmed}`));
+        return { type: "auth", profileName: newTrimmed };
+      }
+      case "X":
+      default:
+        return null;
+    }
+  }
+
+  private async authenticateWithProfile(
+    authService: AuthService,
+    profileName: string,
+    profileManager: ProfileManager,
+    createFirst: boolean,
+  ): Promise<void> {
+    if (createFirst) {
+      profileManager.create(profileName);
+      console.log(chalk.dim(`Created profile: ${profileName}`));
+    }
+
+    await authService.authenticate(profileName);
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm auth"));
+    console.log("");
+    console.log("Authenticate with Google Gemini.");
+    console.log("");
+    console.log("Options:");
+    console.log("  -h, --help    Show this help message");
+  }
+
+  private promptInput(prompt: string): Promise<string> {
+    return new Promise<string>((resolve) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(`${chalk.cyan(prompt + ": ")} `, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+}

package/src/cli/commands/continue-command.ts

@@ -0,0 +1,158 @@
+import chalk from "chalk";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import type { Mediator, Command } from "../../core/mediator.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import { AuthenticationError } from "../../core/errors.ts";
+import {
+  COMMAND_TYPES,
+  type SendMessageCommandPayload,
+  type SendMessageCommandResult,
+} from "../../core/command-handlers.ts";
+import { runInteractiveLoop, type MessageHandlerResult } from "../utils/interactive-prompt.ts";
+
+interface ContinueCommandOptions {
+  help: boolean;
+}
+
+const DEFAULT_OPTIONS: ContinueCommandOptions = {
+  help: false,
+};
+
+export class ContinueCommand implements CliCommand {
+  readonly name = "continue";
+  readonly description = "Continue a conversation";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("continue-command");
+    const options = this.parseArgs(args);
+
+    if (options.help) {
+      this.showUsage();
+      return;
+    }
+
+    let conversationId: string | null = null;
+    let message: string | null = null;
+
+    for (const arg of args) {
+      if (arg.startsWith("--") || arg.startsWith("-")) continue;
+      if (!conversationId) {
+        conversationId = arg;
+      } else if (!message) {
+        message = arg;
+      }
+    }
+
+    if (!conversationId) {
+      await this.invokeListCommand(context);
+      return;
+    }
+
+    const mediator: Mediator = context.mediator;
+
+    if (message) {
+      await this.sendNonInteractive(mediator, conversationId, message, logger, context);
+    } else {
+      await this.startInteractive(mediator, conversationId, logger, context);
+    }
+  }
+
+  private async sendNonInteractive(
+    mediator: Mediator,
+    conversationId: string,
+    message: string,
+    logger: Logger,
+    context: CliCommandContext,
+  ): Promise<void> {
+    const profileName = await this.resolveProfile(context, conversationId);
+    logger.debug(`Sending message to ${conversationId}`);
+    const result = await mediator.send<SendMessageCommandResult>({
+      type: COMMAND_TYPES.SEND_MESSAGE,
+      payload: { conversationId, message, profileName: profileName ?? undefined },
+    } as Command<SendMessageCommandPayload>);
+
+    console.log(chalk.blue.bold("Model:"));
+    console.log(result.response);
+  }
+
+  private async resolveProfile(context: CliCommandContext, conversationId: string): Promise<string | null> {
+    const profiles = context.profileAuthManager.getActiveProfiles();
+    if (profiles.length <= 1) {
+      return null;
+    }
+    const profileName = await context.profileAuthManager.findProfileForConversation(conversationId);
+    if (profileName === null) {
+      throw new AuthenticationError(
+        `Could not find a profile that owns conversation '${conversationId}'. Run 'gemiterm list --all-profiles' to see which profile it belongs to, then 'gemiterm continue ${conversationId} <msg> --profile <name>' to specify the profile explicitly.`,
+      );
+    }
+    return profileName;
+  }
+
+  private async startInteractive(
+    mediator: Mediator,
+    conversationId: string,
+    logger: Logger,
+    context: CliCommandContext,
+  ): Promise<void> {
+    const profileName = await this.resolveProfile(context, conversationId);
+
+    const messageHandler = async (message: string): Promise<MessageHandlerResult> => {
+      logger.debug(`Sending message to ${conversationId}`);
+      const result = await mediator.send<SendMessageCommandResult>({
+        type: COMMAND_TYPES.SEND_MESSAGE,
+        payload: { conversationId, message, profileName: profileName ?? undefined },
+      } as Command<SendMessageCommandPayload>);
+
+      return { response: result.response };
+    };
+
+    await runInteractiveLoop(messageHandler, { profileName });
+  }
+
+  private async invokeListCommand(context: CliCommandContext): Promise<void> {
+    const { CommandRegistry } = await import("../command-registry.ts");
+    const registry = new CommandRegistry();
+    registry.registerAllCommands();
+
+    const listHandler = registry.getHandler("list");
+    if (listHandler) {
+      console.log(chalk.dim("No conversation ID specified. Listing conversations:\n"));
+      await listHandler.execute([], context);
+    } else {
+      console.error("Could not invoke list command.");
+      process.exit(1);
+    }
+  }
+
+  private parseArgs(args: string[]): ContinueCommandOptions {
+    const options = { ...DEFAULT_OPTIONS };
+
+    for (const arg of args) {
+      if (arg === "--help" || arg === "-h") {
+        options.help = true;
+      }
+    }
+
+    return options;
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm continue [conversation_id] [message] [options]"));
+    console.log("");
+    console.log(chalk.bold("Arguments:"));
+    console.log(
+      `  ${chalk.cyan("conversation_id".padEnd(20))}${chalk.dim("ID of the conversation to continue (optional)")}`,
+    );
+    console.log(
+      `  ${chalk.cyan("message".padEnd(20))}${chalk.dim("Message to send (optional, starts interactive mode if omitted)")}`,
+    );
+    console.log("");
+    console.log(chalk.bold("Options:"));
+    console.log(`  ${chalk.cyan("--help, -h".padEnd(22))}${chalk.dim("Show this help message")}`);
+    console.log("");
+    console.log(chalk.dim("If no conversation_id is provided, the list command will be invoked."));
+    console.log(chalk.dim("If no message is provided, an interactive chat session will start."));
+    console.log(chalk.dim("In interactive mode, type /exit or /quit to exit."));
+  }
+}

package/src/cli/commands/delete-command.ts

@@ -0,0 +1,163 @@
+import chalk from "chalk";
+import { createInterface } from "node:readline";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import type { Mediator, Command } from "../../core/mediator.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import { AuthenticationError } from "../../core/errors.ts";
+import {
+  COMMAND_TYPES,
+  type DeleteConversationCommandPayload,
+  type DeleteConversationCommandResult,
+} from "../../core/command-handlers.ts";
+import { validateConversationId } from "../../infrastructure/validators.ts";
+
+interface DeleteCommandOptions {
+  help: boolean;
+  force: boolean;
+}
+
+const DEFAULT_OPTIONS: DeleteCommandOptions = {
+  help: false,
+  force: false,
+};
+
+export class DeleteCommand implements CliCommand {
+  readonly name = "delete";
+  readonly description = "Delete a conversation";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("delete-command");
+    const options = this.parseArgs(args);
+
+    if (options.help) {
+      this.showUsage();
+      return;
+    }
+
+    const conversationId = this.extractConversationId(args);
+
+    if (!conversationId) {
+      console.error(chalk.red("Error: conversation ID is required."));
+      this.showUsage();
+      process.exit(1);
+    }
+
+    try {
+      validateConversationId(conversationId);
+    } catch (error) {
+      console.error(chalk.red(`Error: ${(error as Error).message}`));
+      process.exit(1);
+    }
+
+    const profileName = await this.resolveProfile(context, conversationId);
+
+    if (!options.force) {
+      const confirmed = await this.promptConfirmation(conversationId);
+      if (!confirmed) {
+        console.log(chalk.dim("Cancelled."));
+        return;
+      }
+    }
+
+    const mediator: Mediator = context.mediator;
+    const payload: DeleteConversationCommandPayload = { conversationId, profileName: profileName ?? undefined };
+
+    logger.debug(`Sending delete-conversation command: ${JSON.stringify(payload)}`);
+
+    try {
+      const result = await mediator.send<DeleteConversationCommandResult>({
+        type: COMMAND_TYPES.DELETE_CONVERSATION,
+        payload,
+      } as Command<DeleteConversationCommandPayload>);
+
+      if (result.success) {
+        console.log(chalk.green(`Conversation '${chalk.cyan(conversationId)}' deleted.`));
+        logger.info(`Deleted conversation: ${conversationId}`);
+      } else {
+        console.error(chalk.red("Failed to delete conversation."));
+        process.exit(1);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  }
+
+  private async resolveProfile(context: CliCommandContext, conversationId: string): Promise<string | null> {
+    const profiles = context.profileAuthManager.getActiveProfiles();
+    if (profiles.length <= 1) {
+      return null;
+    }
+    const profileName = await context.profileAuthManager.findProfileForConversation(conversationId);
+    if (profileName === null) {
+      throw new AuthenticationError(
+        `Could not find a profile that owns conversation '${conversationId}'. Run 'gemiterm list --all-profiles' to see which profile it belongs to, then 'gemiterm delete ${conversationId} --profile <name>' to specify the profile explicitly.`,
+      );
+    }
+    return profileName;
+  }
+
+  private extractConversationId(args: string[]): string | null {
+    for (const arg of args) {
+      if (arg.startsWith("--") || arg.startsWith("-")) continue;
+      return arg;
+    }
+    return null;
+  }
+
+  private parseArgs(args: string[]): DeleteCommandOptions {
+    const options = { ...DEFAULT_OPTIONS };
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      switch (arg) {
+        case "--help":
+        case "-h":
+          options.help = true;
+          break;
+        case "--force":
+        case "-f":
+          options.force = true;
+          break;
+      }
+    }
+
+    return options;
+  }
+
+  private promptConfirmation(conversationId: string): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(
+        `${chalk.cyan(`Delete conversation '${conversationId}'?`)} (yes/no): `,
+        (answer) => {
+          rl.close();
+          resolve(answer.toLowerCase().startsWith("y"));
+        },
+      );
+    });
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm delete <conversation_id> [options]"));
+    console.log("");
+    console.log(chalk.bold("Arguments:"));
+    console.log(
+      `  ${chalk.cyan("conversation_id".padEnd(20))}${chalk.dim("ID of the conversation to delete")}`,
+    );
+    console.log("");
+    console.log(chalk.bold("Options:"));
+
+    const flags = [
+      { flag: "--force, -f", desc: "Skip confirmation prompt" },
+      { flag: "--help, -h", desc: "Show this help message" },
+    ];
+
+    const maxLen = Math.max(...flags.map((f) => f.flag.length));
+    for (const f of flags) {
+      const padded = f.flag.padEnd(maxLen + 2);
+      console.log(`  ${chalk.cyan(padded)}${chalk.dim(f.desc)}`);
+    }
+  }
+}