@imdeadpool/codex-account-switcher 0.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sls0n
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# codex-auth
+
+A command-line tool that lets you manage and switch between multiple Codex accounts instantly, no more constant logins and logouts.
+
+> [!WARNING]
+> Not affiliated with OpenAI or Codex. Not an official tool.
+
+## How it Works
+
+Codex stores your authentication session in a single `auth.json` file. This tool works by creating named snapshots of that file for each of your accounts. When you want to switch, `codex-auth` swaps the active `~/.codex/auth.json` with the snapshot you select, instantly changing your logged-in account.
+
+## Requirements
+
+- Node.js 18 or newer
+
+## Install (npm)
+
+```sh
+npm i -g @imdeadpool/codex-account-switcher
+```
+
+## Usage
+
+```sh
+# save the current logged-in token as a named account
+codex-auth save <name>
+
+# switch active account (symlinks on macOS/Linux; copies on Windows)
+codex-auth use <name>
+
+# or pick interactively
+codex-auth use
+
+# list accounts
+codex-auth list
+
+# show current account name
+codex-auth current
+```
+
+### Command reference
+
+- `codex-auth save <name>` – Validates `<name>`, ensures `auth.json` exists, then snapshots it to `~/.codex/accounts/<name>.json`.
+- `codex-auth use [name]` – Accepts a name or launches an interactive selector with the current account pre-selected. Copies on Windows, creates a symlink elsewhere, and records the active name.
+- `codex-auth list` – Lists all saved snapshots alphabetically and marks the active one with `*`.
+- `codex-auth current` – Prints the active account name, or a friendly message if none is active.
+
+Notes:
+
+- Works on macOS/Linux (symlink) and Windows (copy).
+- Requires Node 18+.

package/dist/commands/current.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from "../lib/base-command";
+export default class CurrentCommand extends BaseCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/current.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../lib/base-command");
+class CurrentCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const name = await this.accounts.getCurrentAccountName();
+            this.log(name !== null && name !== void 0 ? name : "No Codex account is active yet.");
+        });
+    }
+}
+CurrentCommand.description = "Show the currently active account name";
+exports.default = CurrentCommand;

package/dist/commands/list.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from "../lib/base-command";
+export default class ListCommand extends BaseCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/list.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../lib/base-command");
+class ListCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const accounts = await this.accounts.listAccountNames();
+            const current = await this.accounts.getCurrentAccountName();
+            if (!accounts.length) {
+                this.log("No saved Codex accounts yet. Run `codex-auth save <name>`.");
+                return;
+            }
+            for (const name of accounts) {
+                const mark = current === name ? "*" : " ";
+                this.log(`${mark} ${name}`);
+            }
+        });
+    }
+}
+ListCommand.description = "List accounts managed under ~/.codex";
+exports.default = ListCommand;

package/dist/commands/save.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from "../lib/base-command";
+export default class SaveCommand extends BaseCommand {
+    static description: string;
+    static args: {
+        readonly name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/save.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../lib/base-command");
+class SaveCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const { args } = await this.parse(SaveCommand);
+            const savedName = await this.accounts.saveAccount(args.name);
+            this.log(`Saved current Codex auth tokens as "${savedName}".`);
+        });
+    }
+}
+SaveCommand.description = "Save the current ~/.codex/auth.json as a named account";
+SaveCommand.args = {
+    name: core_1.Args.string({
+        name: "name",
+        required: true,
+        description: "Name for the account snapshot",
+    }),
+};
+exports.default = SaveCommand;

package/dist/commands/use.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from "../lib/base-command";
+export default class UseCommand extends BaseCommand {
+    static description: string;
+    static args: {
+        readonly account: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private promptForAccount;
+}

package/dist/commands/use.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const prompts_1 = __importDefault(require("prompts"));
+const base_command_1 = require("../lib/base-command");
+const accounts_1 = require("../lib/accounts");
+class UseCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const { args } = await this.parse(UseCommand);
+            let account = args.account;
+            if (!account) {
+                account = await this.promptForAccount();
+            }
+            const activated = await this.accounts.useAccount(account);
+            this.log(`Switched Codex auth to "${activated}".`);
+        });
+    }
+    async promptForAccount() {
+        const accounts = await this.accounts.listAccountNames();
+        if (!accounts.length) {
+            throw new accounts_1.NoAccountsSavedError();
+        }
+        const current = await this.accounts.getCurrentAccountName();
+        const initialIndex = current ? Math.max(accounts.indexOf(current), 0) : 0;
+        const response = await (0, prompts_1.default)({
+            type: "select",
+            name: "account",
+            message: "Select account",
+            choices: accounts.map((name) => ({
+                title: current === name ? `${name} (active)` : name,
+                value: name,
+            })),
+            initial: initialIndex,
+        }, {
+            onCancel: () => {
+                throw new accounts_1.PromptCancelledError();
+            },
+        });
+        const picked = response.account;
+        if (!picked) {
+            throw new accounts_1.PromptCancelledError();
+        }
+        return picked;
+    }
+}
+UseCommand.description = "Switch ~/.codex/auth.json to the selected account";
+UseCommand.args = {
+    account: core_1.Args.string({
+        name: "account",
+        required: false,
+        description: "Account to activate",
+    }),
+};
+exports.default = UseCommand;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+void (0, core_1.run)()
+    .then(() => (0, core_1.flush)())
+    .catch(core_1.Errors.handle);

package/dist/lib/accounts/account-service.d.ts

@@ -0,0 +1,15 @@
+export declare class AccountService {
+    listAccountNames(): Promise<string[]>;
+    getCurrentAccountName(): Promise<string | null>;
+    saveAccount(rawName: string): Promise<string>;
+    useAccount(rawName: string): Promise<string>;
+    private accountFilePath;
+    private normalizeAccountName;
+    private ensureAuthFileExists;
+    private ensureDir;
+    private replaceSymlink;
+    private removeIfExists;
+    private writeCurrentName;
+    private readCurrentNameFile;
+    private pathExists;
+}

package/dist/lib/accounts/account-service.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountService = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../config/paths");
+const errors_1 = require("./errors");
+const ACCOUNT_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+class AccountService {
+    async listAccountNames() {
+        if (!(await this.pathExists(paths_1.accountsDir))) {
+            return [];
+        }
+        const entries = await promises_1.default.readdir(paths_1.accountsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.replace(/\.json$/i, ""))
+            .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
+    }
+    async getCurrentAccountName() {
+        const currentName = await this.readCurrentNameFile();
+        if (currentName)
+            return currentName;
+        if (!(await this.pathExists(paths_1.authPath)))
+            return null;
+        const stat = await promises_1.default.lstat(paths_1.authPath);
+        if (!stat.isSymbolicLink())
+            return null;
+        const rawTarget = await promises_1.default.readlink(paths_1.authPath);
+        const resolvedTarget = node_path_1.default.resolve(node_path_1.default.dirname(paths_1.authPath), rawTarget);
+        const accountsRoot = node_path_1.default.resolve(paths_1.accountsDir);
+        const relative = node_path_1.default.relative(accountsRoot, resolvedTarget);
+        if (relative.startsWith(".."))
+            return null;
+        const base = node_path_1.default.basename(resolvedTarget);
+        return base.replace(/\.json$/i, "");
+    }
+    async saveAccount(rawName) {
+        const name = this.normalizeAccountName(rawName);
+        await this.ensureAuthFileExists();
+        await this.ensureDir(paths_1.accountsDir);
+        const destination = this.accountFilePath(name);
+        await promises_1.default.copyFile(paths_1.authPath, destination);
+        await this.writeCurrentName(name);
+        return name;
+    }
+    async useAccount(rawName) {
+        const name = this.normalizeAccountName(rawName);
+        const source = this.accountFilePath(name);
+        if (!(await this.pathExists(source))) {
+            throw new errors_1.AccountNotFoundError(name);
+        }
+        await this.ensureDir(paths_1.accountsDir);
+        await this.ensureDir(paths_1.codexDir);
+        if (process.platform === "win32") {
+            await promises_1.default.copyFile(source, paths_1.authPath);
+        }
+        else {
+            await this.replaceSymlink(source, paths_1.authPath);
+        }
+        await this.writeCurrentName(name);
+        return name;
+    }
+    accountFilePath(name) {
+        return node_path_1.default.join(paths_1.accountsDir, `${name}.json`);
+    }
+    normalizeAccountName(rawName) {
+        if (typeof rawName !== "string") {
+            throw new errors_1.InvalidAccountNameError();
+        }
+        const trimmed = rawName.trim();
+        if (!trimmed.length) {
+            throw new errors_1.InvalidAccountNameError();
+        }
+        const withoutExtension = trimmed.replace(/\.json$/i, "");
+        if (!ACCOUNT_NAME_PATTERN.test(withoutExtension)) {
+            throw new errors_1.InvalidAccountNameError();
+        }
+        return withoutExtension;
+    }
+    async ensureAuthFileExists() {
+        if (!(await this.pathExists(paths_1.authPath))) {
+            throw new errors_1.AuthFileMissingError(paths_1.authPath);
+        }
+    }
+    async ensureDir(dirPath) {
+        await promises_1.default.mkdir(dirPath, { recursive: true });
+    }
+    async replaceSymlink(target, linkPath) {
+        await this.removeIfExists(linkPath);
+        const absoluteTarget = node_path_1.default.resolve(target);
+        await promises_1.default.symlink(absoluteTarget, linkPath);
+    }
+    async removeIfExists(target) {
+        try {
+            await promises_1.default.rm(target, { force: true });
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    async writeCurrentName(name) {
+        await this.ensureDir(paths_1.codexDir);
+        await promises_1.default.writeFile(paths_1.currentNamePath, `${name}\n`, "utf8");
+    }
+    async readCurrentNameFile() {
+        try {
+            const contents = await promises_1.default.readFile(paths_1.currentNamePath, "utf8");
+            const trimmed = contents.trim();
+            return trimmed.length ? trimmed : null;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async pathExists(targetPath) {
+        try {
+            await promises_1.default.access(targetPath, node_fs_1.default.constants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.AccountService = AccountService;

package/dist/lib/accounts/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class CodexAuthError extends Error {
+    constructor(message: string);
+}
+export declare class AuthFileMissingError extends CodexAuthError {
+    constructor(targetPath: string);
+}
+export declare class AccountNotFoundError extends CodexAuthError {
+    constructor(accountName: string);
+}
+export declare class NoAccountsSavedError extends CodexAuthError {
+    constructor();
+}
+export declare class InvalidAccountNameError extends CodexAuthError {
+    constructor();
+}
+export declare class PromptCancelledError extends CodexAuthError {
+    constructor();
+}

package/dist/lib/accounts/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptCancelledError = exports.InvalidAccountNameError = exports.NoAccountsSavedError = exports.AccountNotFoundError = exports.AuthFileMissingError = exports.CodexAuthError = void 0;
+class CodexAuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+exports.CodexAuthError = CodexAuthError;
+class AuthFileMissingError extends CodexAuthError {
+    constructor(targetPath) {
+        super(`No Codex auth file found at ${targetPath}. ` +
+            `Log into Codex first so ~/.codex/auth.json exists.`);
+    }
+}
+exports.AuthFileMissingError = AuthFileMissingError;
+class AccountNotFoundError extends CodexAuthError {
+    constructor(accountName) {
+        super(`No saved Codex account named "${accountName}" was found.`);
+    }
+}
+exports.AccountNotFoundError = AccountNotFoundError;
+class NoAccountsSavedError extends CodexAuthError {
+    constructor() {
+        super(`No saved Codex accounts yet. Run "codex-auth save <name>" first.`);
+    }
+}
+exports.NoAccountsSavedError = NoAccountsSavedError;
+class InvalidAccountNameError extends CodexAuthError {
+    constructor() {
+        super("Account names must include at least one non-space character and " +
+            "may contain letters, numbers, dashes, underscores, and dots.");
+    }
+}
+exports.InvalidAccountNameError = InvalidAccountNameError;
+class PromptCancelledError extends CodexAuthError {
+    constructor() {
+        super("No account selected. The operation was cancelled.");
+    }
+}
+exports.PromptCancelledError = PromptCancelledError;

package/dist/lib/accounts/index.d.ts

@@ -0,0 +1,4 @@
+import { AccountService } from "./account-service";
+export { AccountService } from "./account-service";
+export { AccountNotFoundError, AuthFileMissingError, CodexAuthError, InvalidAccountNameError, NoAccountsSavedError, PromptCancelledError, } from "./errors";
+export declare const accountService: AccountService;

package/dist/lib/accounts/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountService = exports.PromptCancelledError = exports.NoAccountsSavedError = exports.InvalidAccountNameError = exports.CodexAuthError = exports.AuthFileMissingError = exports.AccountNotFoundError = exports.AccountService = void 0;
+const account_service_1 = require("./account-service");
+var account_service_2 = require("./account-service");
+Object.defineProperty(exports, "AccountService", { enumerable: true, get: function () { return account_service_2.AccountService; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "AccountNotFoundError", { enumerable: true, get: function () { return errors_1.AccountNotFoundError; } });
+Object.defineProperty(exports, "AuthFileMissingError", { enumerable: true, get: function () { return errors_1.AuthFileMissingError; } });
+Object.defineProperty(exports, "CodexAuthError", { enumerable: true, get: function () { return errors_1.CodexAuthError; } });
+Object.defineProperty(exports, "InvalidAccountNameError", { enumerable: true, get: function () { return errors_1.InvalidAccountNameError; } });
+Object.defineProperty(exports, "NoAccountsSavedError", { enumerable: true, get: function () { return errors_1.NoAccountsSavedError; } });
+Object.defineProperty(exports, "PromptCancelledError", { enumerable: true, get: function () { return errors_1.PromptCancelledError; } });
+exports.accountService = new account_service_1.AccountService();

package/dist/lib/base-command.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "@oclif/core";
+export declare abstract class BaseCommand extends Command {
+    protected readonly accounts: import("./accounts").AccountService;
+    protected runSafe(action: () => Promise<void>): Promise<void>;
+    private handleError;
+}

package/dist/lib/base-command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const core_1 = require("@oclif/core");
+const accounts_1 = require("./accounts");
+class BaseCommand extends core_1.Command {
+    constructor() {
+        super(...arguments);
+        this.accounts = accounts_1.accountService;
+    }
+    async runSafe(action) {
+        try {
+            await action();
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    handleError(error) {
+        if (error instanceof accounts_1.CodexAuthError) {
+            this.error(error.message);
+        }
+        throw error;
+    }
+}
+exports.BaseCommand = BaseCommand;

package/dist/lib/config/paths.d.ts

@@ -0,0 +1,4 @@
+export declare const codexDir: string;
+export declare const accountsDir: string;
+export declare const authPath: string;
+export declare const currentNamePath: string;

package/dist/lib/config/paths.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentNamePath = exports.authPath = exports.accountsDir = exports.codexDir = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.codexDir = node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+exports.accountsDir = node_path_1.default.join(exports.codexDir, "accounts");
+exports.authPath = node_path_1.default.join(exports.codexDir, "auth.json");
+exports.currentNamePath = node_path_1.default.join(exports.codexDir, "current");

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@imdeadpool/codex-account-switcher",
+  "version": "0.1.5",
+  "description": "A command-line tool that lets you manage and switch between multiple Codex accounts instantly, no more constant logins and logouts.",
+  "license": "MIT",
+  "bin": {
+    "codex-auth": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "codex",
+    "cli",
+    "auth",
+    "accounts",
+    "switch",
+    "tokens"
+  ],
+  "preferGlobal": true,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sls0n/codex-account-switcher.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Sls0n/codex-account-switcher/issues"
+  },
+  "homepage": "https://github.com/Sls0n/codex-account-switcher#readme",
+  "author": "Sls0n",
+  "dependencies": {
+    "@oclif/core": "^3.0.0",
+    "prompts": "^2.4.2",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.6.3"
+  },
+  "oclif": {
+    "bin": "codex-auth",
+    "commands": "./dist/commands"
+  }
+}