gemiterm 2.2.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemiterm",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "module": "index.ts",
   "type": "module",
   "repository": {

package/src/cli/command-registry.ts

@@ -1,7 +1,6 @@
 import type { Mediator } from "../core/mediator.ts";
 import type { ProfileAuthManager } from "../services/profile-auth-manager.ts";
 import { AuthCommand } from "./commands/auth-command.ts";
-import { ProfileCommand } from "./commands/profile-command.ts";
 import { StatusCommand } from "./commands/status-command.ts";
 import { ListCommand } from "./commands/list-command.ts";
 import { FetchCommand } from "./commands/fetch-command.ts";
@@ -51,7 +50,6 @@ export class CommandRegistry {
     const authCommand = new AuthCommand();
     this.register("auth", authCommand);
     this.register("login", authCommand);
-    this.register("profile", new ProfileCommand());
     this.register("status", new StatusCommand());
     this.register("list", new ListCommand());
     this.register("fetch", new FetchCommand());

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

@@ -5,12 +5,27 @@ 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 {
+  listProfiles,
+  getDefaultProfileName,
+  setDefaultProfileName,
+} from "../../infrastructure/config.ts";
 import { GemitermError } from "../../core/errors.ts";
 import { validateProfileName } from "../../infrastructure/validators.ts";
 import { formatProfileTable } from "../../infrastructure/formatters.ts";
 import { text } from "../utils/prompts.ts";
 
+interface ParsedFlags {
+  list: boolean;
+  add: string | null;
+  delete: string | null;
+  rename: { old: string; new: string } | null;
+  default: string | null;
+  renew: string | null;
+  yes: boolean;
+  profileName: string | null;
+}
+
 export class AuthCommand implements CliCommand {
   readonly name = "auth";
   readonly description = "Authenticate with Google Gemini";
@@ -24,6 +39,8 @@ export class AuthCommand implements CliCommand {
     const logger = new Logger("auth-command");
     logger.debug("Executing auth command", args);
 
+    const flags = this.parseFlags(args);
+
     const cookieStorage = new CookieStorage();
     const profileManager = new ProfileManager(cookieStorage);
     const driver = new PlaywrightCliDriver();
@@ -35,6 +52,41 @@ export class AuthCommand implements CliCommand {
       logger,
     });
 
+    if (flags.list) {
+      await this.listProfiles(profileManager, logger);
+      return;
+    }
+
+    if (flags.add !== null) {
+      await this.addProfile(flags.add, profileManager, authService, logger);
+      return;
+    }
+
+    if (flags.delete !== null) {
+      await this.deleteProfile(flags.delete, flags.yes, profileManager, logger);
+      return;
+    }
+
+    if (flags.rename !== null) {
+      await this.renameProfile(flags.rename.old, flags.rename.new, profileManager, logger);
+      return;
+    }
+
+    if (flags.default !== null) {
+      await this.setDefaultProfile(flags.default, profileManager, logger);
+      return;
+    }
+
+    if (flags.renew !== null) {
+      await this.renewProfile(flags.renew, authService, logger);
+      return;
+    }
+
+    if (flags.profileName !== null) {
+      await this.authenticateToProfile(flags.profileName, profileManager, authService, logger);
+      return;
+    }
+
     const profiles = listProfiles();
     logger.debug("Found profiles", profiles);
 
@@ -59,13 +111,205 @@ export class AuthCommand implements CliCommand {
     if (selected.type === "auth") {
       logger.debug("Authenticating with profile", selected.profileName);
       await this.authenticateWithProfile(authService, selected.profileName, profileManager, false);
+    } else if (selected.type === "renew") {
+      logger.debug("Renewing profile", selected.profileName);
+      await authService.renew(selected.profileName);
+    }
+  }
+
+  private parseFlags(args: string[]): ParsedFlags {
+    const flags: ParsedFlags = {
+      list: false,
+      add: null,
+      delete: null,
+      rename: null,
+      default: null,
+      renew: null,
+      yes: false,
+      profileName: null,
+    };
+
+    const remaining: string[] = [];
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+
+      if (arg === "--list" || arg === "-l") {
+        flags.list = true;
+      } else if (arg === "--yes" || arg === "-y") {
+        flags.yes = true;
+      } else if (arg === "--add" || arg === "-a") {
+        if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          flags.add = args[++i];
+        }
+      } else if (arg === "--delete" || arg === "-d") {
+        if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          flags.delete = args[++i];
+        }
+      } else if (arg === "--rename" || arg === "-r") {
+        if (i + 2 < args.length && !args[i + 1].startsWith("-") && !args[i + 2].startsWith("-")) {
+          flags.rename = { old: args[++i], new: args[++i] };
+        }
+      } else if (arg === "--default" || arg === "-s") {
+        if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          flags.default = args[++i];
+        }
+      } else if (arg === "--renew" || arg === "-e") {
+        if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          flags.renew = args[++i];
+        }
+      } else if (!arg.startsWith("-")) {
+        remaining.push(arg);
+      }
+    }
+
+    if (remaining.length > 0) {
+      flags.profileName = remaining[0];
+    }
+
+    return flags;
+  }
+
+  private async listProfiles(profileManager: ProfileManager, logger: Logger): Promise<void> {
+    logger.debug("Listing all profiles");
+    const profileNames = listProfiles();
+    if (profileNames.length === 0) {
+      console.log(chalk.dim("No profiles found. Run 'gemiterm auth' to create one."));
+      return;
     }
+
+    const defaultName = getDefaultProfileName();
+    const statuses = profileNames.map((name) => {
+      const status = profileManager.getStatus(name);
+      return { ...status, isDefault: name === defaultName };
+    });
+
+    console.log(chalk.bold("Profiles"));
+    console.log(formatProfileTable(statuses));
+
+    const active = statuses.filter((s) => s.isActive);
+    logger.info(`${active.length} of ${statuses.length} profile(s) active`);
+  }
+
+  private async addProfile(
+    profileName: string,
+    profileManager: ProfileManager,
+    authService: AuthService,
+    logger: Logger,
+  ): Promise<void> {
+    validateProfileName(profileName);
+    logger.debug("Adding profile:", profileName);
+
+    if (listProfiles().includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' already exists.`);
+    }
+
+    profileManager.create(profileName);
+    console.log(chalk.green(`Profile '${profileName}' created.`));
+
+    await this.authenticateWithProfile(authService, profileName, profileManager, false);
+  }
+
+  private async deleteProfile(
+    profileName: string,
+    skipConfirm: boolean,
+    profileManager: ProfileManager,
+    logger: Logger,
+  ): Promise<void> {
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+
+    logger.debug("Deleting profile:", profileName);
+
+    if (!skipConfirm) {
+      const confirmAnswer = await this.promptInput(`Delete profile '${profileName}'? [y/N]`);
+      if (!confirmAnswer.toLowerCase().startsWith("y")) {
+        console.log(chalk.dim("Cancelled."));
+        return;
+      }
+    }
+
+    profileManager.delete(profileName);
+    logger.info(`Deleted profile: ${profileName}`);
+    console.log(chalk.green(`Profile '${profileName}' deleted.`));
+  }
+
+  private async renameProfile(
+    profileName: string,
+    newName: string,
+    profileManager: ProfileManager,
+    logger: Logger,
+  ): Promise<void> {
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+
+    validateProfileName(newName);
+    logger.debug("Renaming profile:", profileName, "→", newName);
+
+    if (profiles.includes(newName)) {
+      throw new GemitermError(`Profile '${newName}' already exists.`);
+    }
+
+    profileManager.rename(profileName, newName);
+    logger.info(`Renamed profile: ${profileName} → ${newName}`);
+    console.log(chalk.green(`Profile renamed: ${profileName} → ${newName}`));
+  }
+
+  private async setDefaultProfile(
+    profileName: string,
+    profileManager: ProfileManager,
+    logger: Logger,
+  ): Promise<void> {
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+
+    logger.debug("Setting default profile:", profileName);
+
+    profileManager.setDefault(profileName);
+    setDefaultProfileName(profileName);
+    logger.info(`Set default profile: ${profileName}`);
+    console.log(chalk.green(`Default profile set to '${profileName}'.`));
+  }
+
+  private async renewProfile(
+    profileName: string,
+    authService: AuthService,
+    logger: Logger,
+  ): Promise<void> {
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+    logger.debug("Renewing profile:", profileName);
+    await authService.renew(profileName);
+  }
+
+  private async authenticateToProfile(
+    profileName: string,
+    profileManager: ProfileManager,
+    authService: AuthService,
+    logger: Logger,
+  ): Promise<void> {
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+    logger.debug("Authenticating with profile:", profileName);
+    await this.authenticateWithProfile(authService, profileName, profileManager, false);
   }
 
   private async showProfileMenu(
     profiles: string[],
     profileManager: ProfileManager,
-  ): Promise<{ type: "auth"; profileName: string } | null> {
+  ): Promise<
+    { type: "auth"; profileName: string } | { type: "renew"; profileName: string } | null
+  > {
     console.log(chalk.bold("\nProfile Management"));
     console.log("");
 
@@ -77,6 +321,7 @@ export class AuthCommand implements CliCommand {
       { key: "D", label: "Delete profile" },
       { key: "S", label: "Set default" },
       { key: "R", label: "Rename profile" },
+      { key: "E", label: "Renew session (extend/refresh cookies)" },
       { key: "X", label: "Exit and continue with current default" },
     ];
 
@@ -107,8 +352,8 @@ export class AuthCommand implements CliCommand {
         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")) {
+        const confirmAnswer = await this.promptInput(`Delete profile '${trimmed}'? [y/N]`);
+        if (confirmAnswer.toLowerCase().startsWith("y")) {
           profileManager.delete(trimmed);
           console.log(chalk.green(`Profile '${trimmed}' deleted.`));
         } else {
@@ -142,6 +387,14 @@ export class AuthCommand implements CliCommand {
         console.log(chalk.green(`Profile renamed: ${oldTrimmed} → ${newTrimmed}`));
         return { type: "auth", profileName: newTrimmed };
       }
+      case "E": {
+        const name = await this.promptInput("Enter profile name to renew");
+        const trimmed = name.trim();
+        if (!profiles.includes(trimmed)) {
+          throw new GemitermError(`Profile '${trimmed}' does not exist.`);
+        }
+        return { type: "renew", profileName: trimmed };
+      }
       case "X":
       default:
         return null;
@@ -163,12 +416,22 @@ export class AuthCommand implements CliCommand {
   }
 
   private showUsage(): void {
-    console.log(chalk.bold("Usage: gemiterm auth"));
+    console.log(chalk.bold("Usage: gemiterm auth [profileName] [options]"));
     console.log("");
     console.log("Authenticate with Google Gemini.");
     console.log("");
+    console.log("Arguments:");
+    console.log("  profileName              Authenticate to an existing profile directly");
+    console.log("");
     console.log("Options:");
-    console.log("  -h, --help    Show this help message");
+    console.log("  -h, --help                Show this help message");
+    console.log("  -l, --list                List all profiles (non-interactive)");
+    console.log("  -a, --add <name>          Create a new profile and authenticate");
+    console.log("  -d, --delete <name>      Delete a profile");
+    console.log("  -y, --yes                 Skip confirmation prompts");
+    console.log("  -r, --rename <old> <new>  Rename a profile");
+    console.log("  -s, --default <name>     Set default profile");
+    console.log("  -e, --renew <name>       Renew session (extend/refresh cookies)");
   }
 
   private promptInput(

package/src/cli/utils/prompts.ts

@@ -1,7 +1,6 @@
 import chalk from "chalk";
 import figures from "@inquirer/figures";
 import {
-  input,
   confirm as inquirerConfirm,
   select as inquirerSelect,
 } from "@inquirer/prompts";
@@ -82,19 +81,122 @@ export interface TextOptions {
 
 export async function text(opts: TextOptions): Promise<string> {
   requireTty(`gemiterm new "Your message"`);
-  try {
-    return await input(
-      {
-        message: opts.message,
-        default: opts.default,
-        validate: opts.validate,
-        theme,
-      },
-      { signal: getAbortSignal() },
-    );
-  } catch (error) {
-    mapCancellation(error);
-  }
+
+  return new Promise<string>((resolve, reject) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+
+    const prefix = chalk.cyan("?");
+    const message = chalk.bold(opts.message);
+    let buffer = "";
+    let defaultValue = opts.default ?? "";
+    let finished = false;
+
+    function render(showDefault: boolean): void {
+      const display = showDefault && !buffer && defaultValue
+        ? chalk.dim(defaultValue)
+        : buffer;
+      stdout.write(`\r${"\x1b[K"}${prefix} ${message} ${display}`);
+    }
+
+    function cleanup(): void {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(false);
+      stdin.resume();
+    }
+
+    function finish(value: string): void {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      stdout.write(`\r${"\x1b[K"}${prefix} ${message} ${chalk.green(value)}\n`);
+      resolve(value);
+    }
+
+    function cancel(): void {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      stdout.write("\n");
+      reject(new CancellationError("User cancelled."));
+    }
+
+    async function onData(data: Buffer): Promise<void> {
+      const bytes = new Uint8Array(data);
+
+      for (let i = 0; i < bytes.length; i++) {
+        const byte = bytes[i];
+
+        if (byte === 0x03) {
+          cancel();
+          return;
+        }
+
+        if (byte === 0x0d || byte === 0x0a) {
+          const answer = buffer || defaultValue;
+          if (opts.validate) {
+            const valid = await opts.validate(answer);
+            if (valid !== true) {
+              stdout.write(
+                `\r${"\x1b[K"}${prefix} ${message} ${buffer} ${chalk.red(String(valid))}\n`,
+              );
+              render(false);
+              return;
+            }
+          }
+          finish(answer);
+          return;
+        }
+
+        if (byte === 0x08 || byte === 0x7f) {
+          if (buffer.length > 0) {
+            buffer = buffer.slice(0, -1);
+            render(false);
+          } else if (defaultValue) {
+            defaultValue = "";
+            render(true);
+          }
+          continue;
+        }
+
+        if (byte === 0x1b) {
+          const next1 = bytes[i + 1];
+          const next2 = bytes[i + 2];
+          if (next1 === 0x5b && next2 === 0x33 && bytes[i + 3] === 0x7e) {
+            i += 3;
+            continue;
+          }
+          if (next1 !== undefined) i += 1;
+          continue;
+        }
+
+        if (byte >= 0x20 && byte !== 0x7f) {
+          let char: string;
+          if (byte < 0x80) {
+            char = String.fromCharCode(byte);
+          } else {
+            const decoder = new TextDecoder();
+            char = "\uFFFD";
+            for (let len = 2; len <= 4; len++) {
+              const decoded = decoder.decode(bytes.slice(i, i + len));
+              if (decoded.length > 0 && !/\uFFFD/.test(decoded)) {
+                char = decoded;
+                i += new TextEncoder().encode(char).length - 1;
+                break;
+              }
+            }
+          }
+          buffer += char;
+          render(false);
+        }
+      }
+    }
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+    render(true);
+  });
 }
 
 export interface ConfirmOptions {

package/src/infrastructure/storage.ts

@@ -23,12 +23,19 @@ function validateCookies(cookies: Cookie[]): boolean {
 }
 
 function getCookieExpiryTimestamp(cookies: Cookie[]): number | null {
+  let maxExpiry: number | null = null;
   for (const cookie of cookies) {
-    if (cookie.name === "__Secure-1PSIDTS" && cookie.expires > 0) {
-      return cookie.expires * 1000;
+    if (
+      (cookie.name === "__Secure-1PSID" || cookie.name === "__Secure-1PSIDTS") &&
+      cookie.expires > 0
+    ) {
+      const ms = cookie.expires * 1000;
+      if (maxExpiry === null || ms > maxExpiry) {
+        maxExpiry = ms;
+      }
     }
   }
-  return null;
+  return maxExpiry;
 }
 
 function checkCookieFreshness(cookies: Cookie[]): boolean {
@@ -147,8 +154,9 @@ export class ProfileManager {
     }
     try {
       const cookies = this.cookieStorage.load(name);
-      const isActive = validateCookies(cookies) && checkCookieFreshness(cookies);
+      const hasValidCookies = validateCookies(cookies);
       const expiresMs = getCookieExpiryTimestamp(cookies);
+      const isActive = hasValidCookies && (expiresMs === null || expiresMs > Date.now());
       let expiresAt: string | null = null;
       if (expiresMs !== null) {
         expiresAt = new Date(expiresMs).toISOString();

package/src/services/auth-service.ts

@@ -6,6 +6,8 @@ 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";
+import { getProfilePath } from "../infrastructure/path-utils.ts";
+import { existsFile } from "../infrastructure/io.ts";
 
 const GEMINI_AUTH_URL = "https://gemini.google.com/app";
 const DEFAULT_AUTH_TIMEOUT_MS = 300_000;
@@ -57,6 +59,45 @@ export class AuthService {
     }
   }
 
+  async renew(profileName?: string): Promise<AuthResult> {
+    const name = profileName ?? getDefaultProfileName();
+    validateProfileName(name);
+
+    this.logger.info(`Starting session renewal for profile: ${name}`);
+
+    try {
+      console.log(
+        chalk.cyan(`\n🔄 Renewing session → ${GEMINI_AUTH_URL}  (profile: ${name})`),
+      );
+      console.log(
+        chalk.dim(
+          "   Loading existing cookies — if expired, log in to extend your session.\n",
+        ),
+      );
+
+      await this.launchBrowser(name);
+
+      const statePath = getProfilePath(name);
+      if (existsFile(statePath)) {
+        try {
+          await this.driver.stateLoad(name, statePath);
+          await this.driver.evalJs(name, "location.reload()");
+          this.logger.info("Pre-loaded existing cookies into browser session");
+        } catch (err) {
+          this.logger.debug(`Could not pre-load cookies: ${err}`);
+        }
+      }
+
+      const cookies = await this.waitForLogin(name, DEFAULT_AUTH_TIMEOUT_MS);
+      await this.extractCookies(name, cookies);
+      const expiresAt = this.getCookieExpiry(cookies);
+      this.confirmRenewSuccess(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})`),
@@ -115,6 +156,16 @@ export class AuthService {
     console.log(chalk.dim(`   Has __Secure-1PSID: ${hasSid ? "✅" : "❌"}`));
   }
 
+  confirmRenewSuccess(cookieCount: number, expiresAt: Date | null, cookies: Cookie[] = []): void {
+    console.log(chalk.green(`\n✅ Session renewed — saving state…`));
+    console.log(chalk.green(`Renewal 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 {

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

@@ -1,220 +0,0 @@
-import chalk from "chalk";
-import type { CliCommand, CliCommandContext } from "../command-registry.ts";
-import { text } from "../utils/prompts.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 {
-  listProfiles,
-  getDefaultProfileName,
-  setDefaultProfileName,
-} from "../../infrastructure/config.ts";
-import { GemitermError } from "../../core/errors.ts";
-import { validateProfileName } from "../../infrastructure/validators.ts";
-import { formatProfileTable } from "../../infrastructure/formatters.ts";
-
-const ACTIONS = [
-  { name: "add", usage: "profile add <name>", desc: "Create new profile and authenticate" },
-  { name: "delete", usage: "profile delete <name>", desc: "Delete a profile" },
-  { name: "rename", usage: "profile rename <name> <newName>", desc: "Rename a profile" },
-  { name: "default", usage: "profile default <name>", desc: "Set default profile" },
-  { name: "list", usage: "profile list", desc: "List all profiles with status" },
-] as const;
-
-type ProfileAction = (typeof ACTIONS)[number]["name"];
-
-export class ProfileCommand implements CliCommand {
-  readonly name = "profile";
-  readonly description = "Manage authentication profiles";
-
-  async execute(args: string[], context: CliCommandContext): Promise<void> {
-    const logger = new Logger("profile-command");
-    logger.debug("Executing profile command", args);
-
-    if (args.includes("--help") || args.includes("-h")) {
-      this.showUsage();
-      return;
-    }
-
-    const action = args[0] as ProfileAction | undefined;
-
-    if (!action) {
-      this.showUsage();
-      return;
-    }
-
-    const validActions = ACTIONS.map((a) => a.name);
-    if (!validActions.includes(action)) {
-      throw new GemitermError(
-        `Unknown action '${action}'. Valid actions: ${validActions.join(", ")}`,
-      );
-    }
-
-    logger.debug("Profile action:", action);
-
-    switch (action) {
-      case "add":
-        await this.addProfile(args.slice(1), logger);
-        break;
-      case "delete":
-        await this.deleteProfile(args.slice(1), logger);
-        break;
-      case "rename":
-        await this.renameProfile(args.slice(1), logger);
-        break;
-      case "default":
-        await this.setDefaultProfile(args.slice(1), logger);
-        break;
-      case "list":
-        await this.listProfiles(logger);
-        break;
-    }
-  }
-
-  private async addProfile(args: string[], logger: Logger): Promise<void> {
-    const profileName = args[0];
-    if (!profileName) {
-      throw new GemitermError("Usage: profile add <name>");
-    }
-
-    validateProfileName(profileName);
-    logger.debug("Adding profile:", profileName);
-
-    if (listProfiles().includes(profileName)) {
-      throw new GemitermError(`Profile '${profileName}' already exists.`);
-    }
-
-    const cookieStorage = new CookieStorage();
-    const profileManager = new ProfileManager(cookieStorage);
-    profileManager.create(profileName);
-    console.log(chalk.green(`Profile '${profileName}' created.`));
-
-    const driver = new PlaywrightCliDriver();
-    const cookieMonitor = new CookieMonitor({ driver, logger });
-    const authService = new AuthService({
-      driver,
-      cookieMonitor,
-      cookieStorage,
-      logger,
-    });
-
-    await authService.authenticate(profileName);
-  }
-
-  private async deleteProfile(args: string[], logger: Logger): Promise<void> {
-    const profileName = args[0];
-    if (!profileName) {
-      throw new GemitermError("Usage: profile delete <name>");
-    }
-
-    const profiles = listProfiles();
-    if (!profiles.includes(profileName)) {
-      throw new GemitermError(`Profile '${profileName}' does not exist.`);
-    }
-
-    logger.debug("Deleting profile:", profileName);
-
-    const confirm = await this.promptInput(`Delete profile '${profileName}'? [y/N]`);
-    if (!confirm.toLowerCase().startsWith("y")) {
-      console.log(chalk.dim("Cancelled."));
-      return;
-    }
-
-    const cookieStorage = new CookieStorage();
-    const profileManager = new ProfileManager(cookieStorage);
-    profileManager.delete(profileName);
-    logger.info(`Deleted profile: ${profileName}`);
-    console.log(chalk.green(`Profile '${profileName}' deleted.`));
-  }
-
-  private async renameProfile(args: string[], logger: Logger): Promise<void> {
-    const profileName = args[0];
-    const newName = args[1];
-    if (!profileName || !newName) {
-      throw new GemitermError("Usage: profile rename <name> <newName>");
-    }
-
-    const profiles = listProfiles();
-    if (!profiles.includes(profileName)) {
-      throw new GemitermError(`Profile '${profileName}' does not exist.`);
-    }
-
-    validateProfileName(newName);
-    logger.debug("Renaming profile:", profileName, "→", newName);
-
-    if (profiles.includes(newName)) {
-      throw new GemitermError(`Profile '${newName}' already exists.`);
-    }
-
-    const cookieStorage = new CookieStorage();
-    const profileManager = new ProfileManager(cookieStorage);
-    profileManager.rename(profileName, newName);
-    logger.info(`Renamed profile: ${profileName} → ${newName}`);
-    console.log(chalk.green(`Profile renamed: ${profileName} → ${newName}`));
-  }
-
-  private async setDefaultProfile(args: string[], logger: Logger): Promise<void> {
-    const profileName = args[0];
-    if (!profileName) {
-      throw new GemitermError("Usage: profile default <name>");
-    }
-
-    const profiles = listProfiles();
-    if (!profiles.includes(profileName)) {
-      throw new GemitermError(`Profile '${profileName}' does not exist.`);
-    }
-
-    logger.debug("Setting default profile:", profileName);
-
-    const cookieStorage = new CookieStorage();
-    const profileManager = new ProfileManager(cookieStorage);
-    profileManager.setDefault(profileName);
-    setDefaultProfileName(profileName);
-    logger.info(`Set default profile: ${profileName}`);
-    console.log(chalk.green(`Default profile set to '${profileName}'.`));
-  }
-
-  private async listProfiles(logger: Logger): Promise<void> {
-    logger.debug("Listing all profiles");
-    const profileNames = listProfiles();
-    if (profileNames.length === 0) {
-      console.log(chalk.dim("No profiles found. Run 'gemiterm login' to create one."));
-      return;
-    }
-
-    const cookieStorage = new CookieStorage();
-    const profileManager = new ProfileManager(cookieStorage);
-    const defaultName = getDefaultProfileName();
-    const statuses = profileNames.map((name) => {
-      const status = profileManager.getStatus(name);
-      return { ...status, isDefault: name === defaultName };
-    });
-
-    console.log(chalk.bold("Profiles"));
-    console.log(formatProfileTable(statuses));
-
-    const active = statuses.filter((s) => s.isActive);
-    logger.info(`${active.length} of ${statuses.length} profile(s) active`);
-  }
-
-  private showUsage(): void {
-    console.log(chalk.bold("Usage: gemiterm profile <action> [args]"));
-    console.log("");
-    console.log(chalk.bold("Actions:"));
-
-    const maxUsageLen = Math.max(...ACTIONS.map((a) => a.usage.length));
-    for (const action of ACTIONS) {
-      const padded = action.usage.padEnd(maxUsageLen + 2);
-      console.log(`  ${chalk.cyan(padded)}${chalk.dim(action.desc)}`);
-    }
-
-    console.log("");
-    console.log(chalk.dim("Run 'gemiterm profile <action> --help' for more information."));
-  }
-
-  private promptInput(prompt: string): Promise<string> {
-    return text({ message: prompt });
-  }
-}