caflip 0.2.0

package/dist/cli.js

@@ -0,0 +1,3420 @@
+#!/usr/bin/env bun
+// @bun
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/cli-width/index.js
+var require_cli_width = __commonJS((exports, module) => {
+  module.exports = cliWidth;
+  function normalizeOpts(options) {
+    const defaultOpts = {
+      defaultWidth: 0,
+      output: process.stdout,
+      tty: __require("tty")
+    };
+    if (!options) {
+      return defaultOpts;
+    }
+    Object.keys(defaultOpts).forEach(function(key) {
+      if (!options[key]) {
+        options[key] = defaultOpts[key];
+      }
+    });
+    return options;
+  }
+  function cliWidth(options) {
+    const opts = normalizeOpts(options);
+    if (opts.output.getWindowSize) {
+      return opts.output.getWindowSize()[0] || opts.defaultWidth;
+    }
+    if (opts.tty.getWindowSize) {
+      return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+    }
+    if (opts.output.columns) {
+      return opts.output.columns;
+    }
+    if (process.env.CLI_WIDTH) {
+      const width = parseInt(process.env.CLI_WIDTH, 10);
+      if (!isNaN(width) && width !== 0) {
+        return width;
+      }
+    }
+    return opts.defaultWidth;
+  }
+});
+
+// node_modules/mute-stream/lib/index.js
+var require_lib = __commonJS((exports, module) => {
+  var Stream = __require("stream");
+
+  class MuteStream extends Stream {
+    #isTTY = null;
+    constructor(opts = {}) {
+      super(opts);
+      this.writable = this.readable = true;
+      this.muted = false;
+      this.on("pipe", this._onpipe);
+      this.replace = opts.replace;
+      this._prompt = opts.prompt || null;
+      this._hadControl = false;
+    }
+    #destSrc(key, def) {
+      if (this._dest) {
+        return this._dest[key];
+      }
+      if (this._src) {
+        return this._src[key];
+      }
+      return def;
+    }
+    #proxy(method, ...args) {
+      if (typeof this._dest?.[method] === "function") {
+        this._dest[method](...args);
+      }
+      if (typeof this._src?.[method] === "function") {
+        this._src[method](...args);
+      }
+    }
+    get isTTY() {
+      if (this.#isTTY !== null) {
+        return this.#isTTY;
+      }
+      return this.#destSrc("isTTY", false);
+    }
+    set isTTY(val) {
+      this.#isTTY = val;
+    }
+    get rows() {
+      return this.#destSrc("rows");
+    }
+    get columns() {
+      return this.#destSrc("columns");
+    }
+    mute() {
+      this.muted = true;
+    }
+    unmute() {
+      this.muted = false;
+    }
+    _onpipe(src) {
+      this._src = src;
+    }
+    pipe(dest, options) {
+      this._dest = dest;
+      return super.pipe(dest, options);
+    }
+    pause() {
+      if (this._src) {
+        return this._src.pause();
+      }
+    }
+    resume() {
+      if (this._src) {
+        return this._src.resume();
+      }
+    }
+    write(c) {
+      if (this.muted) {
+        if (!this.replace) {
+          return true;
+        }
+        if (c.match(/^\u001b/)) {
+          if (c.indexOf(this._prompt) === 0) {
+            c = c.slice(this._prompt.length);
+            c = c.replace(/./g, this.replace);
+            c = this._prompt + c;
+          }
+          this._hadControl = true;
+          return this.emit("data", c);
+        } else {
+          if (this._prompt && this._hadControl && c.indexOf(this._prompt) === 0) {
+            this._hadControl = false;
+            this.emit("data", this._prompt);
+            c = c.slice(this._prompt.length);
+          }
+          c = c.toString().replace(/./g, this.replace);
+        }
+      }
+      this.emit("data", c);
+    }
+    end(c) {
+      if (this.muted) {
+        if (c && this.replace) {
+          c = c.toString().replace(/./g, this.replace);
+        } else {
+          c = null;
+        }
+      }
+      if (c) {
+        this.emit("data", c);
+      }
+      this.emit("end");
+    }
+    destroy(...args) {
+      return this.#proxy("destroy", ...args);
+    }
+    destroySoon(...args) {
+      return this.#proxy("destroySoon", ...args);
+    }
+    close(...args) {
+      return this.#proxy("close", ...args);
+    }
+  }
+  module.exports = MuteStream;
+});
+
+// src/index.ts
+import { existsSync as existsSync10, readFileSync as readFileSync10, mkdirSync as mkdirSync6 } from "fs";
+
+// src/config.ts
+import { homedir } from "os";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function getBackupDir(provider) {
+  return join(homedir(), ".caflip-backup", provider);
+}
+function getSequenceFile(provider) {
+  return join(getBackupDir(provider), "sequence.json");
+}
+function getLockDir(provider) {
+  return join(getBackupDir(provider), ".lock");
+}
+function getConfigsDir(provider) {
+  return join(getBackupDir(provider), "configs");
+}
+function getCredentialsDir(provider) {
+  return join(getBackupDir(provider), "credentials");
+}
+var BACKUP_DIR = getBackupDir("claude");
+var SEQUENCE_FILE = getSequenceFile("claude");
+var LOCK_DIR = getLockDir("claude");
+var CONFIGS_DIR = getConfigsDir("claude");
+var CREDENTIALS_DIR = getCredentialsDir("claude");
+var RESERVED_COMMANDS = [
+  "list",
+  "add",
+  "remove",
+  "next",
+  "status",
+  "alias",
+  "claude",
+  "codex",
+  "help"
+];
+function getClaudeConfigPath() {
+  const primary = join(homedir(), ".claude", ".claude.json");
+  const fallback = join(homedir(), ".claude.json");
+  if (existsSync(primary)) {
+    try {
+      const content = JSON.parse(readFileSync(primary, "utf-8"));
+      if (content.oauthAccount) {
+        return primary;
+      }
+    } catch {}
+  }
+  return fallback;
+}
+
+// src/accounts.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+
+// src/files.ts
+import { existsSync as existsSync2, mkdirSync, rmSync, chmodSync, renameSync, writeFileSync, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+import { randomBytes } from "crypto";
+async function writeJsonAtomic(filePath, data) {
+  const jsonStr = JSON.stringify(data, null, 2);
+  JSON.parse(jsonStr);
+  const dir = dirname(filePath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  chmodSync(dir, 448);
+  const tempFile = `${filePath}.${Date.now()}.${randomBytes(8).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tempFile, jsonStr, { mode: 384, flag: "wx" });
+    renameSync(tempFile, filePath);
+    chmodSync(filePath, 384);
+  } catch (err) {
+    try {
+      rmSync(tempFile, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+
+// src/accounts.ts
+async function initSequenceFile(path) {
+  if (existsSync3(path))
+    return;
+  const data = {
+    activeAccountNumber: null,
+    lastUpdated: new Date().toISOString(),
+    sequence: [],
+    accounts: {}
+  };
+  await writeJsonAtomic(path, data);
+}
+async function loadSequence(path) {
+  return JSON.parse(readFileSync3(path, "utf-8"));
+}
+function getNextAccountNumber(seq) {
+  const keys = Object.keys(seq.accounts).map(Number);
+  if (keys.length === 0)
+    return 1;
+  return Math.max(...keys) + 1;
+}
+function accountExists(seq, email) {
+  return Object.values(seq.accounts).some((a) => a.email === email);
+}
+function addAccountToSequence(seq, info) {
+  const num = getNextAccountNumber(seq);
+  const numStr = String(num);
+  const account = {
+    email: info.email,
+    uuid: info.uuid,
+    added: new Date().toISOString()
+  };
+  if (info.alias) {
+    account.alias = info.alias;
+  }
+  return {
+    ...seq,
+    accounts: { ...seq.accounts, [numStr]: account },
+    sequence: [...seq.sequence, num],
+    activeAccountNumber: num,
+    lastUpdated: new Date().toISOString()
+  };
+}
+function removeAccountFromSequence(seq, accountNum) {
+  const numValue = Number(accountNum);
+  const { [accountNum]: _, ...remainingAccounts } = seq.accounts;
+  const remainingSequence = seq.sequence.filter((n) => n !== numValue);
+  let nextActive = seq.activeAccountNumber;
+  if (remainingSequence.length === 0) {
+    nextActive = null;
+  } else if (seq.activeAccountNumber === numValue) {
+    nextActive = remainingSequence[0];
+  }
+  return {
+    ...seq,
+    accounts: remainingAccounts,
+    sequence: remainingSequence,
+    activeAccountNumber: nextActive,
+    lastUpdated: new Date().toISOString()
+  };
+}
+function getPostRemovalAction(original, updated, removedAccountNum) {
+  const removedNum = Number(removedAccountNum);
+  if (original.activeAccountNumber !== removedNum) {
+    return { type: "none" };
+  }
+  if (updated.activeAccountNumber === null) {
+    return { type: "logout" };
+  }
+  return {
+    type: "switch",
+    targetAccountNumber: String(updated.activeAccountNumber)
+  };
+}
+function resolveManagedAccountNumberForEmail(seq, currentEmail) {
+  if (!currentEmail || currentEmail === "none") {
+    return null;
+  }
+  const accountNum = resolveAccountIdentifier(seq, currentEmail);
+  if (!accountNum) {
+    return null;
+  }
+  return Number(accountNum);
+}
+function getNextInSequence(seq) {
+  const currentIndex = seq.sequence.indexOf(seq.activeAccountNumber);
+  const nextIndex = (currentIndex + 1) % seq.sequence.length;
+  return seq.sequence[nextIndex];
+}
+function resolveAccountIdentifier(seq, identifier) {
+  if (/^\d+$/.test(identifier)) {
+    if (seq.accounts[identifier]) {
+      return identifier;
+    }
+    const uiIndex = Number(identifier) - 1;
+    if (uiIndex >= 0 && uiIndex < seq.sequence.length) {
+      return String(seq.sequence[uiIndex]);
+    }
+    return null;
+  }
+  for (const [num, account] of Object.entries(seq.accounts)) {
+    if (account.email === identifier)
+      return num;
+  }
+  return null;
+}
+function resolveAliasTargetAccount(seq, options) {
+  if (options.identifier) {
+    if (/^\d+$/.test(options.identifier)) {
+      return null;
+    }
+    for (const [num, account] of Object.entries(seq.accounts)) {
+      if (account.email === options.identifier)
+        return num;
+    }
+    return null;
+  }
+  if (!options.currentEmail || options.currentEmail === "none") {
+    return null;
+  }
+  return resolveAccountIdentifier(seq, options.currentEmail);
+}
+function getDisplayAccountNumber(seq, accountNum) {
+  const idx = seq.sequence.indexOf(Number(accountNum));
+  return idx === -1 ? null : idx + 1;
+}
+function getDisplayAccountLabel(seq, accountNum) {
+  const displayNum = getDisplayAccountNumber(seq, accountNum);
+  if (displayNum === null) {
+    return `Account-${String(accountNum)}`;
+  }
+  return `Account-${displayNum}`;
+}
+function setAlias(seq, accountNum, alias) {
+  for (const [num, account2] of Object.entries(seq.accounts)) {
+    if (num !== accountNum && account2.alias === alias) {
+      const displayLabel = getDisplayAccountLabel(seq, num);
+      throw new Error(`Alias "${alias}" is already in use by ${displayLabel} (${account2.email})`);
+    }
+  }
+  const account = seq.accounts[accountNum];
+  if (!account) {
+    throw new Error(`${getDisplayAccountLabel(seq, accountNum)} does not exist`);
+  }
+  return {
+    ...seq,
+    accounts: {
+      ...seq.accounts,
+      [accountNum]: { ...account, alias }
+    },
+    lastUpdated: new Date().toISOString()
+  };
+}
+function findAccountByAlias(seq, alias) {
+  for (const [num, account] of Object.entries(seq.accounts)) {
+    if (account.alias === alias)
+      return num;
+  }
+  return null;
+}
+
+// src/files.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, rmSync as rmSync2, chmodSync as chmodSync2, renameSync as renameSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { randomBytes as randomBytes2 } from "crypto";
+async function writeJsonAtomic2(filePath, data) {
+  const jsonStr = JSON.stringify(data, null, 2);
+  JSON.parse(jsonStr);
+  const dir = dirname2(filePath);
+  if (!existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+  }
+  chmodSync2(dir, 448);
+  const tempFile = `${filePath}.${Date.now()}.${randomBytes2(8).toString("hex")}.tmp`;
+  try {
+    writeFileSync2(tempFile, jsonStr, { mode: 384, flag: "wx" });
+    renameSync2(tempFile, filePath);
+    chmodSync2(filePath, 384);
+  } catch (err) {
+    try {
+      rmSync2(tempFile, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+function acquireLock(lockDir) {
+  const parentDir = dirname2(lockDir);
+  if (!existsSync4(parentDir)) {
+    mkdirSync2(parentDir, { recursive: true, mode: 448 });
+  }
+  try {
+    mkdirSync2(lockDir, { recursive: false, mode: 448 });
+    writeLockOwner(lockDir);
+    return;
+  } catch (err) {
+    const code = err instanceof Error && "code" in err ? err.code : undefined;
+    if (code === "EEXIST") {
+      if (isStaleLock(lockDir)) {
+        rmSync2(lockDir, { recursive: true, force: true });
+        mkdirSync2(lockDir, { recursive: false, mode: 448 });
+        writeLockOwner(lockDir);
+        return;
+      }
+      throw new Error(`Another instance is running. If this is wrong, remove ${lockDir}`);
+    }
+    if (err instanceof Error) {
+      throw new Error(`Failed to acquire lock at ${lockDir}: ${err.message}`);
+    }
+    throw new Error(`Failed to acquire lock at ${lockDir}`);
+  }
+}
+function releaseLock(lockDir) {
+  try {
+    rmSync2(lockDir, { recursive: true, force: true });
+  } catch {}
+}
+function getLockOwnerPath(lockDir) {
+  return join3(lockDir, "owner.json");
+}
+function writeLockOwner(lockDir) {
+  const ownerPath = getLockOwnerPath(lockDir);
+  const owner = {
+    pid: process.pid,
+    startedAt: new Date().toISOString()
+  };
+  writeFileSync2(ownerPath, JSON.stringify(owner), { mode: 384 });
+  chmodSync2(lockDir, 448);
+}
+function isStaleLock(lockDir) {
+  const ownerPath = getLockOwnerPath(lockDir);
+  if (!existsSync4(ownerPath)) {
+    return true;
+  }
+  try {
+    const owner = JSON.parse(readFileSync4(ownerPath, "utf-8"));
+    if (!owner.pid || !Number.isInteger(owner.pid) || owner.pid <= 0) {
+      return true;
+    }
+    return !isProcessAlive(owner.pid);
+  } catch {
+    return true;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err instanceof Error && "code" in err) {
+      const code = err.code;
+      if (code === "ESRCH")
+        return false;
+      if (code === "EPERM")
+        return true;
+    }
+    return true;
+  }
+}
+
+// src/config.ts
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+function getBackupDir2(provider) {
+  return join4(homedir2(), ".caflip-backup", provider);
+}
+function getSequenceFile2(provider) {
+  return join4(getBackupDir2(provider), "sequence.json");
+}
+function getLockDir2(provider) {
+  return join4(getBackupDir2(provider), ".lock");
+}
+function getConfigsDir2(provider) {
+  return join4(getBackupDir2(provider), "configs");
+}
+function getCredentialsDir2(provider) {
+  return join4(getBackupDir2(provider), "credentials");
+}
+var BACKUP_DIR2 = getBackupDir2("claude");
+var SEQUENCE_FILE2 = getSequenceFile2("claude");
+var LOCK_DIR2 = getLockDir2("claude");
+var CONFIGS_DIR2 = getConfigsDir2("claude");
+var CREDENTIALS_DIR2 = getCredentialsDir2("claude");
+var RESERVED_COMMANDS2 = [
+  "list",
+  "add",
+  "remove",
+  "next",
+  "status",
+  "alias",
+  "claude",
+  "codex",
+  "help"
+];
+function detectPlatform() {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "linux":
+      return process.env.WSL_DISTRO_NAME ? "wsl" : "linux";
+    case "win32":
+      return "windows";
+    default:
+      return "unknown";
+  }
+}
+function getClaudeConfigPath2() {
+  const primary = join4(homedir2(), ".claude", ".claude.json");
+  const fallback = join4(homedir2(), ".claude.json");
+  if (existsSync5(primary)) {
+    try {
+      const content = JSON.parse(readFileSync5(primary, "utf-8"));
+      if (content.oauthAccount) {
+        return primary;
+      }
+    } catch {}
+  }
+  return fallback;
+}
+
+// src/validation.ts
+var EMAIL_REGEX = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+var ALIAS_REGEX = /^[a-z][a-z0-9-]*$/;
+function validateEmail(email) {
+  return EMAIL_REGEX.test(email);
+}
+function sanitizeEmailForFilename(email) {
+  if (!validateEmail(email))
+    return false;
+  if (email.includes("..") || email.includes("/") || email.includes("\x00")) {
+    return false;
+  }
+  return true;
+}
+function validateAlias(alias) {
+  if (alias.length < 2) {
+    return { valid: false, reason: "Alias must be at least 2 characters" };
+  }
+  if (/^\d+$/.test(alias)) {
+    return {
+      valid: false,
+      reason: "Alias cannot be purely numeric (would conflict with account numbers)"
+    };
+  }
+  if (!ALIAS_REGEX.test(alias)) {
+    return {
+      valid: false,
+      reason: "Alias must contain only lowercase letters, numbers, and hyphens, and start with a letter"
+    };
+  }
+  if (RESERVED_COMMANDS2.includes(alias)) {
+    return { valid: false, reason: `"${alias}" is a reserved command name` };
+  }
+  return { valid: true };
+}
+// package.json
+var package_default = {
+  name: "caflip",
+  version: "0.2.0",
+  type: "module",
+  bin: {
+    caflip: "bin/caflip"
+  },
+  files: [
+    "bin",
+    "dist",
+    "README.md",
+    "install.sh"
+  ],
+  scripts: {
+    build: "bun build --compile src/index.ts --outfile caflip",
+    buildjs: "bun build src/index.ts --target=node --outfile dist/cli.js",
+    dev: "bun run src/index.ts",
+    prepublishOnly: "bun test && bun run buildjs",
+    start: "bun run src/index.ts",
+    test: "bun test"
+  },
+  devDependencies: {
+    "@types/bun": "latest"
+  },
+  peerDependencies: {
+    typescript: "^5"
+  },
+  dependencies: {
+    "@inquirer/prompts": "^8.2.1"
+  }
+};
+
+// src/interactive.ts
+import readline3 from "node:readline";
+
+// node_modules/@inquirer/core/dist/lib/key.js
+var isUpKey = (key, keybindings = []) => key.name === "up" || keybindings.includes("vim") && key.name === "k" || keybindings.includes("emacs") && key.ctrl && key.name === "p";
+var isDownKey = (key, keybindings = []) => key.name === "down" || keybindings.includes("vim") && key.name === "j" || keybindings.includes("emacs") && key.ctrl && key.name === "n";
+var isBackspaceKey = (key) => key.name === "backspace";
+var isTabKey = (key) => key.name === "tab";
+var isNumberKey = (key) => "1234567890".includes(key.name);
+var isEnterKey = (key) => key.name === "enter" || key.name === "return";
+// node_modules/@inquirer/core/dist/lib/errors.js
+class AbortPromptError extends Error {
+  name = "AbortPromptError";
+  message = "Prompt was aborted";
+  constructor(options) {
+    super();
+    this.cause = options?.cause;
+  }
+}
+
+class CancelPromptError extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+}
+
+class ExitPromptError extends Error {
+  name = "ExitPromptError";
+}
+
+class HookError extends Error {
+  name = "HookError";
+}
+
+class ValidationError extends Error {
+  name = "ValidationError";
+}
+// node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "node:async_hooks";
+
+// node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
+var hookStorage = new AsyncLocalStorage;
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {}
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  return hookStorage.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
+  });
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var effectScheduler = {
+  queue(cb) {
+    const store = getStore();
+    const { index } = store;
+    store.hooksEffect.push(() => {
+      store.hooksCleanup[index]?.();
+      const cleanFn = cb(readline());
+      if (cleanFn != null && typeof cleanFn !== "function") {
+        throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+      }
+      store.hooksCleanup[index] = cleanFn;
+    });
+  },
+  run() {
+    const store = getStore();
+    withUpdates(() => {
+      store.hooksEffect.forEach((effect) => {
+        effect();
+      });
+      store.hooksEffect.length = 0;
+    })();
+  },
+  clearAll() {
+    const store = getStore();
+    store.hooksCleanup.forEach((cleanFn) => {
+      cleanFn?.();
+    });
+    store.hooksEffect.length = 0;
+    store.hooksCleanup.length = 0;
+  }
+};
+
+// node_modules/@inquirer/core/dist/lib/use-state.js
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      if (pointer.get() !== newValue) {
+        pointer.set(newValue);
+        handleChange();
+      }
+    });
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
+  });
+}
+
+// node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+  withPointer((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+    if (hasChanged) {
+      effectScheduler.queue(cb);
+    }
+    pointer.set(depArray);
+  });
+}
+
+// node_modules/@inquirer/core/dist/lib/theme.js
+import { styleText } from "node:util";
+
+// node_modules/@inquirer/figures/dist/index.js
+import process2 from "node:process";
+function isUnicodeSupported() {
+  if (process2.platform !== "win32") {
+    return process2.env["TERM"] !== "linux";
+  }
+  return Boolean(process2.env["WT_SESSION"]) || Boolean(process2.env["TERMINUS_SUBLIME"]) || process2.env["ConEmuTask"] === "{cmd::Cmder}" || process2.env["TERM_PROGRAM"] === "Terminus-Sublime" || process2.env["TERM_PROGRAM"] === "vscode" || process2.env["TERM"] === "xterm-256color" || process2.env["TERM"] === "alacritty" || process2.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common = {
+  circleQuestionMark: "(?)",
+  questionMarkPrefix: "(?)",
+  square: "█",
+  squareDarkShade: "▓",
+  squareMediumShade: "▒",
+  squareLightShade: "░",
+  squareTop: "▀",
+  squareBottom: "▄",
+  squareLeft: "▌",
+  squareRight: "▐",
+  squareCenter: "■",
+  bullet: "●",
+  dot: "․",
+  ellipsis: "…",
+  pointerSmall: "›",
+  triangleUp: "▲",
+  triangleUpSmall: "▴",
+  triangleDown: "▼",
+  triangleDownSmall: "▾",
+  triangleLeftSmall: "◂",
+  triangleRightSmall: "▸",
+  home: "⌂",
+  heart: "♥",
+  musicNote: "♪",
+  musicNoteBeamed: "♫",
+  arrowUp: "↑",
+  arrowDown: "↓",
+  arrowLeft: "←",
+  arrowRight: "→",
+  arrowLeftRight: "↔",
+  arrowUpDown: "↕",
+  almostEqual: "≈",
+  notEqual: "≠",
+  lessOrEqual: "≤",
+  greaterOrEqual: "≥",
+  identical: "≡",
+  infinity: "∞",
+  subscriptZero: "₀",
+  subscriptOne: "₁",
+  subscriptTwo: "₂",
+  subscriptThree: "₃",
+  subscriptFour: "₄",
+  subscriptFive: "₅",
+  subscriptSix: "₆",
+  subscriptSeven: "₇",
+  subscriptEight: "₈",
+  subscriptNine: "₉",
+  oneHalf: "½",
+  oneThird: "⅓",
+  oneQuarter: "¼",
+  oneFifth: "⅕",
+  oneSixth: "⅙",
+  oneEighth: "⅛",
+  twoThirds: "⅔",
+  twoFifths: "⅖",
+  threeQuarters: "¾",
+  threeFifths: "⅗",
+  threeEighths: "⅜",
+  fourFifths: "⅘",
+  fiveSixths: "⅚",
+  fiveEighths: "⅝",
+  sevenEighths: "⅞",
+  line: "─",
+  lineBold: "━",
+  lineDouble: "═",
+  lineDashed0: "┄",
+  lineDashed1: "┅",
+  lineDashed2: "┈",
+  lineDashed3: "┉",
+  lineDashed4: "╌",
+  lineDashed5: "╍",
+  lineDashed6: "╴",
+  lineDashed7: "╶",
+  lineDashed8: "╸",
+  lineDashed9: "╺",
+  lineDashed10: "╼",
+  lineDashed11: "╾",
+  lineDashed12: "−",
+  lineDashed13: "–",
+  lineDashed14: "‐",
+  lineDashed15: "⁃",
+  lineVertical: "│",
+  lineVerticalBold: "┃",
+  lineVerticalDouble: "║",
+  lineVerticalDashed0: "┆",
+  lineVerticalDashed1: "┇",
+  lineVerticalDashed2: "┊",
+  lineVerticalDashed3: "┋",
+  lineVerticalDashed4: "╎",
+  lineVerticalDashed5: "╏",
+  lineVerticalDashed6: "╵",
+  lineVerticalDashed7: "╷",
+  lineVerticalDashed8: "╹",
+  lineVerticalDashed9: "╻",
+  lineVerticalDashed10: "╽",
+  lineVerticalDashed11: "╿",
+  lineDownLeft: "┐",
+  lineDownLeftArc: "╮",
+  lineDownBoldLeftBold: "┓",
+  lineDownBoldLeft: "┒",
+  lineDownLeftBold: "┑",
+  lineDownDoubleLeftDouble: "╗",
+  lineDownDoubleLeft: "╖",
+  lineDownLeftDouble: "╕",
+  lineDownRight: "┌",
+  lineDownRightArc: "╭",
+  lineDownBoldRightBold: "┏",
+  lineDownBoldRight: "┎",
+  lineDownRightBold: "┍",
+  lineDownDoubleRightDouble: "╔",
+  lineDownDoubleRight: "╓",
+  lineDownRightDouble: "╒",
+  lineUpLeft: "┘",
+  lineUpLeftArc: "╯",
+  lineUpBoldLeftBold: "┛",
+  lineUpBoldLeft: "┚",
+  lineUpLeftBold: "┙",
+  lineUpDoubleLeftDouble: "╝",
+  lineUpDoubleLeft: "╜",
+  lineUpLeftDouble: "╛",
+  lineUpRight: "└",
+  lineUpRightArc: "╰",
+  lineUpBoldRightBold: "┗",
+  lineUpBoldRight: "┖",
+  lineUpRightBold: "┕",
+  lineUpDoubleRightDouble: "╚",
+  lineUpDoubleRight: "╙",
+  lineUpRightDouble: "╘",
+  lineUpDownLeft: "┤",
+  lineUpBoldDownBoldLeftBold: "┫",
+  lineUpBoldDownBoldLeft: "┨",
+  lineUpDownLeftBold: "┥",
+  lineUpBoldDownLeftBold: "┩",
+  lineUpDownBoldLeftBold: "┪",
+  lineUpDownBoldLeft: "┧",
+  lineUpBoldDownLeft: "┦",
+  lineUpDoubleDownDoubleLeftDouble: "╣",
+  lineUpDoubleDownDoubleLeft: "╢",
+  lineUpDownLeftDouble: "╡",
+  lineUpDownRight: "├",
+  lineUpBoldDownBoldRightBold: "┣",
+  lineUpBoldDownBoldRight: "┠",
+  lineUpDownRightBold: "┝",
+  lineUpBoldDownRightBold: "┡",
+  lineUpDownBoldRightBold: "┢",
+  lineUpDownBoldRight: "┟",
+  lineUpBoldDownRight: "┞",
+  lineUpDoubleDownDoubleRightDouble: "╠",
+  lineUpDoubleDownDoubleRight: "╟",
+  lineUpDownRightDouble: "╞",
+  lineDownLeftRight: "┬",
+  lineDownBoldLeftBoldRightBold: "┳",
+  lineDownLeftBoldRightBold: "┯",
+  lineDownBoldLeftRight: "┰",
+  lineDownBoldLeftBoldRight: "┱",
+  lineDownBoldLeftRightBold: "┲",
+  lineDownLeftRightBold: "┮",
+  lineDownLeftBoldRight: "┭",
+  lineDownDoubleLeftDoubleRightDouble: "╦",
+  lineDownDoubleLeftRight: "╥",
+  lineDownLeftDoubleRightDouble: "╤",
+  lineUpLeftRight: "┴",
+  lineUpBoldLeftBoldRightBold: "┻",
+  lineUpLeftBoldRightBold: "┷",
+  lineUpBoldLeftRight: "┸",
+  lineUpBoldLeftBoldRight: "┹",
+  lineUpBoldLeftRightBold: "┺",
+  lineUpLeftRightBold: "┶",
+  lineUpLeftBoldRight: "┵",
+  lineUpDoubleLeftDoubleRightDouble: "╩",
+  lineUpDoubleLeftRight: "╨",
+  lineUpLeftDoubleRightDouble: "╧",
+  lineUpDownLeftRight: "┼",
+  lineUpBoldDownBoldLeftBoldRightBold: "╋",
+  lineUpDownBoldLeftBoldRightBold: "╈",
+  lineUpBoldDownLeftBoldRightBold: "╇",
+  lineUpBoldDownBoldLeftRightBold: "╊",
+  lineUpBoldDownBoldLeftBoldRight: "╉",
+  lineUpBoldDownLeftRight: "╀",
+  lineUpDownBoldLeftRight: "╁",
+  lineUpDownLeftBoldRight: "┽",
+  lineUpDownLeftRightBold: "┾",
+  lineUpBoldDownBoldLeftRight: "╂",
+  lineUpDownLeftBoldRightBold: "┿",
+  lineUpBoldDownLeftBoldRight: "╃",
+  lineUpBoldDownLeftRightBold: "╄",
+  lineUpDownBoldLeftBoldRight: "╅",
+  lineUpDownBoldLeftRightBold: "╆",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "╬",
+  lineUpDoubleDownDoubleLeftRight: "╫",
+  lineUpDownLeftDoubleRightDouble: "╪",
+  lineCross: "╳",
+  lineBackslash: "╲",
+  lineSlash: "╱"
+};
+var specialMainSymbols = {
+  tick: "✔",
+  info: "ℹ",
+  warning: "⚠",
+  cross: "✘",
+  squareSmall: "◻",
+  squareSmallFilled: "◼",
+  circle: "◯",
+  circleFilled: "◉",
+  circleDotted: "◌",
+  circleDouble: "◎",
+  circleCircle: "ⓞ",
+  circleCross: "ⓧ",
+  circlePipe: "Ⓘ",
+  radioOn: "◉",
+  radioOff: "◯",
+  checkboxOn: "☒",
+  checkboxOff: "☐",
+  checkboxCircleOn: "ⓧ",
+  checkboxCircleOff: "Ⓘ",
+  pointer: "❯",
+  triangleUpOutline: "△",
+  triangleLeft: "◀",
+  triangleRight: "▶",
+  lozenge: "◆",
+  lozengeOutline: "◇",
+  hamburger: "☰",
+  smiley: "㋡",
+  mustache: "෴",
+  star: "★",
+  play: "▶",
+  nodejs: "⬢",
+  oneSeventh: "⅐",
+  oneNinth: "⅑",
+  oneTenth: "⅒"
+};
+var specialFallbackSymbols = {
+  tick: "√",
+  info: "i",
+  warning: "‼",
+  cross: "×",
+  squareSmall: "□",
+  squareSmallFilled: "■",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(○)",
+  circleCross: "(×)",
+  circlePipe: "(│)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[×]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(×)",
+  checkboxCircleOff: "( )",
+  pointer: ">",
+  triangleUpOutline: "∆",
+  triangleLeft: "◄",
+  triangleRight: "►",
+  lozenge: "♦",
+  lozengeOutline: "◊",
+  hamburger: "≡",
+  smiley: "☺",
+  mustache: "┌─┐",
+  star: "✶",
+  play: "►",
+  nodejs: "♦",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var mainSymbols = {
+  ...common,
+  ...specialMainSymbols
+};
+var fallbackSymbols = {
+  ...common,
+  ...specialFallbackSymbols
+};
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var dist_default = figures;
+var replacements = Object.entries(specialMainSymbols);
+
+// node_modules/@inquirer/core/dist/lib/theme.js
+var defaultTheme = {
+  prefix: {
+    idle: styleText("blue", "?"),
+    done: styleText("green", dist_default.tick)
+  },
+  spinner: {
+    interval: 80,
+    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].map((frame) => styleText("yellow", frame))
+  },
+  style: {
+    answer: (text) => styleText("cyan", text),
+    message: (text) => styleText("bold", text),
+    error: (text) => styleText("red", `> ${text}`),
+    defaultAnswer: (text) => styleText("dim", `(${text})`),
+    help: (text) => styleText("dim", text),
+    highlight: (text) => styleText("cyan", text),
+    key: (text) => styleText("cyan", styleText("bold", `<${text}>`))
+  }
+};
+
+// node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key, value] of Object.entries(obj)) {
+      const prevValue = output[key];
+      output[key] = isPlainObject(prevValue) && isPlainObject(value) ? deepMerge(prevValue, value) : value;
+    }
+  }
+  return output;
+}
+function makeTheme(...themes) {
+  const themesToMerge = [
+    defaultTheme,
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge(...themesToMerge);
+}
+
+// node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState(false);
+  const [tick, setTick] = useState(0);
+  const { prefix, spinner } = makeTheme(theme);
+  useEffect(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(() => {
+          inc = inc + 1;
+          setTick(inc % spinner.frames.length);
+        }, spinner.interval);
+      }, 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
+    }
+  }, [status]);
+  if (showLoader) {
+    return spinner.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+// node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+  return withPointer((pointer) => {
+    const prev = pointer.get();
+    if (!prev || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+      const value = fn();
+      pointer.set({ value, dependencies });
+      return value;
+    }
+    return prev.value;
+  });
+}
+// node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+  return useState({ current: val })[0];
+}
+// node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+  const signal = useRef(userHandler);
+  signal.current = userHandler;
+  useEffect((rl) => {
+    let ignore = false;
+    const handler = withUpdates((_input, event) => {
+      if (ignore)
+        return;
+      signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+// node_modules/@inquirer/core/dist/lib/utils.js
+var import_cli_width = __toESM(require_cli_width(), 1);
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default2 = getStringTruncatedWidth;
+
+// node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default2(input, NO_TRUNCATION2, options).width;
+};
+var dist_default3 = fastStringWidth;
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default3(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default3(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default3(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default3(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default3(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default3(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// node_modules/@inquirer/core/dist/lib/utils.js
+function breakLines(content, width) {
+  return content.split(`
+`).flatMap((line) => wrapAnsi(line, width, { trim: false, hard: true }).split(`
+`).map((str) => str.trimEnd())).join(`
+`);
+}
+function readlineWidth() {
+  return import_cli_width.default({ defaultWidth: 80, output: readline().output });
+}
+
+// node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+  const state = useRef({
+    lastPointer: active,
+    lastActive: undefined
+  });
+  const { lastPointer, lastActive } = state.current;
+  const middle = Math.floor(pageSize / 2);
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+  let pointer = defaultPointerPosition;
+  if (renderedLength > pageSize) {
+    if (loop) {
+      pointer = lastPointer;
+      if (lastActive != null && lastActive < active && active - lastActive < pageSize) {
+        pointer = Math.min(middle, Math.abs(active - lastActive) === 1 ? Math.min(lastPointer + (renderedItems[lastActive]?.length ?? 0), Math.max(defaultPointerPosition, lastPointer)) : lastPointer + active - lastActive);
+      }
+    } else {
+      const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+      pointer = spaceUnderActive < pageSize - middle ? pageSize - spaceUnderActive : Math.min(defaultPointerPosition, middle);
+    }
+  }
+  state.current.lastPointer = pointer;
+  state.current.lastActive = active;
+  return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+  const width = readlineWidth();
+  const bound = (num) => (num % items.length + items.length) % items.length;
+  const renderedItems = items.map((item, index) => {
+    if (item == null)
+      return [];
+    return breakLines(renderItem({ item, index, isActive: index === active }), width).split(`
+`);
+  });
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+  const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+  const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+  const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+  const pageBuffer = Array.from({ length: pageSize });
+  pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+  const itemVisited = new Set([active]);
+  let bufferPointer = activeItemPosition + activeItem.length;
+  let itemPointer = bound(active + 1);
+  while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+    pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer += linesToAdd.length;
+    itemPointer = bound(itemPointer + 1);
+  }
+  bufferPointer = activeItemPosition - 1;
+  itemPointer = bound(active - 1);
+  while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+    pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer -= linesToAdd.length;
+    itemPointer = bound(itemPointer - 1);
+  }
+  return pageBuffer.filter((line) => typeof line === "string").join(`
+`);
+}
+// node_modules/@inquirer/core/dist/lib/create-prompt.js
+var import_mute_stream = __toESM(require_lib(), 1);
+import * as readline2 from "node:readline";
+import { AsyncResource as AsyncResource3 } from "node:async_hooks";
+
+// node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process3) => !!process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase {
+}
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+
+class SignalExitFallback extends SignalExitBase {
+  onExit() {
+    return () => {};
+  }
+  load() {}
+  unload() {}
+}
+
+class SignalExit extends SignalExitBase {
+  #hupSig = process3.platform === "win32" ? "SIGINT" : "SIGHUP";
+  #emitter = new Emitter;
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process3) {
+    super();
+    this.#process = process3;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process3;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process3.kill(process3.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process3.reallyExit;
+    this.#originalProcessEmit = process3.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {};
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {}
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {}
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+}
+var process3 = globalThis.process;
+var {
+  onExit,
+  load,
+  unload
+} = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback);
+
+// node_modules/@inquirer/core/dist/lib/screen-manager.js
+import { stripVTControlCharacters } from "node:util";
+
+// node_modules/@inquirer/ansi/dist/index.js
+var ESC2 = "\x1B[";
+var cursorLeft = ESC2 + "G";
+var cursorHide = ESC2 + "?25l";
+var cursorShow = ESC2 + "?25h";
+var cursorUp = (rows = 1) => rows > 0 ? `${ESC2}${rows}A` : "";
+var cursorDown = (rows = 1) => rows > 0 ? `${ESC2}${rows}B` : "";
+var cursorTo = (x, y) => {
+  if (typeof y === "number" && !Number.isNaN(y)) {
+    return `${ESC2}${y + 1};${x + 1}H`;
+  }
+  return `${ESC2}${x + 1}G`;
+};
+var eraseLine = ESC2 + "2K";
+var eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+
+// node_modules/@inquirer/core/dist/lib/screen-manager.js
+var height = (content) => content.split(`
+`).length;
+var lastLine = (content) => content.split(`
+`).pop() ?? "";
+
+class ScreenManager {
+  height = 0;
+  extraLinesUnderPrompt = 0;
+  cursorPos;
+  rl;
+  constructor(rl) {
+    this.rl = rl;
+    this.cursorPos = rl.getCursorPos();
+  }
+  write(content) {
+    this.rl.output.unmute();
+    this.rl.output.write(content);
+    this.rl.output.mute();
+  }
+  render(content, bottomContent = "") {
+    const promptLine = lastLine(content);
+    const rawPromptLine = stripVTControlCharacters(promptLine);
+    let prompt = rawPromptLine;
+    if (this.rl.line.length > 0) {
+      prompt = prompt.slice(0, -this.rl.line.length);
+    }
+    this.rl.setPrompt(prompt);
+    this.cursorPos = this.rl.getCursorPos();
+    const width = readlineWidth();
+    content = breakLines(content, width);
+    bottomContent = breakLines(bottomContent, width);
+    if (rawPromptLine.length % width === 0) {
+      content += `
+`;
+    }
+    let output = content + (bottomContent ? `
+` + bottomContent : "");
+    const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+    const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+    if (bottomContentHeight > 0)
+      output += cursorUp(bottomContentHeight);
+    output += cursorTo(this.cursorPos.cols);
+    this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+    this.extraLinesUnderPrompt = bottomContentHeight;
+    this.height = height(output);
+  }
+  checkCursorPos() {
+    const cursorPos = this.rl.getCursorPos();
+    if (cursorPos.cols !== this.cursorPos.cols) {
+      this.write(cursorTo(cursorPos.cols));
+      this.cursorPos = cursorPos;
+    }
+  }
+  done({ clearContent }) {
+    this.rl.setPrompt("");
+    let output = cursorDown(this.extraLinesUnderPrompt);
+    output += clearContent ? eraseLines(this.height) : `
+`;
+    output += cursorShow;
+    this.write(output);
+    this.rl.close();
+  }
+}
+
+// node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+class PromisePolyfill extends Promise {
+  static withResolver() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+}
+
+// node_modules/@inquirer/core/dist/lib/create-prompt.js
+function getCallSites() {
+  const _prepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = _prepareStackTrace;
+  return result;
+}
+function createPrompt(view) {
+  const callSites = getCallSites();
+  const prompt = (config, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = new Set;
+    const output = new import_mute_stream.default;
+    output.pipe(context.output ?? process.stdout);
+    const rl = readline2.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    const screen = new ScreenManager(rl);
+    const { promise, resolve, reject } = PromisePolyfill.withResolver();
+    const cancel = () => reject(new CancelPromptError);
+    if (signal) {
+      const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
+      if (signal.aborted) {
+        abort();
+        return Object.assign(promise, { cancel });
+      }
+      signal.addEventListener("abort", abort);
+      cleanups.add(() => signal.removeEventListener("abort", abort));
+    }
+    cleanups.add(onExit((code, signal2) => {
+      reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+    }));
+    const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+    rl.on("SIGINT", sigint);
+    cleanups.add(() => rl.removeListener("SIGINT", sigint));
+    const checkCursorPos = () => screen.checkCursorPos();
+    rl.input.on("keypress", checkCursorPos);
+    cleanups.add(() => rl.input.removeListener("keypress", checkCursorPos));
+    return withHooks(rl, (cycle) => {
+      const hooksCleanup = AsyncResource3.bind(() => effectScheduler.clearAll());
+      rl.on("close", hooksCleanup);
+      cleanups.add(() => rl.removeListener("close", hooksCleanup));
+      cycle(() => {
+        try {
+          const nextView = view(config, (value) => {
+            setImmediate(() => resolve(value));
+          });
+          if (nextView === undefined) {
+            const callerFilename = callSites[1]?.getFileName();
+            throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+          }
+          const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+          screen.render(content, bottomContent);
+          effectScheduler.run();
+        } catch (error) {
+          reject(error);
+        }
+      });
+      return Object.assign(promise.then((answer) => {
+        effectScheduler.clearAll();
+        return answer;
+      }, (error) => {
+        effectScheduler.clearAll();
+        throw error;
+      }).finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise), { cancel });
+    });
+  };
+  return prompt;
+}
+// node_modules/@inquirer/core/dist/lib/Separator.js
+import { styleText as styleText2 } from "node:util";
+class Separator {
+  separator = styleText2("dim", Array.from({ length: 15 }).join(dist_default.line));
+  type = "separator";
+  constructor(separator) {
+    if (separator) {
+      this.separator = separator;
+    }
+  }
+  static isSeparator(choice) {
+    return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
+  }
+}
+// node_modules/@inquirer/confirm/dist/index.js
+function getBooleanValue(value, defaultValue) {
+  let answer = defaultValue !== false;
+  if (/^(y|yes)/i.test(value))
+    answer = true;
+  else if (/^(n|no)/i.test(value))
+    answer = false;
+  return answer;
+}
+function boolToString(value) {
+  return value ? "Yes" : "No";
+}
+var dist_default4 = createPrompt((config, done) => {
+  const { transformer = boolToString } = config;
+  const [status, setStatus] = useState("idle");
+  const [value, setValue] = useState("");
+  const theme = makeTheme(config.theme);
+  const prefix = usePrefix({ status, theme });
+  useKeypress((key, rl) => {
+    if (status !== "idle")
+      return;
+    if (isEnterKey(key)) {
+      const answer = getBooleanValue(value, config.default);
+      setValue(transformer(answer));
+      setStatus("done");
+      done(answer);
+    } else if (isTabKey(key)) {
+      const answer = boolToString(!getBooleanValue(value, config.default));
+      rl.clearLine(0);
+      rl.write(answer);
+      setValue(answer);
+    } else {
+      setValue(rl.line);
+    }
+  });
+  let formattedValue = value;
+  let defaultValue = "";
+  if (status === "done") {
+    formattedValue = theme.style.answer(value);
+  } else {
+    defaultValue = ` ${theme.style.defaultAnswer(config.default === false ? "y/N" : "Y/n")}`;
+  }
+  const message = theme.style.message(config.message, status);
+  return `${prefix} ${message}${defaultValue} ${formattedValue}`;
+});
+// node_modules/@inquirer/select/dist/index.js
+import { styleText as styleText3 } from "node:util";
+var selectTheme = {
+  icon: { cursor: dist_default.pointer },
+  style: {
+    disabled: (text) => styleText3("dim", `- ${text}`),
+    description: (text) => styleText3("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText3("bold", key)} ${styleText3("dim", action)}`).join(styleText3("dim", " • "))
+  },
+  indexMode: "hidden",
+  keybindings: []
+};
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        disabled: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      disabled: choice.disabled ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var dist_default5 = createPrompt((config, done) => {
+  const { loop = true, pageSize = 7 } = config;
+  const theme = makeTheme(selectTheme, config.theme);
+  const { keybindings } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const searchTimeoutRef = useRef();
+  const searchEnabled = !keybindings.includes("vim");
+  const items = useMemo(() => normalizeChoices(config.choices), [config.choices]);
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isSelectable);
+    const last = items.findLastIndex(isSelectable);
+    if (first === -1) {
+      throw new ValidationError("[select prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const defaultItemIndex = useMemo(() => {
+    if (!("default" in config))
+      return -1;
+    return items.findIndex((item) => isSelectable(item) && item.value === config.default);
+  }, [config.default, items]);
+  const [active, setActive] = useState(defaultItemIndex === -1 ? bounds.first : defaultItemIndex);
+  const selectedChoice = items[active];
+  useKeypress((key, rl) => {
+    clearTimeout(searchTimeoutRef.current);
+    if (isEnterKey(key)) {
+      setStatus("done");
+      done(selectedChoice.value);
+    } else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+      rl.clearLine(0);
+      if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+        const offset = isUpKey(key, keybindings) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isSelectable(items[next]));
+        setActive(next);
+      }
+    } else if (isNumberKey(key) && !Number.isNaN(Number(rl.line))) {
+      const selectedIndex = Number(rl.line) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item2) => {
+        if (Separator.isSeparator(item2))
+          return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const item = items[position];
+      if (item != null && isSelectable(item)) {
+        setActive(position);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    } else if (isBackspaceKey(key)) {
+      rl.clearLine(0);
+    } else if (searchEnabled) {
+      const searchTerm = rl.line.toLowerCase();
+      const matchIndex = items.findIndex((item) => {
+        if (Separator.isSeparator(item) || !isSelectable(item))
+          return false;
+        return item.name.toLowerCase().startsWith(searchTerm);
+      });
+      if (matchIndex !== -1) {
+        setActive(matchIndex);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    }
+  });
+  useEffect(() => () => {
+    clearTimeout(searchTimeoutRef.current);
+  }, []);
+  const message = theme.style.message(config.message, status);
+  const helpLine = theme.style.keysHelpTip([
+    ["↑↓", "navigate"],
+    ["⏎", "select"]
+  ]);
+  let separatorCount = 0;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive, index }) {
+      if (Separator.isSeparator(item)) {
+        separatorCount++;
+        return ` ${item.separator}`;
+      }
+      const indexLabel = theme.indexMode === "number" ? `${index + 1 - separatorCount}. ` : "";
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        return theme.style.disabled(`${indexLabel}${item.name} ${disabledLabel}`);
+      }
+      const color = isActive ? theme.style.highlight : (x) => x;
+      const cursor = isActive ? theme.icon.cursor : ` `;
+      return color(`${cursor} ${indexLabel}${item.name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    return [prefix, message, theme.style.answer(selectedChoice.short)].filter(Boolean).join(" ");
+  }
+  const { description } = selectedChoice;
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    helpLine
+  ].filter(Boolean).join(`
+`).trimEnd();
+  return `${lines}${cursorHide}`;
+});
+// src/interactive.ts
+class PromptCancelledError extends Error {
+  constructor() {
+    super("Prompt cancelled");
+    this.name = "PromptCancelledError";
+  }
+}
+function isPromptCancellation(err) {
+  return err instanceof Error && (err.name === "ExitPromptError" || err.name === "CancelPromptError");
+}
+function listenForEsc(promise) {
+  if (typeof promise.cancel !== "function")
+    return () => {};
+  readline3.emitKeypressEvents(process.stdin);
+  const wasRaw = process.stdin.isRaw;
+  if (process.stdin.isTTY && !wasRaw) {
+    process.stdin.setRawMode(true);
+  }
+  const onKeypress = (_str, key) => {
+    if (key?.name === "escape") {
+      promise.cancel();
+    }
+  };
+  process.stdin.on("keypress", onKeypress);
+  return () => {
+    process.stdin.removeListener("keypress", onKeypress);
+    if (process.stdin.isTTY && !wasRaw) {
+      process.stdin.setRawMode(false);
+    }
+  };
+}
+async function wrapPromptCancellation(fn) {
+  const promise = fn();
+  const cleanup = listenForEsc(promise);
+  try {
+    return await promise;
+  } catch (err) {
+    if (isPromptCancellation(err)) {
+      throw new PromptCancelledError;
+    }
+    throw err;
+  } finally {
+    cleanup();
+  }
+}
+function formatAccount(num, email, alias, isActive) {
+  let label = `${num}: ${email}`;
+  if (alias)
+    label += ` [${alias}]`;
+  if (isActive)
+    label += " (active)";
+  return label;
+}
+async function pickAccount(seq, message = "Switch to account:", promptSelect = dist_default5, extraChoices = []) {
+  const choices = [
+    ...seq.sequence.map((num, index) => {
+      const numStr = String(num);
+      const account = seq.accounts[numStr];
+      if (!account) {
+        throw new Error(`Corrupt sequence data: missing account entry for id ${numStr}`);
+      }
+      const isActive = num === seq.activeAccountNumber;
+      return {
+        name: formatAccount(String(index + 1), account.email, account.alias, isActive),
+        value: numStr
+      };
+    }),
+    ...extraChoices
+  ];
+  const bold = (s) => `\x1B[1m${s}\x1B[22m`;
+  const dim = (s) => `\x1B[2m${s}\x1B[22m`;
+  const theme = {
+    style: {
+      keysHelpTip: (keys) => [...keys, ["⎋", "cancel"]].map(([k, a]) => `${bold(k)} ${dim(a)}`).join(dim(" • "))
+    }
+  };
+  return wrapPromptCancellation(() => promptSelect({ message, choices, theme }));
+}
+async function pickChoice(message, choices, promptSelect = dist_default5) {
+  const bold = (s) => `\x1B[1m${s}\x1B[22m`;
+  const dim = (s) => `\x1B[2m${s}\x1B[22m`;
+  const theme = {
+    style: {
+      keysHelpTip: (keys) => [...keys, ["⎋", "cancel"]].map(([k, a]) => `${bold(k)} ${dim(a)}`).join(dim(" • "))
+    }
+  };
+  return wrapPromptCancellation(() => promptSelect({ message, choices, theme }));
+}
+async function pickProvider(defaultProvider, promptSelect = dist_default5) {
+  const choices = [
+    {
+      name: defaultProvider === "claude" ? "Claude Code (last used)" : "Claude Code",
+      value: "claude"
+    },
+    {
+      name: defaultProvider === "codex" ? "Codex (last used)" : "Codex",
+      value: "codex"
+    }
+  ];
+  const selected = await pickChoice("Select provider", choices, promptSelect);
+  return selected;
+}
+async function pickAccountForRemoval(seq, promptSelect = dist_default5) {
+  return pickAccount(seq, "Remove which account?", promptSelect);
+}
+async function confirmAction(message, promptConfirm = dist_default4) {
+  return wrapPromptCancellation(() => promptConfirm({ message, default: false }));
+}
+
+// src/providers/types.ts
+var SUPPORTED_PROVIDERS = ["claude", "codex"];
+function isProviderName(value) {
+  return SUPPORTED_PROVIDERS.includes(value);
+}
+function parseProviderArgs(args) {
+  if (args[0] === "--provider") {
+    throw new Error("Use positional provider syntax: caflip <claude|codex> <command>");
+  }
+  if (args[0] && isProviderName(args[0])) {
+    return { provider: args[0], commandArgs: args.slice(1), isProviderQualified: true };
+  }
+  return { provider: null, commandArgs: args, isProviderQualified: false };
+}
+
+// src/providers/claude.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+
+// src/credentials.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, mkdirSync as mkdirSync3, chmodSync as chmodSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { spawn, spawnSync } from "child_process";
+
+// src/validation.ts
+var EMAIL_REGEX2 = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+var ACCOUNT_NUMBER_REGEX = /^\d+$/;
+function validateEmail2(email) {
+  return EMAIL_REGEX2.test(email);
+}
+function sanitizeEmailForFilename2(email) {
+  if (!validateEmail2(email))
+    return false;
+  if (email.includes("..") || email.includes("/") || email.includes("\x00")) {
+    return false;
+  }
+  return true;
+}
+function validateAccountNumber(accountNum) {
+  return ACCOUNT_NUMBER_REGEX.test(accountNum);
+}
+
+// src/credentials.ts
+async function runCommand(cmd) {
+  return await runCommandWithInput(cmd);
+}
+async function runCommandWithInput(cmd, input) {
+  return await new Promise((resolve, reject) => {
+    const proc = spawn(cmd[0], cmd.slice(1), {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1
+      });
+    });
+    if (input && proc.stdin) {
+      proc.stdin.write(input);
+    }
+    proc.stdin?.end();
+  });
+}
+function isSecurityItemMissing(stderr) {
+  const msg = stderr.toLowerCase();
+  return msg.includes("could not be found") || msg.includes("item could not be found") || msg.includes("item not found");
+}
+function ensureAccountNumberSafe(accountNum) {
+  if (!validateAccountNumber(accountNum)) {
+    throw new Error(`Unsafe account number for filename: ${accountNum}`);
+  }
+}
+function hasSecretTool() {
+  const result = spawnSync("sh", ["-c", "command -v secret-tool >/dev/null 2>&1"], {
+    stdio: "ignore"
+  });
+  return result.status === 0;
+}
+function activeSecretToolAttrs() {
+  return ["service", "claude-code", "account", "active"];
+}
+function backupSecretToolAttrs(accountNum, email) {
+  return ["service", "ccflip", "account", accountNum, "email", email];
+}
+async function secretToolLookup(attrs) {
+  const result = await runCommand(["secret-tool", "lookup", ...attrs]);
+  if (result.exitCode === 0) {
+    return result.stdout;
+  }
+  return "";
+}
+async function secretToolStore(attrs, secret) {
+  const payload = secret.endsWith(`
+`) ? secret : `${secret}
+`;
+  const result = await runCommandWithInput(["secret-tool", "store", "--label", "ccflip credentials", ...attrs], payload);
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to store credentials in secret-tool: ${result.stderr || `exit code ${result.exitCode}`}`);
+  }
+}
+async function secretToolClear(attrs) {
+  const result = await runCommand(["secret-tool", "clear", ...attrs]);
+  if (result.exitCode !== 0 && result.stderr.trim()) {
+    throw new Error(`Failed to clear credentials from secret-tool: ${result.stderr || `exit code ${result.exitCode}`}`);
+  }
+}
+async function readCredentials() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos": {
+      const result = await runCommand([
+        "security",
+        "find-generic-password",
+        "-s",
+        "Claude Code-credentials",
+        "-w"
+      ]);
+      if (result.exitCode === 0) {
+        return result.stdout;
+      }
+      if (isSecurityItemMissing(result.stderr)) {
+        return "";
+      }
+      throw new Error(`Failed to read active credentials from keychain: ${result.stderr || `exit code ${result.exitCode}`}`);
+    }
+    case "linux":
+    case "wsl": {
+      if (hasSecretTool()) {
+        const keyringValue = await secretToolLookup(activeSecretToolAttrs());
+        if (keyringValue) {
+          return keyringValue;
+        }
+      }
+      const credPath = join5(homedir3(), ".claude", ".credentials.json");
+      if (existsSync6(credPath)) {
+        return readFileSync6(credPath, "utf-8");
+      }
+      return "";
+    }
+    default:
+      return "";
+  }
+}
+async function writeCredentials(credentials) {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos": {
+      const result = await runCommand([
+        "security",
+        "add-generic-password",
+        "-U",
+        "-s",
+        "Claude Code-credentials",
+        "-a",
+        process.env.USER ?? "unknown",
+        "-w",
+        credentials
+      ]);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to write active credentials to keychain: ${result.stderr || `exit code ${result.exitCode}`}`);
+      }
+      break;
+    }
+    case "linux":
+    case "wsl": {
+      if (hasSecretTool()) {
+        await secretToolStore(activeSecretToolAttrs(), credentials);
+        return;
+      }
+      const claudeDir = join5(homedir3(), ".claude");
+      mkdirSync3(claudeDir, { recursive: true, mode: 448 });
+      chmodSync3(claudeDir, 448);
+      const credPath = join5(claudeDir, ".credentials.json");
+      writeFileSync3(credPath, credentials, { mode: 384 });
+      chmodSync3(credPath, 384);
+      break;
+    }
+  }
+}
+async function clearActiveCredentials() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos": {
+      const result = await runCommand([
+        "security",
+        "delete-generic-password",
+        "-s",
+        "Claude Code-credentials"
+      ]);
+      if (result.exitCode !== 0 && !isSecurityItemMissing(result.stderr)) {
+        throw new Error(`Failed to clear active credentials from keychain: ${result.stderr || `exit code ${result.exitCode}`}`);
+      }
+      break;
+    }
+    case "linux":
+    case "wsl": {
+      if (hasSecretTool()) {
+        await secretToolClear(activeSecretToolAttrs());
+      }
+      const credPath = join5(homedir3(), ".claude", ".credentials.json");
+      rmSync3(credPath, { force: true });
+      break;
+    }
+  }
+}
+async function readAccountCredentials(accountNum, email, credentialsDir = CREDENTIALS_DIR2) {
+  ensureAccountNumberSafe(accountNum);
+  if (!sanitizeEmailForFilename2(email)) {
+    throw new Error(`Unsafe email for filename: ${email}`);
+  }
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos": {
+      const result = await runCommand([
+        "security",
+        "find-generic-password",
+        "-s",
+        `Claude Code-Account-${accountNum}-${email}`,
+        "-w"
+      ]);
+      if (result.exitCode === 0) {
+        return result.stdout;
+      }
+      if (isSecurityItemMissing(result.stderr)) {
+        return "";
+      }
+      throw new Error(`Failed to read account credentials from keychain: ${result.stderr || `exit code ${result.exitCode}`}`);
+    }
+    case "linux":
+    case "wsl": {
+      if (hasSecretTool()) {
+        const keyringValue = await secretToolLookup(backupSecretToolAttrs(accountNum, email));
+        if (keyringValue) {
+          return keyringValue;
+        }
+      }
+      const credFile = join5(credentialsDir, `.claude-credentials-${accountNum}-${email}.json`);
+      if (existsSync6(credFile)) {
+        return readFileSync6(credFile, "utf-8");
+      }
+      return "";
+    }
+    default:
+      return "";
+  }
+}
+async function writeAccountCredentials(accountNum, email, credentials, credentialsDir = CREDENTIALS_DIR2) {
+  ensureAccountNumberSafe(accountNum);
+  if (!sanitizeEmailForFilename2(email)) {
+    throw new Error(`Unsafe email for filename: ${email}`);
+  }
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos": {
+      const result = await runCommand([
+        "security",
+        "add-generic-password",
+        "-U",
+        "-s",
+        `Claude Code-Account-${accountNum}-${email}`,
+        "-a",
+        process.env.USER ?? "unknown",
+        "-w",
+        credentials
+      ]);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to write account credentials to keychain: ${result.stderr || `exit code ${result.exitCode}`}`);
+      }
+      break;
+    }
+    case "linux":
+    case "wsl": {
+      if (hasSecretTool()) {
+        await secretToolStore(backupSecretToolAttrs(accountNum, email), credentials);
+        return;
+      }
+      const credFile = join5(credentialsDir, `.claude-credentials-${accountNum}-${email}.json`);
+      mkdirSync3(credentialsDir, { recursive: true, mode: 448 });
+      chmodSync3(credentialsDir, 448);
+      const parsed = JSON.parse(credentials);
+      await writeJsonAtomic(credFile, parsed);
+      break;
+    }
+  }
+}
+async function deleteAccountCredentials(accountNum, email, credentialsDir = CREDENTIALS_DIR2) {
+  ensureAccountNumberSafe(accountNum);
+  if (!sanitizeEmailForFilename2(email)) {
+    throw new Error(`Unsafe email for filename: ${email}`);
+  }
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos": {
+      const result = await runCommand([
+        "security",
+        "delete-generic-password",
+        "-s",
+        `Claude Code-Account-${accountNum}-${email}`
+      ]);
+      if (result.exitCode !== 0 && !isSecurityItemMissing(result.stderr)) {
+        throw new Error(`Failed to delete account credentials from keychain: ${result.stderr || `exit code ${result.exitCode}`}`);
+      }
+      break;
+    }
+    case "linux":
+    case "wsl": {
+      if (hasSecretTool()) {
+        await secretToolClear(backupSecretToolAttrs(accountNum, email));
+      }
+      const credFile = join5(credentialsDir, `.claude-credentials-${accountNum}-${email}.json`);
+      rmSync3(credFile, { force: true });
+      break;
+    }
+  }
+}
+function readAccountConfig(accountNum, email, configsDir) {
+  ensureAccountNumberSafe(accountNum);
+  if (!sanitizeEmailForFilename2(email)) {
+    throw new Error(`Unsafe email for filename: ${email}`);
+  }
+  const configFile = join5(configsDir, `.claude-config-${accountNum}-${email}.json`);
+  if (existsSync6(configFile)) {
+    return readFileSync6(configFile, "utf-8");
+  }
+  return "";
+}
+async function writeAccountConfig(accountNum, email, config, configsDir) {
+  ensureAccountNumberSafe(accountNum);
+  if (!sanitizeEmailForFilename2(email)) {
+    throw new Error(`Unsafe email for filename: ${email}`);
+  }
+  const configFile = join5(configsDir, `.claude-config-${accountNum}-${email}.json`);
+  mkdirSync3(configsDir, { recursive: true, mode: 448 });
+  const parsed = JSON.parse(config);
+  await writeJsonAtomic(configFile, parsed);
+}
+function deleteAccountConfig(accountNum, email, configsDir) {
+  ensureAccountNumberSafe(accountNum);
+  if (!sanitizeEmailForFilename2(email)) {
+    throw new Error(`Unsafe email for filename: ${email}`);
+  }
+  const configFile = join5(configsDir, `.claude-config-${accountNum}-${email}.json`);
+  rmSync3(configFile, { force: true });
+}
+
+// src/providers/codex.ts
+import { chmodSync as chmodSync4, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+function getCodexAuthPath() {
+  return join6(process.env.HOME ?? homedir4(), ".codex", "auth.json");
+}
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length < 2)
+    return null;
+  try {
+    const payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = payload + "=".repeat((4 - payload.length % 4) % 4);
+    const decoded = Buffer.from(padded, "base64").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function ensureBackupKeySafe(accountNum, email) {
+  if (!validateAccountNumber(accountNum)) {
+    throw new Error(`Unsafe account number for filename: ${accountNum}`);
+  }
+  if (!sanitizeEmailForFilename2(email)) {
+    throw new Error(`Unsafe email for filename: ${email}`);
+  }
+}
+async function readCodexActiveAuth() {
+  const authPath = getCodexAuthPath();
+  if (!existsSync7(authPath)) {
+    return "";
+  }
+  return readFileSync7(authPath, "utf-8");
+}
+async function writeCodexActiveAuth(raw) {
+  const codexDir = join6(process.env.HOME ?? homedir4(), ".codex");
+  mkdirSync4(codexDir, { recursive: true, mode: 448 });
+  chmodSync4(codexDir, 448);
+  const authPath = getCodexAuthPath();
+  writeFileSync4(authPath, raw, { mode: 384 });
+  chmodSync4(authPath, 384);
+}
+async function clearCodexActiveAuth() {
+  rmSync4(getCodexAuthPath(), { force: true });
+}
+async function readCodexAccountAuthBackup(accountNum, email, credentialsDir) {
+  ensureBackupKeySafe(accountNum, email);
+  const backupPath = join6(credentialsDir, `.codex-auth-${accountNum}-${email}.json`);
+  if (!existsSync7(backupPath)) {
+    return "";
+  }
+  return readFileSync7(backupPath, "utf-8");
+}
+async function writeCodexAccountAuthBackup(accountNum, email, raw, credentialsDir) {
+  ensureBackupKeySafe(accountNum, email);
+  mkdirSync4(credentialsDir, { recursive: true, mode: 448 });
+  chmodSync4(credentialsDir, 448);
+  const backupPath = join6(credentialsDir, `.codex-auth-${accountNum}-${email}.json`);
+  writeFileSync4(backupPath, raw, { mode: 384 });
+  chmodSync4(backupPath, 384);
+}
+async function deleteCodexAccountAuthBackup(accountNum, email, credentialsDir) {
+  ensureBackupKeySafe(accountNum, email);
+  const backupPath = join6(credentialsDir, `.codex-auth-${accountNum}-${email}.json`);
+  rmSync4(backupPath, { force: true });
+}
+function getCodexCurrentAccount() {
+  const authPath = getCodexAuthPath();
+  if (!existsSync7(authPath)) {
+    return null;
+  }
+  try {
+    const authObj = JSON.parse(readFileSync7(authPath, "utf-8"));
+    const idToken = authObj.tokens?.id_token;
+    if (!idToken) {
+      return null;
+    }
+    const payload = decodeJwtPayload(idToken);
+    if (!payload) {
+      return null;
+    }
+    const email = typeof payload.email === "string" ? payload.email : null;
+    if (!email) {
+      return null;
+    }
+    const authPayload = payload["https://api.openai.com/auth"];
+    const accountId = authPayload?.chatgpt_account_id ?? authObj.tokens?.account_id;
+    return {
+      email,
+      accountId
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/claude.ts
+function getClaudeCurrentAccountEmail() {
+  const configPath = getClaudeConfigPath2();
+  if (!existsSync8(configPath))
+    return "none";
+  try {
+    const content = JSON.parse(readFileSync8(configPath, "utf-8"));
+    return content?.oauthAccount?.emailAddress ?? "none";
+  } catch {
+    return "none";
+  }
+}
+var claudeProvider = {
+  name: "claude",
+  getCurrentAccount: () => {
+    const email = getClaudeCurrentAccountEmail();
+    if (email === "none")
+      return null;
+    return { email };
+  },
+  getCurrentAccountEmail: getClaudeCurrentAccountEmail,
+  readActiveAuth: readCredentials,
+  writeActiveAuth: writeCredentials,
+  clearActiveAuth: clearActiveCredentials,
+  readAccountAuth: readAccountCredentials,
+  writeAccountAuth: writeAccountCredentials,
+  deleteAccountAuth: deleteAccountCredentials,
+  readAccountConfig,
+  writeAccountConfig,
+  deleteAccountConfig
+};
+var codexProvider = {
+  name: "codex",
+  getCurrentAccount: getCodexCurrentAccount,
+  getCurrentAccountEmail: () => getCodexCurrentAccount()?.email ?? "none",
+  readActiveAuth: readCodexActiveAuth,
+  writeActiveAuth: writeCodexActiveAuth,
+  clearActiveAuth: clearCodexActiveAuth,
+  readAccountAuth: readCodexAccountAuthBackup,
+  writeAccountAuth: writeCodexAccountAuthBackup,
+  deleteAccountAuth: deleteCodexAccountAuthBackup,
+  readAccountConfig: () => "",
+  writeAccountConfig: async () => {},
+  deleteAccountConfig: () => {}
+};
+
+// src/providers/index.ts
+var providers = {
+  claude: claudeProvider,
+  codex: codexProvider
+};
+function getProvider(name) {
+  return providers[name];
+}
+
+// src/meta.ts
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { mkdirSync as mkdirSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+function getMetaFilePath() {
+  const home = process.env.HOME ?? homedir5();
+  return join7(home, ".caflip-backup", ".meta.json");
+}
+function readCliMeta() {
+  const metaFile = getMetaFilePath();
+  if (!existsSync9(metaFile)) {
+    return { lastProvider: "claude" };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync9(metaFile, "utf-8"));
+    if (parsed.lastProvider === "codex") {
+      return { lastProvider: "codex" };
+    }
+    return { lastProvider: "claude" };
+  } catch {
+    return { lastProvider: "claude" };
+  }
+}
+async function writeLastProvider(provider) {
+  const metaFile = getMetaFilePath();
+  mkdirSync5(join7(process.env.HOME ?? homedir5(), ".caflip-backup"), {
+    recursive: true,
+    mode: 448
+  });
+  await writeJsonAtomic(metaFile, { lastProvider: provider });
+}
+
+// src/index.ts
+var ADD_CURRENT_ACCOUNT_CHOICE = "__add_current_account__";
+var activeBackupDir = BACKUP_DIR;
+var activeSequenceFile = SEQUENCE_FILE;
+var activeLockDir = LOCK_DIR;
+var activeConfigsDir = CONFIGS_DIR;
+var activeCredentialsDir = CREDENTIALS_DIR;
+var activeProvider = getProvider("claude");
+function setActiveProvider(provider) {
+  activeBackupDir = getBackupDir(provider);
+  activeSequenceFile = getSequenceFile(provider);
+  activeLockDir = getLockDir(provider);
+  activeConfigsDir = getConfigsDir(provider);
+  activeCredentialsDir = getCredentialsDir(provider);
+  activeProvider = getProvider(provider);
+}
+function setupDirectories() {
+  for (const dir of [activeBackupDir, activeConfigsDir, activeCredentialsDir]) {
+    mkdirSync6(dir, { recursive: true, mode: 448 });
+  }
+}
+function getCurrentAccount() {
+  return activeProvider.getCurrentAccountEmail();
+}
+function getProviderLabel() {
+  return activeProvider.name === "codex" ? "Codex" : "Claude Code";
+}
+async function clearActiveOAuthAccount() {
+  const configPath = getClaudeConfigPath();
+  let configObj = {};
+  if (existsSync10(configPath)) {
+    try {
+      configObj = JSON.parse(readFileSync10(configPath, "utf-8"));
+    } catch {
+      configObj = {};
+    }
+  }
+  delete configObj.oauthAccount;
+  await writeJsonAtomic2(configPath, configObj);
+}
+async function syncSequenceActiveAccount(seq) {
+  const currentEmail = getCurrentAccount();
+  const resolvedActive = resolveManagedAccountNumberForEmail(seq, currentEmail);
+  if (seq.activeAccountNumber !== resolvedActive) {
+    seq.activeAccountNumber = resolvedActive;
+    seq.lastUpdated = new Date().toISOString();
+    await writeJsonAtomic2(activeSequenceFile, seq);
+  }
+  return seq;
+}
+async function performSwitch(seq, targetAccount, options) {
+  const targetEmail = seq.accounts[targetAccount].email;
+  const currentEmail = options?.currentEmail ?? getCurrentAccount();
+  const currentAccount = currentEmail === "none" ? null : resolveAccountIdentifier(seq, currentEmail);
+  if (currentEmail === targetEmail) {
+    const account = seq.accounts[targetAccount];
+    const aliasStr2 = account.alias ? ` [${account.alias}]` : "";
+    const displayLabel2 = getDisplayAccountLabel(seq, targetAccount);
+    if (seq.activeAccountNumber !== Number(targetAccount)) {
+      seq.activeAccountNumber = Number(targetAccount);
+      seq.lastUpdated = new Date().toISOString();
+      await writeJsonAtomic2(activeSequenceFile, seq);
+    }
+    console.log(`Already using ${displayLabel2} (${account.email})${aliasStr2}`);
+    return;
+  }
+  if (!sanitizeEmailForFilename(targetEmail)) {
+    throw new Error("Target account email is not safe for storage");
+  }
+  if (currentEmail !== "none" && !sanitizeEmailForFilename(currentEmail)) {
+    throw new Error("Current account email is not safe for storage");
+  }
+  if (currentEmail !== "none" && currentAccount) {
+    const currentCreds = await activeProvider.readActiveAuth();
+    if (currentCreds) {
+      await activeProvider.writeAccountAuth(currentAccount, currentEmail, currentCreds, activeCredentialsDir);
+    }
+    if (activeProvider.name === "claude") {
+      const configPath = getClaudeConfigPath();
+      const currentConfig = existsSync10(configPath) ? readFileSync10(configPath, "utf-8") : "";
+      if (currentConfig) {
+        await activeProvider.writeAccountConfig(currentAccount, currentEmail, currentConfig, activeConfigsDir);
+      }
+    }
+  }
+  const targetCreds = await activeProvider.readAccountAuth(targetAccount, targetEmail, activeCredentialsDir);
+  const targetConfig = activeProvider.readAccountConfig(targetAccount, targetEmail, activeConfigsDir);
+  if (!targetCreds) {
+    throw new Error(`Missing backup data for ${getDisplayAccountLabel(seq, targetAccount)}`);
+  }
+  if (activeProvider.name === "claude" && !targetConfig) {
+    throw new Error(`Missing backup data for ${getDisplayAccountLabel(seq, targetAccount)}`);
+  }
+  await activeProvider.writeActiveAuth(targetCreds);
+  if (activeProvider.name === "claude") {
+    const targetConfigObj = JSON.parse(targetConfig);
+    const oauthAccount = targetConfigObj.oauthAccount;
+    if (!oauthAccount) {
+      throw new Error("Invalid oauthAccount in backup");
+    }
+    const configPath = getClaudeConfigPath();
+    let currentConfigObj = {};
+    if (existsSync10(configPath)) {
+      currentConfigObj = JSON.parse(readFileSync10(configPath, "utf-8"));
+    }
+    currentConfigObj.oauthAccount = oauthAccount;
+    await writeJsonAtomic2(configPath, currentConfigObj);
+  }
+  seq.activeAccountNumber = Number(targetAccount);
+  seq.lastUpdated = new Date().toISOString();
+  await writeJsonAtomic2(activeSequenceFile, seq);
+  const alias = seq.accounts[targetAccount].alias;
+  const aliasStr = alias ? ` [${alias}]` : "";
+  const displayLabel = getDisplayAccountLabel(seq, targetAccount);
+  console.log(`Switched to ${displayLabel} (${targetEmail})${aliasStr}`);
+  console.log(`
+Please restart ${getProviderLabel()} to use the new authentication.
+`);
+}
+async function cmdList() {
+  if (!existsSync10(activeSequenceFile)) {
+    const providerCmd = activeProvider.name === "codex" ? "caflip codex add" : "caflip claude add";
+    console.log(`No accounts managed yet. Run: ${providerCmd}`);
+    return;
+  }
+  const seq = await loadSequence(activeSequenceFile);
+  await syncSequenceActiveAccount(seq);
+  const currentEmail = getCurrentAccount();
+  console.log("Accounts:");
+  seq.sequence.forEach((num, index) => {
+    const numStr = String(num);
+    const account = seq.accounts[numStr];
+    if (!account) {
+      throw new Error(`Corrupt sequence data: missing account entry for id ${numStr}`);
+    }
+    const isActive = account.email === currentEmail;
+    let line = `  ${index + 1}: ${account.email}`;
+    if (account.alias)
+      line += ` [${account.alias}]`;
+    if (isActive)
+      line += " (active)";
+    console.log(line);
+  });
+}
+async function cmdAdd(alias) {
+  setupDirectories();
+  await initSequenceFile(activeSequenceFile);
+  const currentAccount = activeProvider.getCurrentAccount();
+  const currentEmail = currentAccount?.email ?? "none";
+  if (currentEmail === "none") {
+    throw new Error(`No active ${getProviderLabel()} account found. Please log in first.`);
+  }
+  if (!sanitizeEmailForFilename(currentEmail)) {
+    throw new Error("Current account email is not safe for storage");
+  }
+  const seq = await loadSequence(activeSequenceFile);
+  await syncSequenceActiveAccount(seq);
+  if (accountExists(seq, currentEmail)) {
+    console.log(`Account ${currentEmail} is already managed.`);
+    return;
+  }
+  if (alias) {
+    const result = validateAlias(alias);
+    if (!result.valid) {
+      throw new Error(result.reason);
+    }
+    if (findAccountByAlias(seq, alias)) {
+      throw new Error(`Alias "${alias}" is already in use`);
+    }
+  }
+  const creds = await activeProvider.readActiveAuth();
+  if (!creds) {
+    throw new Error("No credentials found for current account");
+  }
+  let config = "";
+  let uuid = currentAccount?.accountId ?? "";
+  if (activeProvider.name === "claude") {
+    const configPath = getClaudeConfigPath();
+    config = readFileSync10(configPath, "utf-8");
+    const configObj = JSON.parse(config);
+    uuid = configObj.oauthAccount?.accountUuid ?? "";
+  }
+  const updated = addAccountToSequence(seq, {
+    email: currentEmail,
+    uuid,
+    alias
+  });
+  const accountNum = String(updated.activeAccountNumber);
+  const displayLabel = getDisplayAccountLabel(updated, accountNum);
+  await activeProvider.writeAccountAuth(accountNum, currentEmail, creds, activeCredentialsDir);
+  if (config) {
+    await activeProvider.writeAccountConfig(accountNum, currentEmail, config, activeConfigsDir);
+  }
+  await writeJsonAtomic2(activeSequenceFile, updated);
+  const aliasStr = alias ? ` [${alias}]` : "";
+  console.log(`Added ${displayLabel}: ${currentEmail}${aliasStr}`);
+}
+async function cmdRemove(identifier) {
+  if (!existsSync10(activeSequenceFile)) {
+    throw new Error("No accounts managed yet");
+  }
+  const seq = await loadSequence(activeSequenceFile);
+  await syncSequenceActiveAccount(seq);
+  let accountNum;
+  if (!identifier) {
+    accountNum = await pickAccountForRemoval(seq);
+  } else {
+    if (/^\d+$/.test(identifier)) {
+      throw new Error("Remove target must be an email, not a number");
+    }
+    const resolved = resolveAccountIdentifier(seq, identifier);
+    if (!resolved) {
+      throw new Error(`Account not found: ${identifier}`);
+    }
+    accountNum = resolved;
+  }
+  const account = seq.accounts[accountNum];
+  if (!account) {
+    throw new Error(`${getDisplayAccountLabel(seq, accountNum)} does not exist`);
+  }
+  if (seq.activeAccountNumber === Number(accountNum)) {
+    console.log(`Warning: ${getDisplayAccountLabel(seq, accountNum)} (${account.email}) is currently active`);
+  }
+  const confirmed = await confirmAction(`Permanently remove ${getDisplayAccountLabel(seq, accountNum)} (${account.email})?`);
+  if (!confirmed) {
+    console.log("Cancelled");
+    return;
+  }
+  const updated = removeAccountFromSequence(seq, accountNum);
+  const action = getPostRemovalAction(seq, updated, accountNum);
+  if (action.type === "switch") {
+    await performSwitch(seq, action.targetAccountNumber);
+  } else if (action.type === "logout") {
+    await activeProvider.clearActiveAuth();
+    if (activeProvider.name === "claude") {
+      await clearActiveOAuthAccount();
+    }
+  }
+  await activeProvider.deleteAccountAuth(accountNum, account.email, activeCredentialsDir);
+  activeProvider.deleteAccountConfig(accountNum, account.email, activeConfigsDir);
+  await writeJsonAtomic2(activeSequenceFile, updated);
+  console.log(`${getDisplayAccountLabel(seq, accountNum)} (${account.email}) has been removed`);
+}
+async function cmdNext() {
+  if (!existsSync10(activeSequenceFile)) {
+    throw new Error("No accounts managed yet");
+  }
+  const seq = await loadSequence(activeSequenceFile);
+  await syncSequenceActiveAccount(seq);
+  if (seq.sequence.length < 2) {
+    throw new Error("Need at least 2 accounts to rotate");
+  }
+  const nextNum = getNextInSequence(seq);
+  await performSwitch(seq, String(nextNum));
+}
+async function cmdStatus(options) {
+  const jsonMode = options?.json ?? false;
+  const email = getCurrentAccount();
+  let alias = null;
+  let managed = false;
+  if (email !== "none" && existsSync10(activeSequenceFile)) {
+    const seq = await loadSequence(activeSequenceFile);
+    for (const account of Object.values(seq.accounts)) {
+      if (account.email === email) {
+        managed = true;
+        alias = account.alias ?? null;
+        break;
+      }
+    }
+  }
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      provider: activeProvider.name,
+      email: email === "none" ? null : email,
+      alias,
+      managed
+    }));
+    return;
+  }
+  if (email === "none") {
+    console.log("none");
+  } else {
+    if (alias) {
+      console.log(`${email} [${alias}]`);
+      return;
+    }
+    console.log(email);
+  }
+}
+async function cmdAlias(alias, identifier) {
+  if (!existsSync10(activeSequenceFile)) {
+    throw new Error("No accounts managed yet");
+  }
+  const result = validateAlias(alias);
+  if (!result.valid) {
+    throw new Error(result.reason);
+  }
+  const seq = await loadSequence(activeSequenceFile);
+  if (identifier && /^\d+$/.test(identifier)) {
+    throw new Error("Alias target must be an email, not a number");
+  }
+  const currentEmail = getCurrentAccount();
+  const accountNum = resolveAliasTargetAccount(seq, { identifier, currentEmail });
+  if (!accountNum) {
+    if (identifier) {
+      throw new Error(`Account not found: ${identifier}`);
+    } else if (currentEmail === "none") {
+      throw new Error(`No active ${getProviderLabel()} account found. Please log in first.`);
+    } else {
+      throw new Error(`Current account is not managed: ${currentEmail}`);
+    }
+  }
+  const updated = setAlias(seq, accountNum, alias);
+  await writeJsonAtomic2(activeSequenceFile, updated);
+  const account = updated.accounts[accountNum];
+  console.log(`Alias "${alias}" set for ${getDisplayAccountLabel(updated, accountNum)} (${account.email})`);
+}
+async function cmdInteractiveSwitch() {
+  const currentEmail = getCurrentAccount();
+  const hasSequence = existsSync10(activeSequenceFile);
+  const seq = hasSequence ? await loadSequence(activeSequenceFile) : null;
+  if (seq) {
+    await syncSequenceActiveAccount(seq);
+  }
+  if (!seq || seq.sequence.length === 0) {
+    const emptyStateChoices = [
+      {
+        name: `+ Add current logged-in account${currentEmail === "none" ? "" : ` (${currentEmail})`}`,
+        value: ADD_CURRENT_ACCOUNT_CHOICE
+      },
+      { name: "Back", value: "__back__" }
+    ];
+    const selected2 = await pickChoice(`No managed ${getProviderLabel()} accounts yet`, emptyStateChoices);
+    if (selected2 === "__back__") {
+      return;
+    }
+    await cmdAdd();
+    return;
+  }
+  const shouldOfferAddCurrent = currentEmail !== "none" && !accountExists(seq, currentEmail);
+  const extraChoices = shouldOfferAddCurrent ? [{ name: `+ Add current logged-in account (${currentEmail})`, value: ADD_CURRENT_ACCOUNT_CHOICE }] : [];
+  const selected = await pickAccount(seq, `caflip v${package_default.version} \u2014 Switch ${getProviderLabel()} account:`, undefined, extraChoices);
+  if (selected === ADD_CURRENT_ACCOUNT_CHOICE) {
+    await cmdAdd();
+    return;
+  }
+  await performSwitch(seq, selected, { currentEmail });
+}
+function showHelp() {
+  console.log(`caflip - Coding Agent Account Switch (Claude Code + Codex)
+
+Usage:
+  caflip
+  caflip <claude|codex> [command]
+
+Commands:
+  (no args)                            Interactive provider picker
+  <provider>                           Interactive account picker for provider
+  <provider> <alias>                   Switch by alias for provider
+  <provider> list                      List all managed accounts
+  <provider> add [--alias <name>]      Add current account
+  <provider> remove [<email>]          Remove an account
+  <provider> next                      Rotate to next account
+  <provider> status [--json]           Show current account
+  <provider> alias <name> [<email>]    Set alias for current or target account
+  help                                 Show this help
+
+Examples:
+  caflip                               Pick provider interactively
+  caflip claude                        Pick Claude account interactively
+  caflip claude work                   Switch Claude account by alias
+  caflip claude add --alias personal   Add current Claude account with alias
+  caflip claude status --json          Show Claude status as JSON
+  caflip codex list                    List managed Codex accounts
+  caflip codex add --alias work        Add current Codex account with alias
+  caflip codex alias work user@company.com
+                                       Set Codex alias for target email`);
+}
+async function main() {
+  const parsed = parseProviderArgs(process.argv.slice(2));
+  const provider = parsed.provider;
+  const args = parsed.commandArgs;
+  const command = args[0];
+  let lockHeld = false;
+  const runWithLock = async (fn) => {
+    setupDirectories();
+    acquireLock(activeLockDir);
+    lockHeld = true;
+    try {
+      return await fn();
+    } finally {
+      if (lockHeld) {
+        releaseLock(activeLockDir);
+        lockHeld = false;
+      }
+    }
+  };
+  const runWithProviderLock = async (targetProvider, fn) => {
+    setActiveProvider(targetProvider);
+    return await runWithLock(fn);
+  };
+  const isHelpCommand = command === "help" || command === "--help" || command === "-h";
+  if (!parsed.isProviderQualified && command && !isHelpCommand) {
+    if (RESERVED_COMMANDS.includes(command)) {
+      console.error("Error: Provider is required for non-interactive commands.");
+      console.error("Try: caflip claude list");
+      process.exit(2);
+    } else {
+      console.error("Error: Alias requires provider prefix.");
+      console.error("Try: caflip claude <alias> or caflip codex <alias>");
+      process.exit(2);
+    }
+  }
+  if (!command) {
+    if (!provider) {
+      const defaultProvider = readCliMeta().lastProvider;
+      const selectedProvider = await pickProvider(defaultProvider);
+      await writeLastProvider(selectedProvider);
+      await runWithProviderLock(selectedProvider, async () => {
+        await cmdInteractiveSwitch();
+      });
+      return;
+    }
+    await runWithProviderLock(provider, async () => {
+      await cmdInteractiveSwitch();
+    });
+    return;
+  }
+  if (isHelpCommand) {
+    showHelp();
+    return;
+  }
+  if (!provider) {
+    console.error("Error: Provider is required for non-interactive commands.");
+    console.error("Try: caflip claude list");
+    process.exit(2);
+  }
+  setActiveProvider(provider);
+  switch (command) {
+    case "list":
+      await cmdList();
+      break;
+    case "add": {
+      await runWithLock(async () => {
+        let alias;
+        const aliasIdx = args.indexOf("--alias");
+        if (aliasIdx !== -1 && args[aliasIdx + 1]) {
+          alias = args[aliasIdx + 1];
+        }
+        await cmdAdd(alias);
+      });
+      break;
+    }
+    case "remove": {
+      await runWithLock(async () => {
+        await cmdRemove(args[1]);
+      });
+      break;
+    }
+    case "next": {
+      await runWithLock(async () => {
+        await cmdNext();
+      });
+      break;
+    }
+    case "status":
+      await cmdStatus({ json: args.includes("--json") });
+      break;
+    case "alias": {
+      if (!args[1]) {
+        console.error("Usage: caflip alias <name> [<email>]");
+        process.exit(1);
+      }
+      await runWithLock(async () => {
+        await cmdAlias(args[1], args[2]);
+      });
+      break;
+    }
+    default: {
+      if (existsSync10(activeSequenceFile)) {
+        const seq = await loadSequence(activeSequenceFile);
+        const accountNum = findAccountByAlias(seq, command);
+        if (accountNum) {
+          await runWithLock(async () => {
+            await performSwitch(seq, accountNum);
+          });
+          return;
+        }
+      }
+      console.error(`Error: Unknown command "${command}"`);
+      showHelp();
+      process.exit(1);
+    }
+  }
+}
+if (__require.main == __require.module) {
+  main().catch((err) => {
+    if (err instanceof PromptCancelledError) {
+      console.log("Cancelled");
+      process.exit(0);
+    }
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}
+export {
+  performSwitch
+};