caflip 0.2.0 → 0.3.0

package/README.md

@@ -2,11 +2,12 @@
 
 A fast account switcher for coding agents like Claude Code and Codex.
 
-![caflip interactive account picker](./docs/demo.png)
+![caflip provider + account interactive flow](./docs/demo.png)
+Pick provider first, then switch account.
 
 caflip is built for one job: if you have multiple Claude or Codex accounts, switch between them quickly.
 
-Today, caflip focuses on Claude Code accounts. Your skills, settings, themes, `CLAUDE.md`, MCP servers, keybindings, and all other configuration stay exactly the same while switching accounts.
+Today, caflip supports both Claude Code and Codex accounts. Your skills, settings, themes, `CLAUDE.md`, MCP servers, keybindings, and all other configuration stay exactly the same while switching accounts.
 
 Use case: you have personal/work Claude or Codex accounts and want to switch quickly without re-login flows every time.
 
@@ -16,7 +17,7 @@ Use case: you have personal/work Claude or Codex accounts and want to switch qui
 | Platform | Credential Storage |
 |---|---|
 | macOS | System Keychain |
-| Linux | `secret-tool` keyring (preferred), file-based fallback (owner-only access) |
+| Linux | `CLAUDE_CONFIG_DIR/.credentials.json` when set, otherwise `~/.claude/.credentials.json`; `secret-tool` is kept as compatibility sync |
 | WSL | Same as Linux |
 | Windows | Not yet supported |
 
@@ -28,6 +29,12 @@ Use case: you have personal/work Claude or Codex accounts and want to switch qui
 curl -fsSL https://raw.githubusercontent.com/LucienLee/caflip/main/install.sh | bash
 ```
 
+To uninstall the standalone binary installed by this script:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/LucienLee/caflip/main/uninstall.sh | bash
+```
+
 ### Via npm (Node.js)
 
 ```bash
@@ -40,6 +47,13 @@ npm install -g caflip
 bun install -g caflip
 ```
 
+For package-manager installs, uninstall with the same package manager:
+
+```bash
+npm uninstall -g caflip
+bun remove -g caflip
+```
+
 ### Local Development
 
 ```bash
@@ -49,6 +63,10 @@ bun run dev -- help
 ## Quick Start
 
 ```bash
+# Show current account / managed accounts across both providers
+caflip status
+caflip list
+
 # Add your first Claude account (must already be logged in)
 caflip claude add --alias personal
 
@@ -69,6 +87,14 @@ caflip claude next
 caflip codex add --alias codex-work
 caflip codex list
 caflip codex next
+
+# Run official provider login through caflip, then register the session
+caflip claude login
+caflip codex login
+
+# Pass provider-specific flags after --
+caflip claude login -- --email lucien@aibor.io --sso
+caflip codex login -- --device-auth
 ```
 
 After switching, restart the target CLI (Claude Code or Codex) to pick up new authentication.
@@ -78,12 +104,15 @@ After switching, restart the target CLI (Claude Code or Codex) to pick up new au
 | Command | Description |
 |---|---|
 | `caflip` | Interactive provider picker (Claude/Codex) |
+| `caflip list` | List managed accounts for Claude and Codex |
+| `caflip status` | Show current account for Claude and Codex |
 | `caflip claude [command]` | Run command for Claude provider |
 | `caflip codex [command]` | Run command for Codex provider |
 | `caflip [provider]` | Interactive account picker for that provider |
 | `caflip [provider] <alias>` | Switch by alias for that provider |
 | `caflip [provider] list` | List managed accounts |
 | `caflip [provider] add [--alias name]` | Add current account |
+| `caflip [provider] login [-- <args...>]` | Run provider login and register the resulting session |
 | `caflip [provider] remove [email]` | Remove an account |
 | `caflip [provider] next` | Rotate to next account |
 | `caflip [provider] status` | Show current account |
@@ -105,6 +134,14 @@ caflip codex alias work me@company.com
 
 `remove` target accepts email only. Omit it to choose from the interactive picker.
 
+`login` can be used without arguments for the default login flow. Pass provider-specific flags after `--`:
+
+```bash
+caflip claude login
+caflip claude login -- --email lucien@aibor.io --sso
+caflip codex login -- --device-auth
+```
+
 ## Shell Prompt Integration
 
 Show the current account in your prompt:
@@ -119,6 +156,10 @@ Account data lives in:
 - `~/.caflip-backup/claude/`
 - `~/.caflip-backup/codex/`
 
+On Linux and WSL, caflip follows Claude's config root for active Claude credentials and config:
+- if `CLAUDE_CONFIG_DIR` is set, caflip reads `"$CLAUDE_CONFIG_DIR/.credentials.json"` and `"$CLAUDE_CONFIG_DIR/.claude.json"`
+- otherwise it falls back to `~/.claude/.credentials.json` and then Claude's standard config lookup
+
 ## Credits
 
 Inspired by [cc-account-switcher](https://github.com/ming86/cc-account-switcher).

package/dist/cli.js

@@ -181,11 +181,10 @@ var require_lib = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync9, 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);
@@ -212,38 +211,26 @@ var RESERVED_COMMANDS = [
   "add",
   "remove",
   "next",
+  "login",
   "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";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 
 // src/files.ts
-import { existsSync as existsSync2, mkdirSync, rmSync, chmodSync, renameSync, writeFileSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync, mkdirSync, rmSync, chmodSync, renameSync, writeFileSync, readFileSync } 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)) {
+  if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
   chmodSync(dir, 448);
@@ -262,7 +249,7 @@ async function writeJsonAtomic(filePath, data) {
 
 // src/accounts.ts
 async function initSequenceFile(path) {
-  if (existsSync3(path))
+  if (existsSync2(path))
     return;
   const data = {
     activeAccountNumber: null,
@@ -273,7 +260,7 @@ async function initSequenceFile(path) {
   await writeJsonAtomic(path, data);
 }
 async function loadSequence(path) {
-  return JSON.parse(readFileSync3(path, "utf-8"));
+  return JSON.parse(readFileSync2(path, "utf-8"));
 }
 function getNextAccountNumber(seq) {
   const keys = Object.keys(seq.accounts).map(Number);
@@ -422,14 +409,14 @@ function findAccountByAlias(seq, alias) {
 }
 
 // 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 { existsSync as existsSync3, mkdirSync as mkdirSync2, rmSync as rmSync2, chmodSync as chmodSync2, renameSync as renameSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3 } 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)) {
+  if (!existsSync3(dir)) {
     mkdirSync2(dir, { recursive: true, mode: 448 });
   }
   chmodSync2(dir, 448);
@@ -447,7 +434,7 @@ async function writeJsonAtomic2(filePath, data) {
 }
 function acquireLock(lockDir) {
   const parentDir = dirname2(lockDir);
-  if (!existsSync4(parentDir)) {
+  if (!existsSync3(parentDir)) {
     mkdirSync2(parentDir, { recursive: true, mode: 448 });
   }
   try {
@@ -490,11 +477,11 @@ function writeLockOwner(lockDir) {
 }
 function isStaleLock(lockDir) {
   const ownerPath = getLockOwnerPath(lockDir);
-  if (!existsSync4(ownerPath)) {
+  if (!existsSync3(ownerPath)) {
     return true;
   }
   try {
-    const owner = JSON.parse(readFileSync4(ownerPath, "utf-8"));
+    const owner = JSON.parse(readFileSync3(ownerPath, "utf-8"));
     if (!owner.pid || !Number.isInteger(owner.pid) || owner.pid <= 0) {
       return true;
     }
@@ -521,7 +508,7 @@ function isProcessAlive(pid) {
 
 // src/config.ts
 import { homedir as homedir2 } from "os";
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { join as join4 } from "path";
 function getBackupDir2(provider) {
   return join4(homedir2(), ".caflip-backup", provider);
@@ -548,6 +535,7 @@ var RESERVED_COMMANDS2 = [
   "add",
   "remove",
   "next",
+  "login",
   "status",
   "alias",
   "claude",
@@ -566,12 +554,23 @@ function detectPlatform() {
       return "unknown";
   }
 }
-function getClaudeConfigPath2() {
-  const primary = join4(homedir2(), ".claude", ".claude.json");
-  const fallback = join4(homedir2(), ".claude.json");
-  if (existsSync5(primary)) {
+function getClaudeConfigDir(env = process.env, home = homedir2()) {
+  const customDir = env.CLAUDE_CONFIG_DIR?.trim();
+  if (customDir) {
+    return customDir;
+  }
+  return join4(home, ".claude");
+}
+function getClaudeConfigPath(env = process.env, home = homedir2()) {
+  const customDir = env.CLAUDE_CONFIG_DIR?.trim();
+  if (customDir) {
+    return join4(customDir, ".claude.json");
+  }
+  const primary = join4(getClaudeConfigDir(env, home), ".claude.json");
+  const fallback = join4(home, ".claude.json");
+  if (existsSync4(primary)) {
     try {
-      const content = JSON.parse(readFileSync5(primary, "utf-8"));
+      const content = JSON.parse(readFileSync4(primary, "utf-8"));
       if (content.oauthAccount) {
         return primary;
       }
@@ -618,7 +617,7 @@ function validateAlias(alias) {
 // package.json
 var package_default = {
   name: "caflip",
-  version: "0.2.0",
+  version: "0.3.0",
   type: "module",
   bin: {
     caflip: "bin/caflip"
@@ -2368,6 +2367,25 @@ async function confirmAction(message, promptConfirm = dist_default4) {
   return wrapPromptCancellation(() => promptConfirm({ message, default: false }));
 }
 
+// src/login/runner.ts
+import { spawn } from "child_process";
+async function runLoginCommand(command) {
+  return await new Promise((resolve, reject) => {
+    const proc = spawn(command[0], command.slice(1), {
+      stdio: "inherit"
+    });
+    proc.on("error", (error) => {
+      reject(error);
+    });
+    proc.on("close", (code, signal) => {
+      resolve({
+        exitCode: code ?? 1,
+        signal
+      });
+    });
+  });
+}
+
 // src/providers/types.ts
 var SUPPORTED_PROVIDERS = ["claude", "codex"];
 function isProviderName(value) {
@@ -2384,13 +2402,13 @@ function parseProviderArgs(args) {
 }
 
 // src/providers/claude.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } 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 { existsSync as existsSync5, readFileSync as readFileSync5, 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";
+import { spawn as spawn2, spawnSync } from "child_process";
 
 // src/validation.ts
 var EMAIL_REGEX2 = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
@@ -2416,7 +2434,7 @@ async function runCommand(cmd) {
 }
 async function runCommandWithInput(cmd, input) {
   return await new Promise((resolve, reject) => {
-    const proc = spawn(cmd[0], cmd.slice(1), {
+    const proc = spawn2(cmd[0], cmd.slice(1), {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";
@@ -2464,6 +2482,16 @@ function activeSecretToolAttrs() {
 function backupSecretToolAttrs(accountNum, email) {
   return ["service", "ccflip", "account", accountNum, "email", email];
 }
+function getClaudeCredentialsDir(env = process.env, home = homedir3()) {
+  const customDir = env.CLAUDE_CONFIG_DIR?.trim();
+  if (customDir) {
+    return customDir;
+  }
+  return join5(home, ".claude");
+}
+function getClaudeCredentialsPath(env = process.env, home = homedir3()) {
+  return join5(getClaudeCredentialsDir(env, home), ".credentials.json");
+}
 async function secretToolLookup(attrs) {
   const result = await runCommand(["secret-tool", "lookup", ...attrs]);
   if (result.exitCode === 0) {
@@ -2507,16 +2535,16 @@ async function readCredentials() {
     }
     case "linux":
     case "wsl": {
+      const credPath = getClaudeCredentialsPath();
+      if (existsSync5(credPath)) {
+        return readFileSync5(credPath, "utf-8");
+      }
       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:
@@ -2545,16 +2573,15 @@ async function writeCredentials(credentials) {
     }
     case "linux":
     case "wsl": {
-      if (hasSecretTool()) {
-        await secretToolStore(activeSecretToolAttrs(), credentials);
-        return;
-      }
-      const claudeDir = join5(homedir3(), ".claude");
+      const claudeDir = getClaudeCredentialsDir();
       mkdirSync3(claudeDir, { recursive: true, mode: 448 });
       chmodSync3(claudeDir, 448);
-      const credPath = join5(claudeDir, ".credentials.json");
+      const credPath = getClaudeCredentialsPath();
       writeFileSync3(credPath, credentials, { mode: 384 });
       chmodSync3(credPath, 384);
+      if (hasSecretTool()) {
+        await secretToolStore(activeSecretToolAttrs(), credentials);
+      }
       break;
     }
   }
@@ -2576,11 +2603,11 @@ async function clearActiveCredentials() {
     }
     case "linux":
     case "wsl": {
+      const credPath = getClaudeCredentialsPath();
+      rmSync3(credPath, { force: true });
       if (hasSecretTool()) {
         await secretToolClear(activeSecretToolAttrs());
       }
-      const credPath = join5(homedir3(), ".claude", ".credentials.json");
-      rmSync3(credPath, { force: true });
       break;
     }
   }
@@ -2617,8 +2644,8 @@ async function readAccountCredentials(accountNum, email, credentialsDir = CREDEN
         }
       }
       const credFile = join5(credentialsDir, `.claude-credentials-${accountNum}-${email}.json`);
-      if (existsSync6(credFile)) {
-        return readFileSync6(credFile, "utf-8");
+      if (existsSync5(credFile)) {
+        return readFileSync5(credFile, "utf-8");
       }
       return "";
     }
@@ -2701,8 +2728,8 @@ function readAccountConfig(accountNum, email, configsDir) {
     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");
+  if (existsSync5(configFile)) {
+    return readFileSync5(configFile, "utf-8");
   }
   return "";
 }
@@ -2725,6 +2752,191 @@ function deleteAccountConfig(accountNum, email, configsDir) {
   rmSync3(configFile, { force: true });
 }
 
+// src/login/runner.ts
+import { spawn as spawn3 } from "child_process";
+var DEFAULT_CAPTURE_TIMEOUT_MS = 5000;
+function normalizeOutput(value) {
+  return value.trim();
+}
+async function runCapturedCommand(command, options) {
+  return await new Promise((resolve, reject) => {
+    const proc = spawn3(command[0], command.slice(1), {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_CAPTURE_TIMEOUT_MS;
+    const timer = setTimeout(() => {
+      proc.kill("SIGTERM");
+    }, timeoutMs);
+    proc.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    proc.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    proc.on("close", (code, signal) => {
+      clearTimeout(timer);
+      if (signal === "SIGTERM") {
+        resolve({
+          exitCode: 124,
+          stdout: normalizeOutput(stdout),
+          stderr: normalizeOutput(stderr) || `command timed out after ${timeoutMs}ms`,
+          signal
+        });
+        return;
+      }
+      resolve({
+        exitCode: code ?? 1,
+        stdout: normalizeOutput(stdout),
+        stderr: normalizeOutput(stderr),
+        signal
+      });
+    });
+  });
+}
+
+// src/providers/claude.ts
+function readClaudeConfigObject() {
+  const configPath = getClaudeConfigPath();
+  if (!existsSync6(configPath))
+    return null;
+  try {
+    return JSON.parse(readFileSync6(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getClaudeCurrentAccount() {
+  const content = readClaudeConfigObject();
+  const email = content?.oauthAccount?.emailAddress;
+  if (typeof email !== "string" || !email) {
+    return null;
+  }
+  const accountId = typeof content?.oauthAccount?.accountUuid === "string" ? content.oauthAccount.accountUuid : undefined;
+  return { email, accountId };
+}
+function getClaudeCurrentAccountEmail() {
+  return getClaudeCurrentAccount()?.email ?? "none";
+}
+async function readClaudeActiveConfig() {
+  const configPath = getClaudeConfigPath();
+  if (!existsSync6(configPath)) {
+    return "";
+  }
+  try {
+    return readFileSync6(configPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function writeClaudeActiveConfig(raw) {
+  let targetConfig;
+  try {
+    targetConfig = JSON.parse(raw);
+  } catch {
+    throw new Error("Invalid Claude config backup");
+  }
+  const oauthAccount = targetConfig.oauthAccount;
+  if (!oauthAccount) {
+    throw new Error("Invalid oauthAccount in backup");
+  }
+  const configPath = getClaudeConfigPath();
+  let currentConfigObj = {};
+  if (existsSync6(configPath)) {
+    try {
+      currentConfigObj = JSON.parse(readFileSync6(configPath, "utf-8"));
+    } catch {
+      currentConfigObj = {};
+    }
+  }
+  currentConfigObj.oauthAccount = oauthAccount;
+  await writeJsonAtomic(configPath, currentConfigObj);
+}
+async function clearClaudeActiveConfig() {
+  const configPath = getClaudeConfigPath();
+  let configObj = {};
+  if (existsSync6(configPath)) {
+    try {
+      configObj = JSON.parse(readFileSync6(configPath, "utf-8"));
+    } catch {
+      configObj = {};
+    }
+  }
+  delete configObj.oauthAccount;
+  await writeJsonAtomic(configPath, configObj);
+}
+async function verifyClaudeLogin(commandRunner = runCapturedCommand) {
+  const result = await commandRunner(["claude", "auth", "status", "--json"]);
+  if (result.exitCode !== 0) {
+    return {
+      ok: false,
+      reason: result.stderr || "claude auth status failed"
+    };
+  }
+  let payload;
+  try {
+    payload = JSON.parse(result.stdout);
+  } catch {
+    return {
+      ok: false,
+      reason: "claude auth status returned invalid JSON"
+    };
+  }
+  if (payload.loggedIn !== true) {
+    return {
+      ok: false,
+      reason: "claude auth status reported logged out",
+      details: {
+        loggedIn: payload.loggedIn ?? false
+      }
+    };
+  }
+  if (!payload.email) {
+    return {
+      ok: false,
+      reason: "claude auth status did not include an email"
+    };
+  }
+  return {
+    ok: true,
+    email: payload.email,
+    details: {
+      authMethod: payload.authMethod,
+      orgId: payload.orgId,
+      orgName: payload.orgName,
+      subscriptionType: payload.subscriptionType
+    }
+  };
+}
+var claudeLoginAdapter = {
+  buildCommand: (passthroughArgs) => ["claude", "auth", "login", ...passthroughArgs],
+  verifyLogin: verifyClaudeLogin
+};
+var claudeProvider = {
+  name: "claude",
+  login: claudeLoginAdapter,
+  usesAccountConfig: true,
+  getCurrentAccount: getClaudeCurrentAccount,
+  getCurrentAccountEmail: getClaudeCurrentAccountEmail,
+  readActiveAuth: readCredentials,
+  writeActiveAuth: writeCredentials,
+  clearActiveAuth: clearActiveCredentials,
+  readActiveConfig: readClaudeActiveConfig,
+  writeActiveConfig: writeClaudeActiveConfig,
+  clearActiveConfig: clearClaudeActiveConfig,
+  readAccountAuth: readAccountCredentials,
+  writeAccountAuth: writeAccountCredentials,
+  deleteAccountAuth: deleteAccountCredentials,
+  readAccountConfig,
+  writeAccountConfig,
+  deleteAccountConfig
+};
+
 // 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";
@@ -2758,7 +2970,11 @@ async function readCodexActiveAuth() {
   if (!existsSync7(authPath)) {
     return "";
   }
-  return readFileSync7(authPath, "utf-8");
+  try {
+    return readFileSync7(authPath, "utf-8");
+  } catch {
+    return "";
+  }
 }
 async function writeCodexActiveAuth(raw) {
   const codexDir = join6(process.env.HOME ?? homedir4(), ".codex");
@@ -2777,7 +2993,11 @@ async function readCodexAccountAuthBackup(accountNum, email, credentialsDir) {
   if (!existsSync7(backupPath)) {
     return "";
   }
-  return readFileSync7(backupPath, "utf-8");
+  try {
+    return readFileSync7(backupPath, "utf-8");
+  } catch {
+    return "";
+  }
 }
 async function writeCodexAccountAuthBackup(accountNum, email, raw, credentialsDir) {
   ensureBackupKeySafe(accountNum, email);
@@ -2821,45 +3041,79 @@ function getCodexCurrentAccount() {
     return null;
   }
 }
-
-// src/providers/claude.ts
-function getClaudeCurrentAccountEmail() {
-  const configPath = getClaudeConfigPath2();
-  if (!existsSync8(configPath))
-    return "none";
+function readCodexAuthFile() {
+  const authPath = getCodexAuthPath();
+  if (!existsSync7(authPath)) {
+    return null;
+  }
   try {
-    const content = JSON.parse(readFileSync8(configPath, "utf-8"));
-    return content?.oauthAccount?.emailAddress ?? "none";
+    return JSON.parse(readFileSync7(authPath, "utf-8"));
   } catch {
-    return "none";
+    return null;
   }
 }
-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
+async function verifyCodexLogin(commandRunner = runCapturedCommand) {
+  const result = await commandRunner(["codex", "login", "status"]);
+  if (result.exitCode !== 0) {
+    return {
+      ok: false,
+      reason: result.stderr || "codex login status failed"
+    };
+  }
+  const authFile = readCodexAuthFile();
+  if (!authFile) {
+    return {
+      ok: false,
+      reason: "codex auth file was missing or unreadable after successful login status"
+    };
+  }
+  if (authFile.OPENAI_API_KEY) {
+    return {
+      ok: false,
+      reason: "caflip does not support Codex API key login sessions",
+      details: {
+        authMode: authFile.auth_mode ?? "apikey"
+      }
+    };
+  }
+  if (authFile.auth_mode && authFile.auth_mode !== "chatgpt") {
+    return {
+      ok: false,
+      reason: `caflip does not support Codex ${authFile.auth_mode} login sessions`,
+      details: {
+        authMode: authFile.auth_mode
+      }
+    };
+  }
+  const currentAccount = getCodexCurrentAccount();
+  if (!currentAccount?.email) {
+    return {
+      ok: false,
+      reason: "codex auth file did not resolve a current account email"
+    };
+  }
+  return {
+    ok: true,
+    email: currentAccount.email,
+    details: currentAccount.accountId ? { accountId: currentAccount.accountId } : undefined
+  };
+}
+var codexLoginAdapter = {
+  buildCommand: (passthroughArgs) => ["codex", "login", ...passthroughArgs],
+  verifyLogin: verifyCodexLogin
 };
 var codexProvider = {
   name: "codex",
+  login: codexLoginAdapter,
+  usesAccountConfig: false,
   getCurrentAccount: getCodexCurrentAccount,
   getCurrentAccountEmail: () => getCodexCurrentAccount()?.email ?? "none",
   readActiveAuth: readCodexActiveAuth,
   writeActiveAuth: writeCodexActiveAuth,
   clearActiveAuth: clearCodexActiveAuth,
+  readActiveConfig: async () => "",
+  writeActiveConfig: async () => {},
+  clearActiveConfig: async () => {},
   readAccountAuth: readCodexAccountAuthBackup,
   writeAccountAuth: writeCodexAccountAuthBackup,
   deleteAccountAuth: deleteCodexAccountAuthBackup,
@@ -2878,7 +3132,7 @@ function getProvider(name) {
 }
 
 // src/meta.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
 import { mkdirSync as mkdirSync5 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join7 } from "path";
@@ -2888,11 +3142,11 @@ function getMetaFilePath() {
 }
 function readCliMeta() {
   const metaFile = getMetaFilePath();
-  if (!existsSync9(metaFile)) {
+  if (!existsSync8(metaFile)) {
     return { lastProvider: "claude" };
   }
   try {
-    const parsed = JSON.parse(readFileSync9(metaFile, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(metaFile, "utf-8"));
     if (parsed.lastProvider === "codex") {
       return { lastProvider: "codex" };
     }
@@ -2937,18 +3191,10 @@ function getCurrentAccount() {
 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);
+function showProviderRequiredError(command) {
+  console.error(`Error: ${command} requires provider prefix.`);
+  console.error(`Try: caflip claude ${command} or caflip codex ${command}`);
+  process.exit(2);
 }
 async function syncSequenceActiveAccount(seq) {
   const currentEmail = getCurrentAccount();
@@ -2960,6 +3206,108 @@ async function syncSequenceActiveAccount(seq) {
   }
   return seq;
 }
+async function registerCurrentActiveAccount(options) {
+  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");
+  }
+  if (options?.expectedEmail && currentEmail !== options.expectedEmail) {
+    throw new Error(`Active ${getProviderLabel()} account changed during login verification: expected ${options.expectedEmail}, got ${currentEmail}`);
+  }
+  setupDirectories();
+  await initSequenceFile(activeSequenceFile);
+  const seq = await loadSequence(activeSequenceFile);
+  await syncSequenceActiveAccount(seq);
+  if (options?.alias) {
+    const result = validateAlias(options.alias);
+    if (!result.valid) {
+      throw new Error(result.reason);
+    }
+    const existingAliasTarget = findAccountByAlias(seq, options.alias);
+    const currentAccountNum = resolveAccountIdentifier(seq, currentEmail);
+    if (existingAliasTarget && existingAliasTarget !== currentAccountNum) {
+      throw new Error(`Alias "${options.alias}" is already in use`);
+    }
+  }
+  const existingAccountNum = resolveAccountIdentifier(seq, currentEmail);
+  if (existingAccountNum) {
+    if (!options?.updateIfExists) {
+      console.log(`Account ${currentEmail} is already managed.`);
+      return {
+        action: "unchanged",
+        accountNum: existingAccountNum,
+        email: currentEmail
+      };
+    }
+  }
+  const creds = await activeProvider.readActiveAuth();
+  if (!creds) {
+    throw new Error("No credentials found for current account");
+  }
+  const config = await activeProvider.readActiveConfig();
+  let uuid = currentAccount?.accountId ?? "";
+  if (activeProvider.usesAccountConfig && !config) {
+    throw new Error("No config found for current account");
+  }
+  if (existingAccountNum) {
+    const updatedSeq = {
+      ...seq,
+      activeAccountNumber: Number(existingAccountNum),
+      lastUpdated: new Date().toISOString(),
+      accounts: {
+        ...seq.accounts,
+        [existingAccountNum]: {
+          ...seq.accounts[existingAccountNum],
+          uuid,
+          ...options?.alias ? { alias: options.alias } : {}
+        }
+      }
+    };
+    await activeProvider.writeAccountAuth(existingAccountNum, currentEmail, creds, activeCredentialsDir);
+    if (config) {
+      await activeProvider.writeAccountConfig(existingAccountNum, currentEmail, config, activeConfigsDir);
+    }
+    await writeJsonAtomic2(activeSequenceFile, updatedSeq);
+    return {
+      action: "updated",
+      accountNum: existingAccountNum,
+      email: currentEmail
+    };
+  }
+  const updated = addAccountToSequence(seq, {
+    email: currentEmail,
+    uuid,
+    alias: options?.alias
+  });
+  const accountNum = String(updated.activeAccountNumber);
+  await activeProvider.writeAccountAuth(accountNum, currentEmail, creds, activeCredentialsDir);
+  if (config) {
+    await activeProvider.writeAccountConfig(accountNum, currentEmail, config, activeConfigsDir);
+  }
+  await writeJsonAtomic2(activeSequenceFile, updated);
+  return {
+    action: "added",
+    accountNum,
+    email: currentEmail
+  };
+}
+function getLoginPassthroughArgs(args) {
+  const passthroughIdx = args.indexOf("--");
+  if (passthroughIdx === -1) {
+    if (args.length > 0) {
+      throw new Error("Provider login arguments must be passed after --");
+    }
+    return [];
+  }
+  if (passthroughIdx !== 0) {
+    throw new Error("Provider login arguments must be passed after --");
+  }
+  return args.slice(passthroughIdx + 1);
+}
 async function performSwitch(seq, targetAccount, options) {
   const targetEmail = seq.accounts[targetAccount].email;
   const currentEmail = options?.currentEmail ?? getCurrentAccount();
@@ -2987,9 +3335,8 @@ async function performSwitch(seq, targetAccount, options) {
     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 (activeProvider.usesAccountConfig) {
+      const currentConfig = await activeProvider.readActiveConfig();
       if (currentConfig) {
         await activeProvider.writeAccountConfig(currentAccount, currentEmail, currentConfig, activeConfigsDir);
       }
@@ -3000,23 +3347,12 @@ async function performSwitch(seq, targetAccount, options) {
   if (!targetCreds) {
     throw new Error(`Missing backup data for ${getDisplayAccountLabel(seq, targetAccount)}`);
   }
-  if (activeProvider.name === "claude" && !targetConfig) {
+  if (activeProvider.usesAccountConfig && !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);
+  if (targetConfig) {
+    await activeProvider.writeActiveConfig(targetConfig);
   }
   seq.activeAccountNumber = Number(targetAccount);
   seq.lastUpdated = new Date().toISOString();
@@ -3030,16 +3366,25 @@ Please restart ${getProviderLabel()} to use the new authentication.
 `);
 }
 async function cmdList() {
-  if (!existsSync10(activeSequenceFile)) {
+  const lines = await getManagedAccountLinesForActiveProvider();
+  if (!lines) {
     const providerCmd = activeProvider.name === "codex" ? "caflip codex add" : "caflip claude add";
     console.log(`No accounts managed yet. Run: ${providerCmd}`);
     return;
   }
+  console.log("Accounts:");
+  for (const line of lines) {
+    console.log(line);
+  }
+}
+async function getManagedAccountLinesForActiveProvider() {
+  if (!existsSync9(activeSequenceFile)) {
+    return null;
+  }
   const seq = await loadSequence(activeSequenceFile);
   await syncSequenceActiveAccount(seq);
   const currentEmail = getCurrentAccount();
-  console.log("Accounts:");
-  seq.sequence.forEach((num, index) => {
+  return seq.sequence.map((num, index) => {
     const numStr = String(num);
     const account = seq.accounts[numStr];
     if (!account) {
@@ -3051,64 +3396,44 @@ async function cmdList() {
       line += ` [${account.alias}]`;
     if (isActive)
       line += " (active)";
-    console.log(line);
+    return 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.`);
+  const result = await registerCurrentActiveAccount({ alias, updateIfExists: false });
+  if (result.action === "unchanged") {
     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 seq = await loadSequence(activeSequenceFile);
+  const displayLabel = getDisplayAccountLabel(seq, result.accountNum);
   const aliasStr = alias ? ` [${alias}]` : "";
-  console.log(`Added ${displayLabel}: ${currentEmail}${aliasStr}`);
+  console.log(`Added ${displayLabel}: ${result.email}${aliasStr}`);
+}
+async function cmdLogin(args) {
+  const passthroughArgs = getLoginPassthroughArgs(args);
+  const loginCommand = activeProvider.login.buildCommand(passthroughArgs);
+  const execution = await runLoginCommand(loginCommand);
+  if (execution.exitCode !== 0) {
+    throw new Error(`${getProviderLabel()} login failed`);
+  }
+  const verification = await activeProvider.login.verifyLogin();
+  if (!verification.ok) {
+    throw new Error(verification.reason);
+  }
+  const result = await registerCurrentActiveAccount({
+    updateIfExists: true,
+    expectedEmail: verification.email
+  });
+  const seq = await loadSequence(activeSequenceFile);
+  const displayLabel = getDisplayAccountLabel(seq, result.accountNum);
+  const verb = result.action === "added" ? "Added" : "Updated";
+  console.log(`${verb} ${displayLabel}: ${result.email}`);
+}
+function validateLoginArgs(args) {
+  getLoginPassthroughArgs(args);
 }
 async function cmdRemove(identifier) {
-  if (!existsSync10(activeSequenceFile)) {
+  if (!existsSync9(activeSequenceFile)) {
     throw new Error("No accounts managed yet");
   }
   const seq = await loadSequence(activeSequenceFile);
@@ -3144,9 +3469,7 @@ async function cmdRemove(identifier) {
     await performSwitch(seq, action.targetAccountNumber);
   } else if (action.type === "logout") {
     await activeProvider.clearActiveAuth();
-    if (activeProvider.name === "claude") {
-      await clearActiveOAuthAccount();
-    }
+    await activeProvider.clearActiveConfig();
   }
   await activeProvider.deleteAccountAuth(accountNum, account.email, activeCredentialsDir);
   activeProvider.deleteAccountConfig(accountNum, account.email, activeConfigsDir);
@@ -3154,7 +3477,7 @@ async function cmdRemove(identifier) {
   console.log(`${getDisplayAccountLabel(seq, accountNum)} (${account.email}) has been removed`);
 }
 async function cmdNext() {
-  if (!existsSync10(activeSequenceFile)) {
+  if (!existsSync9(activeSequenceFile)) {
     throw new Error("No accounts managed yet");
   }
   const seq = await loadSequence(activeSequenceFile);
@@ -3166,11 +3489,32 @@ async function cmdNext() {
   await performSwitch(seq, String(nextNum));
 }
 async function cmdStatus(options) {
+  const summary = await getStatusSummaryForActiveProvider();
   const jsonMode = options?.json ?? false;
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      provider: activeProvider.name,
+      email: summary.email === "none" ? null : summary.email,
+      alias: summary.alias,
+      managed: summary.managed
+    }));
+    return;
+  }
+  if (summary.email === "none") {
+    console.log("none");
+  } else {
+    if (summary.alias) {
+      console.log(`${summary.email} [${summary.alias}]`);
+      return;
+    }
+    console.log(summary.email);
+  }
+}
+async function getStatusSummaryForActiveProvider() {
   const email = getCurrentAccount();
   let alias = null;
   let managed = false;
-  if (email !== "none" && existsSync10(activeSequenceFile)) {
+  if (email !== "none" && existsSync9(activeSequenceFile)) {
     const seq = await loadSequence(activeSequenceFile);
     for (const account of Object.values(seq.accounts)) {
       if (account.email === email) {
@@ -3180,27 +3524,67 @@ async function cmdStatus(options) {
       }
     }
   }
-  if (jsonMode) {
-    console.log(JSON.stringify({
-      provider: activeProvider.name,
-      email: email === "none" ? null : email,
-      alias,
-      managed
-    }));
-    return;
+  return { email, alias, managed };
+}
+async function withActiveProvider(provider, fn) {
+  const previousProvider = activeProvider.name;
+  setActiveProvider(provider);
+  try {
+    return await fn();
+  } finally {
+    setActiveProvider(previousProvider);
   }
-  if (email === "none") {
-    console.log("none");
-  } else {
-    if (alias) {
-      console.log(`${email} [${alias}]`);
-      return;
+}
+async function cmdListAllProviders() {
+  for (const [index, provider] of SUPPORTED_PROVIDERS.entries()) {
+    const output = await withActiveProvider(provider, async () => {
+      const heading = getProviderLabel();
+      const lines = await getManagedAccountLinesForActiveProvider();
+      if (!lines) {
+        return {
+          heading,
+          lines: [`No accounts managed yet. Run: caflip ${provider} add`]
+        };
+      }
+      return {
+        heading,
+        lines: ["Accounts:", ...lines.map((line) => line.slice(2))]
+      };
+    });
+    if (index > 0) {
+      console.log("");
     }
-    console.log(email);
+    console.log(output.heading);
+    for (const line of output.lines) {
+      console.log(`  ${line}`);
+    }
+  }
+}
+async function cmdStatusAllProviders() {
+  for (const [index, provider] of SUPPORTED_PROVIDERS.entries()) {
+    const summary = await withActiveProvider(provider, async () => {
+      return {
+        heading: getProviderLabel(),
+        ...await getStatusSummaryForActiveProvider()
+      };
+    });
+    if (index > 0) {
+      console.log("");
+    }
+    console.log(summary.heading);
+    if (summary.email === "none") {
+      console.log("  none");
+      continue;
+    }
+    if (summary.alias) {
+      console.log(`  ${summary.email} [${summary.alias}]`);
+      continue;
+    }
+    console.log(`  ${summary.email}`);
   }
 }
 async function cmdAlias(alias, identifier) {
-  if (!existsSync10(activeSequenceFile)) {
+  if (!existsSync9(activeSequenceFile)) {
     throw new Error("No accounts managed yet");
   }
   const result = validateAlias(alias);
@@ -3229,7 +3613,7 @@ async function cmdAlias(alias, identifier) {
 }
 async function cmdInteractiveSwitch() {
   const currentEmail = getCurrentAccount();
-  const hasSequence = existsSync10(activeSequenceFile);
+  const hasSequence = existsSync9(activeSequenceFile);
   const seq = hasSequence ? await loadSequence(activeSequenceFile) : null;
   if (seq) {
     await syncSequenceActiveAccount(seq);
@@ -3267,10 +3651,13 @@ Usage:
 
 Commands:
   (no args)                            Interactive provider picker
+  list                                 List managed accounts for all providers
+  status                               Show current account for all providers
   <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> login [-- <args...>]      Run provider login and register session
   <provider> remove [<email>]          Remove an account
   <provider> next                      Rotate to next account
   <provider> status [--json]           Show current account
@@ -3279,11 +3666,17 @@ Commands:
 
 Examples:
   caflip                               Pick provider interactively
+  caflip list                          List managed accounts for Claude and Codex
+  caflip status                        Show current account for Claude and Codex
   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 login                   Run Claude login and register session
+  caflip claude login -- --email me@example.com --sso
+                                       Pass provider-specific flags after --
   caflip claude status --json          Show Claude status as JSON
   caflip codex list                    List managed Codex accounts
+  caflip codex login -- --device-auth  Run Codex login and register session
   caflip codex add --alias work        Add current Codex account with alias
   caflip codex alias work user@company.com
                                        Set Codex alias for target email`);
@@ -3312,11 +3705,10 @@ async function main() {
     return await runWithLock(fn);
   };
   const isHelpCommand = command === "help" || command === "--help" || command === "-h";
-  if (!parsed.isProviderQualified && command && !isHelpCommand) {
+  const isProviderOptionalReadOnlyCommand = command === "list" || command === "status";
+  if (!parsed.isProviderQualified && command && !isHelpCommand && !isProviderOptionalReadOnlyCommand) {
     if (RESERVED_COMMANDS.includes(command)) {
-      console.error("Error: Provider is required for non-interactive commands.");
-      console.error("Try: caflip claude list");
-      process.exit(2);
+      showProviderRequiredError(command);
     } else {
       console.error("Error: Alias requires provider prefix.");
       console.error("Try: caflip claude <alias> or caflip codex <alias>");
@@ -3343,9 +3735,20 @@ async function main() {
     return;
   }
   if (!provider) {
-    console.error("Error: Provider is required for non-interactive commands.");
-    console.error("Try: caflip claude list");
-    process.exit(2);
+    if (command === "list") {
+      await cmdListAllProviders();
+      return;
+    }
+    if (command === "status") {
+      if (args.includes("--json")) {
+        console.error("Error: Provider is required for status --json.");
+        console.error("Try: caflip claude status --json");
+        process.exit(2);
+      }
+      await cmdStatusAllProviders();
+      return;
+    }
+    showProviderRequiredError(command);
   }
   setActiveProvider(provider);
   switch (command) {
@@ -3375,12 +3778,19 @@ async function main() {
       });
       break;
     }
+    case "login": {
+      validateLoginArgs(args.slice(1));
+      await runWithLock(async () => {
+        await cmdLogin(args.slice(1));
+      });
+      break;
+    }
     case "status":
       await cmdStatus({ json: args.includes("--json") });
       break;
     case "alias": {
       if (!args[1]) {
-        console.error("Usage: caflip alias <name> [<email>]");
+        console.error(`Usage: caflip ${provider} alias <name> [<email>]`);
         process.exit(1);
       }
       await runWithLock(async () => {
@@ -3389,7 +3799,7 @@ async function main() {
       break;
     }
     default: {
-      if (existsSync10(activeSequenceFile)) {
+      if (existsSync9(activeSequenceFile)) {
         const seq = await loadSequence(activeSequenceFile);
         const accountNum = findAccountByAlias(seq, command);
         if (accountNum) {

package/install.sh

@@ -3,7 +3,7 @@ set -e
 
 REPO="LucienLee/caflip"
 BINARY="caflip"
-INSTALL_DIR="/usr/local/bin"
+INSTALL_DIR="${INSTALL_DIR:-/usr/local/bin}"
 
 OS=$(uname -s | tr '[:upper:]' '[:lower:]')
 ARCH=$(uname -m)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caflip",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "bin": {
     "caflip": "bin/caflip"