codex-team 0.0.1

package/dist/main.cjs

@@ -0,0 +1,1273 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runCli: ()=>runCli
+});
+const external_node_process_namespaceObject = require("node:process");
+const external_dayjs_namespaceObject = require("dayjs");
+var external_dayjs_default = /*#__PURE__*/ __webpack_require__.n(external_dayjs_namespaceObject);
+const timezone_js_namespaceObject = require("dayjs/plugin/timezone.js");
+var timezone_js_default = /*#__PURE__*/ __webpack_require__.n(timezone_js_namespaceObject);
+const utc_js_namespaceObject = require("dayjs/plugin/utc.js");
+var utc_js_default = /*#__PURE__*/ __webpack_require__.n(utc_js_namespaceObject);
+const promises_namespaceObject = require("node:fs/promises");
+function isRecord(value) {
+    return "object" == typeof value && null !== value && !Array.isArray(value);
+}
+function asNonEmptyString(value, fieldName) {
+    if ("string" != typeof value || "" === value.trim()) throw new Error(`Field "${fieldName}" must be a non-empty string.`);
+    return value;
+}
+function asOptionalString(value, fieldName) {
+    if (null == value) return;
+    return asNonEmptyString(value, fieldName);
+}
+function asOptionalBoolean(value, fieldName) {
+    if (null == value) return;
+    if ("boolean" != typeof value) throw new Error(`Field "${fieldName}" must be a boolean.`);
+    return value;
+}
+function asOptionalNumber(value, fieldName) {
+    if (null == value) return;
+    if ("number" != typeof value || Number.isNaN(value)) throw new Error(`Field "${fieldName}" must be a number.`);
+    return value;
+}
+function defaultQuotaSnapshot() {
+    return {
+        status: "stale"
+    };
+}
+function parseQuotaSnapshot(raw) {
+    if (null == raw) return defaultQuotaSnapshot();
+    if (!isRecord(raw)) throw new Error('Field "quota" must be an object.');
+    const status = raw.status;
+    if ("ok" !== status && "stale" !== status && "error" !== status && "unsupported" !== status) throw new Error('Field "quota.status" must be one of ok/stale/error/unsupported.');
+    return {
+        status,
+        plan_type: asOptionalString(raw.plan_type, "quota.plan_type"),
+        credits_balance: asOptionalNumber(raw.credits_balance, "quota.credits_balance"),
+        fetched_at: asOptionalString(raw.fetched_at, "quota.fetched_at"),
+        error_message: asOptionalString(raw.error_message, "quota.error_message"),
+        unlimited: asOptionalBoolean(raw.unlimited, "quota.unlimited"),
+        five_hour: parseQuotaWindowSnapshot(raw.five_hour, "quota.five_hour"),
+        one_week: parseQuotaWindowSnapshot(raw.one_week, "quota.one_week")
+    };
+}
+function parseQuotaWindowSnapshot(raw, fieldName) {
+    if (null == raw) return;
+    if (!isRecord(raw)) throw new Error(`Field "${fieldName}" must be an object.`);
+    return {
+        used_percent: asNonEmptyNumber(raw.used_percent, `${fieldName}.used_percent`),
+        window_seconds: asNonEmptyNumber(raw.window_seconds, `${fieldName}.window_seconds`),
+        reset_after_seconds: asOptionalNumber(raw.reset_after_seconds, `${fieldName}.reset_after_seconds`),
+        reset_at: asOptionalString(raw.reset_at, `${fieldName}.reset_at`)
+    };
+}
+function asNonEmptyNumber(value, fieldName) {
+    if ("number" != typeof value || Number.isNaN(value)) throw new Error(`Field "${fieldName}" must be a number.`);
+    return value;
+}
+function parseAuthSnapshot(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        throw new Error(`Failed to parse auth snapshot JSON: ${error.message}`);
+    }
+    if (!isRecord(parsed)) throw new Error("Auth snapshot must be a JSON object.");
+    const authMode = asNonEmptyString(parsed.auth_mode, "auth_mode");
+    if (!isRecord(parsed.tokens)) throw new Error('Field "tokens" must be an object.');
+    const accountId = asNonEmptyString(parsed.tokens.account_id, "tokens.account_id");
+    return {
+        ...parsed,
+        auth_mode: authMode,
+        tokens: {
+            ...parsed.tokens,
+            account_id: accountId
+        }
+    };
+}
+async function readAuthSnapshotFile(filePath) {
+    const raw = await (0, promises_namespaceObject.readFile)(filePath, "utf8");
+    return parseAuthSnapshot(raw);
+}
+function createSnapshotMeta(name, snapshot, now, existingCreatedAt) {
+    const timestamp = now.toISOString();
+    return {
+        name,
+        auth_mode: snapshot.auth_mode,
+        account_id: snapshot.tokens.account_id,
+        created_at: existingCreatedAt ?? timestamp,
+        updated_at: timestamp,
+        last_switched_at: null,
+        quota: defaultQuotaSnapshot()
+    };
+}
+function parseSnapshotMeta(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        throw new Error(`Failed to parse account metadata JSON: ${error.message}`);
+    }
+    if (!isRecord(parsed)) throw new Error("Account metadata must be a JSON object.");
+    const lastSwitchedAt = parsed.last_switched_at;
+    if (null !== lastSwitchedAt && "string" != typeof lastSwitchedAt) throw new Error('Field "last_switched_at" must be a string or null.');
+    return {
+        name: asNonEmptyString(parsed.name, "name"),
+        auth_mode: asNonEmptyString(parsed.auth_mode, "auth_mode"),
+        account_id: asNonEmptyString(parsed.account_id, "account_id"),
+        created_at: asNonEmptyString(parsed.created_at, "created_at"),
+        updated_at: asNonEmptyString(parsed.updated_at, "updated_at"),
+        last_switched_at: lastSwitchedAt,
+        quota: parseQuotaSnapshot(parsed.quota)
+    };
+}
+function maskAccountId(accountId) {
+    if (accountId.length <= 10) return accountId;
+    return `${accountId.slice(0, 6)}...${accountId.slice(-4)}`;
+}
+function decodeJwtPayload(token) {
+    const payload = token.split(".")[1];
+    if (!payload) throw new Error("Token payload is missing.");
+    const padded = payload.padEnd(payload.length + (4 - payload.length % 4) % 4, "=");
+    const decoded = Buffer.from(padded, "base64url").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    if (!isRecord(parsed)) throw new Error("Token payload must be a JSON object.");
+    return parsed;
+}
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_util_namespaceObject = require("node:util");
+const DEFAULT_CHATGPT_BASE_URL = "https://chatgpt.com";
+const USER_AGENT = "codexm/0.1";
+function quota_client_isRecord(value) {
+    return "object" == typeof value && null !== value && !Array.isArray(value);
+}
+function extractAuthClaim(payload) {
+    const value = payload["https://api.openai.com/auth"];
+    return quota_client_isRecord(value) ? value : void 0;
+}
+function extractStringClaim(payload, key) {
+    const value = payload[key];
+    return "string" == typeof value && "" !== value.trim() ? value : void 0;
+}
+function isSupportedChatGPTMode(authMode) {
+    const normalized = authMode.trim().toLowerCase();
+    return "chatgpt" === normalized || "chatgpt_auth_tokens" === normalized;
+}
+function parsePlanType(snapshot) {
+    for (const tokenName of [
+        "id_token",
+        "access_token"
+    ]){
+        const token = snapshot.tokens[tokenName];
+        if ("string" == typeof token && "" !== token.trim()) try {
+            const payload = decodeJwtPayload(token);
+            const authClaim = extractAuthClaim(payload);
+            const planType = authClaim?.chatgpt_plan_type;
+            if ("string" == typeof planType && "" !== planType.trim()) return planType;
+        } catch  {}
+    }
+}
+function extractChatGPTAuth(snapshot) {
+    const authMode = snapshot.auth_mode ?? "";
+    const supported = isSupportedChatGPTMode(authMode);
+    const accessTokenValue = snapshot.tokens.access_token;
+    const refreshTokenValue = snapshot.tokens.refresh_token;
+    const directAccountId = snapshot.tokens.account_id;
+    let accountId = "string" == typeof directAccountId && "" !== directAccountId.trim() ? directAccountId : void 0;
+    let planType;
+    let issuer;
+    let clientId;
+    for (const tokenName of [
+        "id_token",
+        "access_token"
+    ]){
+        const token = snapshot.tokens[tokenName];
+        if ("string" == typeof token && "" !== token.trim()) try {
+            const payload = decodeJwtPayload(token);
+            const authClaim = extractAuthClaim(payload);
+            if (!accountId) {
+                const maybeAccountId = authClaim?.chatgpt_account_id;
+                if ("string" == typeof maybeAccountId && "" !== maybeAccountId.trim()) accountId = maybeAccountId;
+            }
+            if (!planType) {
+                const maybePlanType = authClaim?.chatgpt_plan_type;
+                if ("string" == typeof maybePlanType && "" !== maybePlanType.trim()) planType = maybePlanType;
+            }
+            issuer ??= extractStringClaim(payload, "iss");
+            clientId ??= extractStringClaim(payload, "client_id") ?? extractStringClaim(payload, "azp") ?? ("string" == typeof payload.aud ? payload.aud : void 0);
+        } catch  {}
+    }
+    if (!supported) return {
+        accessToken: "string" == typeof accessTokenValue ? accessTokenValue : "",
+        accountId: accountId ?? "",
+        refreshToken: "string" == typeof refreshTokenValue && "" !== refreshTokenValue.trim() ? refreshTokenValue : void 0,
+        planType,
+        issuer,
+        clientId,
+        supported: false
+    };
+    if ("string" != typeof accessTokenValue || "" === accessTokenValue.trim()) throw new Error("auth.json is missing access_token.");
+    if (!accountId) throw new Error("auth.json is missing ChatGPT account_id.");
+    return {
+        accessToken: accessTokenValue,
+        accountId,
+        refreshToken: "string" == typeof refreshTokenValue && "" !== refreshTokenValue.trim() ? refreshTokenValue : void 0,
+        planType,
+        issuer,
+        clientId,
+        supported: true
+    };
+}
+async function readChatGPTBaseUrl(homeDir) {
+    if (!homeDir) return DEFAULT_CHATGPT_BASE_URL;
+    try {
+        const config = await (0, promises_namespaceObject.readFile)((0, external_node_path_namespaceObject.join)(homeDir, ".codex", "config.toml"), "utf8");
+        for (const line of config.split(/\r?\n/u)){
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("chatgpt_base_url")) continue;
+            const [, rawValue] = trimmed.split("=", 2);
+            const value = rawValue?.trim().replace(/^['"]|['"]$/gu, "");
+            if (value) return value.replace(/\/+$/u, "");
+        }
+    } catch  {}
+    return DEFAULT_CHATGPT_BASE_URL;
+}
+async function resolveUsageUrls(homeDir) {
+    const baseUrl = await readChatGPTBaseUrl(homeDir);
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/u, "");
+    const candidates = [
+        `${normalizedBaseUrl}/backend-api/wham/usage`,
+        `${normalizedBaseUrl}/wham/usage`,
+        `${normalizedBaseUrl}/api/codex/usage`,
+        "https://chatgpt.com/backend-api/wham/usage"
+    ];
+    return [
+        ...new Set(candidates)
+    ];
+}
+function normalizeFetchError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function shouldRetryWithTokenRefresh(message) {
+    const normalized = message.toLowerCase();
+    return normalized.includes("401") || normalized.includes("403") || normalized.includes("unauthorized") || normalized.includes("invalid_token") || normalized.includes("deactivated_workspace");
+}
+function parseCreditsBalance(balance) {
+    if (null == balance) return;
+    const normalized = balance.trim().toLowerCase();
+    if ("" === normalized || "null" === normalized || "none" === normalized || "nan" === normalized) return;
+    const numeric = Number.parseFloat(balance);
+    if (Number.isFinite(numeric)) return numeric;
+    throw new Error(`Invalid credits balance "${balance}".`);
+}
+function mapUsagePayload(payload, fallbackPlanType, fetchedAt) {
+    if (!payload.credits) throw new Error('Usage response is missing the "credits" field.');
+    const windows = collectUsageWindows(payload);
+    return {
+        status: "ok",
+        plan_type: payload.plan_type ?? fallbackPlanType,
+        credits_balance: parseCreditsBalance(payload.credits.balance),
+        fetched_at: fetchedAt,
+        unlimited: true === payload.credits.unlimited,
+        five_hour: pickNearestWindow(windows, 18000),
+        one_week: pickNearestWindow(windows, 604800)
+    };
+}
+function collectUsageWindows(payload) {
+    const windows = [];
+    const pushRateLimit = (rateLimit)=>{
+        if (!rateLimit) return;
+        if (rateLimit.primary_window) windows.push(rateLimit.primary_window);
+        if (rateLimit.secondary_window) windows.push(rateLimit.secondary_window);
+    };
+    pushRateLimit(payload.rate_limit);
+    for (const additional of payload.additional_rate_limits ?? [])pushRateLimit(additional.rate_limit);
+    return windows;
+}
+function pickNearestWindow(windows, targetSeconds) {
+    const nearest = windows.reduce((best, current)=>{
+        if (!best) return current;
+        return Math.abs(current.limit_window_seconds - targetSeconds) < Math.abs(best.limit_window_seconds - targetSeconds) ? current : best;
+    }, void 0);
+    if (!nearest) return;
+    return {
+        used_percent: nearest.used_percent,
+        window_seconds: nearest.limit_window_seconds,
+        reset_after_seconds: nearest.reset_after_seconds,
+        reset_at: "number" == typeof nearest.reset_at ? new Date(1000 * nearest.reset_at).toISOString() : void 0
+    };
+}
+async function requestUsage(snapshot, options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const extracted = extractChatGPTAuth(snapshot);
+    const urls = await resolveUsageUrls(options.homeDir);
+    const now = (options.now ?? new Date()).toISOString();
+    const errors = [];
+    for (const url of urls){
+        let response;
+        try {
+            response = await fetchImpl(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${extracted.accessToken}`,
+                    "ChatGPT-Account-Id": extracted.accountId,
+                    Accept: "application/json",
+                    "User-Agent": USER_AGENT
+                }
+            });
+        } catch (error) {
+            errors.push(`${url} -> ${normalizeFetchError(error)}`);
+            continue;
+        }
+        if (!response.ok) {
+            const body = await response.text();
+            errors.push(`${url} -> ${response.status}: ${body.slice(0, 140).replace(/\s+/gu, " ").trim()}`);
+            continue;
+        }
+        let payload;
+        try {
+            payload = await response.json();
+        } catch (error) {
+            errors.push(`${url} -> failed to parse JSON: ${normalizeFetchError(error)}`);
+            continue;
+        }
+        return mapUsagePayload(payload, extracted.planType, now);
+    }
+    throw new Error(0 === errors.length ? "Usage request failed: no candidate URL was attempted." : `Usage request failed: ${errors.join(" | ")}`);
+}
+async function refreshChatGPTAuthTokens(snapshot, options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const extracted = extractChatGPTAuth(snapshot);
+    if (!extracted.refreshToken) throw new Error("auth.json is missing refresh_token.");
+    const tokenUrl = `${(extracted.issuer ?? "https://auth.openai.com").replace(/\/+$/u, "")}/oauth/token`;
+    const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: extracted.refreshToken
+    });
+    if (extracted.clientId) body.set("client_id", extracted.clientId);
+    const response = await fetchImpl(tokenUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Accept: "application/json",
+            "User-Agent": USER_AGENT
+        },
+        body
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Token refresh failed: ${response.status} ${errorText.slice(0, 140).replace(/\s+/gu, " ").trim()}`);
+    }
+    const payload = await response.json();
+    const nextSnapshot = {
+        ...snapshot,
+        last_refresh: (options.now ?? new Date()).toISOString(),
+        tokens: {
+            ...snapshot.tokens,
+            access_token: payload.access_token,
+            id_token: payload.id_token,
+            refresh_token: payload.refresh_token ?? extracted.refreshToken,
+            account_id: extracted.accountId
+        }
+    };
+    return nextSnapshot;
+}
+async function fetchQuotaSnapshot(snapshot, options = {}) {
+    const fetchedAt = (options.now ?? new Date()).toISOString();
+    const extracted = extractChatGPTAuth(snapshot);
+    if (!extracted.supported) return {
+        quota: {
+            status: "unsupported",
+            plan_type: extracted.planType ?? parsePlanType(snapshot),
+            fetched_at: fetchedAt
+        },
+        authSnapshot: snapshot
+    };
+    try {
+        return {
+            quota: await requestUsage(snapshot, options),
+            authSnapshot: snapshot
+        };
+    } catch (error) {
+        const message = normalizeFetchError(error);
+        if (!extracted.refreshToken || !shouldRetryWithTokenRefresh(message)) throw error;
+        const refreshedSnapshot = await refreshChatGPTAuthTokens(snapshot, options);
+        return {
+            quota: await requestUsage(refreshedSnapshot, options),
+            authSnapshot: refreshedSnapshot
+        };
+    }
+}
+const execFile = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+const DIRECTORY_MODE = 448;
+const FILE_MODE = 384;
+const SCHEMA_VERSION = 1;
+const ACCOUNT_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function defaultPaths(homeDir = (0, external_node_os_namespaceObject.homedir)()) {
+    const codexDir = (0, external_node_path_namespaceObject.join)(homeDir, ".codex");
+    const codexTeamDir = (0, external_node_path_namespaceObject.join)(homeDir, ".codex-team");
+    return {
+        homeDir,
+        codexDir,
+        codexTeamDir,
+        currentAuthPath: (0, external_node_path_namespaceObject.join)(codexDir, "auth.json"),
+        accountsDir: (0, external_node_path_namespaceObject.join)(codexTeamDir, "accounts"),
+        backupsDir: (0, external_node_path_namespaceObject.join)(codexTeamDir, "backups"),
+        statePath: (0, external_node_path_namespaceObject.join)(codexTeamDir, "state.json")
+    };
+}
+async function chmodIfPossible(path, mode) {
+    try {
+        await (0, promises_namespaceObject.chmod)(path, mode);
+    } catch (error) {
+        const nodeError = error;
+        if ("ENOENT" !== nodeError.code) throw error;
+    }
+}
+async function ensureDirectory(path, mode) {
+    await (0, promises_namespaceObject.mkdir)(path, {
+        recursive: true,
+        mode
+    });
+    await chmodIfPossible(path, mode);
+}
+async function atomicWriteFile(path, content, mode = FILE_MODE) {
+    const directory = (0, external_node_path_namespaceObject.dirname)(path);
+    const tempPath = (0, external_node_path_namespaceObject.join)(directory, `.${(0, external_node_path_namespaceObject.basename)(path)}.${process.pid}.${Date.now()}.tmp`);
+    await ensureDirectory(directory, DIRECTORY_MODE);
+    await (0, promises_namespaceObject.writeFile)(tempPath, content, {
+        encoding: "utf8",
+        mode
+    });
+    await chmodIfPossible(tempPath, mode);
+    await (0, promises_namespaceObject.rename)(tempPath, path);
+    await chmodIfPossible(path, mode);
+}
+function stringifyJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function ensureAccountName(name) {
+    if (!ACCOUNT_NAME_PATTERN.test(name)) throw new Error('Account name must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/ and cannot contain path separators.');
+}
+async function pathExists(path) {
+    try {
+        await (0, promises_namespaceObject.stat)(path);
+        return true;
+    } catch (error) {
+        const nodeError = error;
+        if ("ENOENT" === nodeError.code) return false;
+        throw error;
+    }
+}
+async function readJsonFile(path) {
+    return (0, promises_namespaceObject.readFile)(path, "utf8");
+}
+async function detectRunningCodexProcesses() {
+    try {
+        const { stdout } = await execFile("ps", [
+            "-Ao",
+            "pid=,command="
+        ]);
+        const pids = [];
+        for (const line of stdout.split("\n")){
+            const match = line.trim().match(/^(\d+)\s+(.+)$/);
+            if (!match) continue;
+            const pid = Number(match[1]);
+            const command = match[2];
+            if (pid !== process.pid && /(^|\s|\/)codex(\s|$)/.test(command) && !command.includes("codex-team")) pids.push(pid);
+        }
+        return pids;
+    } catch  {
+        return [];
+    }
+}
+class AccountStore {
+    paths;
+    fetchImpl;
+    constructor(paths){
+        const resolved = defaultPaths(paths?.homeDir);
+        this.paths = {
+            ...resolved,
+            ...paths,
+            homeDir: paths?.homeDir ?? resolved.homeDir
+        };
+        this.fetchImpl = paths?.fetchImpl;
+    }
+    accountDirectory(name) {
+        ensureAccountName(name);
+        return (0, external_node_path_namespaceObject.join)(this.paths.accountsDir, name);
+    }
+    accountAuthPath(name) {
+        return (0, external_node_path_namespaceObject.join)(this.accountDirectory(name), "auth.json");
+    }
+    accountMetaPath(name) {
+        return (0, external_node_path_namespaceObject.join)(this.accountDirectory(name), "meta.json");
+    }
+    async writeAccountAuthSnapshot(name, snapshot) {
+        await atomicWriteFile(this.accountAuthPath(name), stringifyJson(snapshot));
+    }
+    async writeAccountMeta(name, meta) {
+        await atomicWriteFile(this.accountMetaPath(name), stringifyJson(meta));
+    }
+    async syncCurrentAuthIfMatching(snapshot) {
+        if (!await pathExists(this.paths.currentAuthPath)) return;
+        try {
+            const currentSnapshot = await readAuthSnapshotFile(this.paths.currentAuthPath);
+            if (currentSnapshot.tokens.account_id !== snapshot.tokens.account_id) return;
+            await atomicWriteFile(this.paths.currentAuthPath, stringifyJson(snapshot));
+        } catch  {}
+    }
+    async quotaSummaryForAccount(account) {
+        let planType = account.quota.plan_type ?? null;
+        try {
+            const snapshot = await readAuthSnapshotFile(account.authPath);
+            const extracted = extractChatGPTAuth(snapshot);
+            planType ??= extracted.planType ?? null;
+        } catch  {}
+        return {
+            name: account.name,
+            account_id: account.account_id,
+            plan_type: planType,
+            credits_balance: account.quota.credits_balance ?? null,
+            status: account.quota.status,
+            fetched_at: account.quota.fetched_at ?? null,
+            error_message: account.quota.error_message ?? null,
+            unlimited: true === account.quota.unlimited,
+            five_hour: account.quota.five_hour ?? null,
+            one_week: account.quota.one_week ?? null
+        };
+    }
+    async ensureLayout() {
+        await ensureDirectory(this.paths.codexTeamDir, DIRECTORY_MODE);
+        await ensureDirectory(this.paths.accountsDir, DIRECTORY_MODE);
+        await ensureDirectory(this.paths.backupsDir, DIRECTORY_MODE);
+    }
+    async readState() {
+        if (!await pathExists(this.paths.statePath)) return {
+            schema_version: SCHEMA_VERSION,
+            last_switched_account: null,
+            last_backup_path: null
+        };
+        const raw = await readJsonFile(this.paths.statePath);
+        const parsed = JSON.parse(raw);
+        return {
+            schema_version: parsed.schema_version ?? SCHEMA_VERSION,
+            last_switched_account: parsed.last_switched_account ?? null,
+            last_backup_path: parsed.last_backup_path ?? null
+        };
+    }
+    async writeState(state) {
+        await this.ensureLayout();
+        await atomicWriteFile(this.paths.statePath, stringifyJson(state));
+    }
+    async readManagedAccount(name) {
+        const metaPath = this.accountMetaPath(name);
+        const authPath = this.accountAuthPath(name);
+        const [rawMeta, snapshot] = await Promise.all([
+            readJsonFile(metaPath),
+            readAuthSnapshotFile(authPath)
+        ]);
+        const meta = parseSnapshotMeta(rawMeta);
+        if (meta.name !== name) throw new Error(`Account metadata name mismatch for "${name}".`);
+        if (meta.account_id !== snapshot.tokens.account_id) throw new Error(`Account metadata account_id mismatch for "${name}".`);
+        return {
+            ...meta,
+            authPath,
+            metaPath,
+            duplicateAccountId: false
+        };
+    }
+    async listAccounts() {
+        await this.ensureLayout();
+        const entries = await (0, promises_namespaceObject.readdir)(this.paths.accountsDir, {
+            withFileTypes: true
+        });
+        const accounts = [];
+        const warnings = [];
+        for (const entry of entries)if (entry.isDirectory()) try {
+            accounts.push(await this.readManagedAccount(entry.name));
+        } catch (error) {
+            warnings.push(`Account "${entry.name}" is invalid: ${error.message}`);
+        }
+        const counts = new Map();
+        for (const account of accounts)counts.set(account.account_id, (counts.get(account.account_id) ?? 0) + 1);
+        accounts.sort((left, right)=>left.name.localeCompare(right.name));
+        return {
+            accounts: accounts.map((account)=>({
+                    ...account,
+                    duplicateAccountId: (counts.get(account.account_id) ?? 0) > 1
+                })),
+            warnings
+        };
+    }
+    async getCurrentStatus() {
+        const { accounts, warnings } = await this.listAccounts();
+        if (!await pathExists(this.paths.currentAuthPath)) return {
+            exists: false,
+            auth_mode: null,
+            account_id: null,
+            matched_accounts: [],
+            managed: false,
+            duplicate_match: false,
+            warnings
+        };
+        const snapshot = await readAuthSnapshotFile(this.paths.currentAuthPath);
+        const matchedAccounts = accounts.filter((account)=>account.account_id === snapshot.tokens.account_id).map((account)=>account.name);
+        return {
+            exists: true,
+            auth_mode: snapshot.auth_mode,
+            account_id: snapshot.tokens.account_id,
+            matched_accounts: matchedAccounts,
+            managed: matchedAccounts.length > 0,
+            duplicate_match: matchedAccounts.length > 1,
+            warnings
+        };
+    }
+    async saveCurrentAccount(name, force = false) {
+        ensureAccountName(name);
+        await this.ensureLayout();
+        if (!await pathExists(this.paths.currentAuthPath)) throw new Error("Current ~/.codex/auth.json does not exist.");
+        const rawSnapshot = await readJsonFile(this.paths.currentAuthPath);
+        const snapshot = parseAuthSnapshot(rawSnapshot);
+        const accountDir = this.accountDirectory(name);
+        const authPath = this.accountAuthPath(name);
+        const metaPath = this.accountMetaPath(name);
+        const accountExists = await pathExists(accountDir);
+        const existingMeta = accountExists && await pathExists(metaPath) ? parseSnapshotMeta(await readJsonFile(metaPath)) : void 0;
+        if (accountExists && !force) throw new Error(`Account "${name}" already exists. Use --force to overwrite it.`);
+        await ensureDirectory(accountDir, DIRECTORY_MODE);
+        await atomicWriteFile(authPath, `${rawSnapshot.trimEnd()}\n`);
+        const meta = createSnapshotMeta(name, snapshot, new Date(), existingMeta?.created_at);
+        meta.last_switched_at = existingMeta?.last_switched_at ?? null;
+        meta.quota = existingMeta?.quota ?? meta.quota;
+        await atomicWriteFile(metaPath, stringifyJson(meta));
+        return this.readManagedAccount(name);
+    }
+    async updateCurrentManagedAccount() {
+        await this.ensureLayout();
+        if (!await pathExists(this.paths.currentAuthPath)) throw new Error("Current ~/.codex/auth.json does not exist.");
+        const current = await this.getCurrentStatus();
+        if (!current.managed) throw new Error("Current account is not managed.");
+        if (current.duplicate_match || 1 !== current.matched_accounts.length) throw new Error(`Current account matches multiple managed accounts: ${current.matched_accounts.join(", ")}.`);
+        const name = current.matched_accounts[0];
+        const currentRawSnapshot = await readJsonFile(this.paths.currentAuthPath);
+        const currentSnapshot = parseAuthSnapshot(currentRawSnapshot);
+        const metaPath = this.accountMetaPath(name);
+        const existingMeta = parseSnapshotMeta(await readJsonFile(metaPath));
+        await atomicWriteFile(this.accountAuthPath(name), `${currentRawSnapshot.trimEnd()}\n`);
+        await atomicWriteFile(metaPath, stringifyJson({
+            ...createSnapshotMeta(name, currentSnapshot, new Date(), existingMeta.created_at),
+            last_switched_at: existingMeta.last_switched_at,
+            quota: existingMeta.quota
+        }));
+        return {
+            account: await this.readManagedAccount(name)
+        };
+    }
+    async switchAccount(name) {
+        ensureAccountName(name);
+        await this.ensureLayout();
+        const account = await this.readManagedAccount(name);
+        const warnings = [];
+        let backupPath = null;
+        await ensureDirectory(this.paths.codexDir, DIRECTORY_MODE);
+        if (await pathExists(this.paths.currentAuthPath)) {
+            backupPath = (0, external_node_path_namespaceObject.join)(this.paths.backupsDir, "last-active-auth.json");
+            await (0, promises_namespaceObject.copyFile)(this.paths.currentAuthPath, backupPath);
+            await chmodIfPossible(backupPath, FILE_MODE);
+        }
+        const rawAuth = await readJsonFile(account.authPath);
+        await atomicWriteFile(this.paths.currentAuthPath, `${rawAuth.trimEnd()}\n`);
+        const writtenSnapshot = await readAuthSnapshotFile(this.paths.currentAuthPath);
+        if (writtenSnapshot.tokens.account_id !== account.account_id) throw new Error(`Switch verification failed for account "${name}".`);
+        const meta = parseSnapshotMeta(await readJsonFile(account.metaPath));
+        meta.last_switched_at = new Date().toISOString();
+        meta.updated_at = meta.last_switched_at;
+        await atomicWriteFile(account.metaPath, stringifyJson(meta));
+        await this.writeState({
+            schema_version: SCHEMA_VERSION,
+            last_switched_account: name,
+            last_backup_path: backupPath
+        });
+        const runningCodexPids = await detectRunningCodexProcesses();
+        if (runningCodexPids.length > 0) warnings.push(`Detected running codex processes (${runningCodexPids.join(", ")}). Existing sessions may still hold the previous login state.`);
+        return {
+            account: await this.readManagedAccount(name),
+            warnings,
+            backup_path: backupPath
+        };
+    }
+    async listQuotaSummaries() {
+        const { accounts, warnings } = await this.listAccounts();
+        const summaries = await Promise.all(accounts.map((account)=>this.quotaSummaryForAccount(account)));
+        return {
+            accounts: summaries,
+            warnings
+        };
+    }
+    async refreshQuotaForAccount(name) {
+        ensureAccountName(name);
+        await this.ensureLayout();
+        const account = await this.readManagedAccount(name);
+        const meta = parseSnapshotMeta(await readJsonFile(account.metaPath));
+        const snapshot = await readAuthSnapshotFile(account.authPath);
+        const now = new Date();
+        try {
+            const result = await fetchQuotaSnapshot(snapshot, {
+                homeDir: this.paths.homeDir,
+                fetchImpl: this.fetchImpl,
+                now
+            });
+            if (JSON.stringify(result.authSnapshot) !== JSON.stringify(snapshot)) {
+                await this.writeAccountAuthSnapshot(name, result.authSnapshot);
+                await this.syncCurrentAuthIfMatching(result.authSnapshot);
+            }
+            meta.auth_mode = result.authSnapshot.auth_mode;
+            meta.account_id = result.authSnapshot.tokens.account_id;
+            meta.updated_at = now.toISOString();
+            meta.quota = result.quota;
+            await this.writeAccountMeta(name, meta);
+            return {
+                account: await this.readManagedAccount(name),
+                quota: meta.quota
+            };
+        } catch (error) {
+            let planType = meta.quota.plan_type;
+            try {
+                const extracted = extractChatGPTAuth(snapshot);
+                planType ??= extracted.planType;
+            } catch  {}
+            meta.updated_at = now.toISOString();
+            meta.quota = {
+                ...meta.quota,
+                status: "error",
+                plan_type: planType,
+                fetched_at: now.toISOString(),
+                error_message: error.message
+            };
+            await this.writeAccountMeta(name, meta);
+            throw new Error(`Failed to refresh quota for "${name}": ${error.message}`);
+        }
+    }
+    async refreshAllQuotas(targetName) {
+        const { accounts } = await this.listAccounts();
+        const targets = targetName ? accounts.filter((account)=>account.name === targetName) : accounts;
+        if (targetName && 0 === targets.length) throw new Error(`Account "${targetName}" does not exist.`);
+        const successes = [];
+        const failures = [];
+        for (const account of targets)try {
+            const refreshed = await this.refreshQuotaForAccount(account.name);
+            successes.push(await this.quotaSummaryForAccount(refreshed.account));
+        } catch (error) {
+            failures.push({
+                name: account.name,
+                error: error.message
+            });
+        }
+        return {
+            successes,
+            failures
+        };
+    }
+    async removeAccount(name) {
+        ensureAccountName(name);
+        const accountDir = this.accountDirectory(name);
+        if (!await pathExists(accountDir)) throw new Error(`Account "${name}" does not exist.`);
+        await (0, promises_namespaceObject.rm)(accountDir, {
+            recursive: true,
+            force: false
+        });
+    }
+    async renameAccount(oldName, newName) {
+        ensureAccountName(oldName);
+        ensureAccountName(newName);
+        const oldDir = this.accountDirectory(oldName);
+        const newDir = this.accountDirectory(newName);
+        if (!await pathExists(oldDir)) throw new Error(`Account "${oldName}" does not exist.`);
+        if (await pathExists(newDir)) throw new Error(`Account "${newName}" already exists.`);
+        await (0, promises_namespaceObject.rename)(oldDir, newDir);
+        const metaPath = this.accountMetaPath(newName);
+        const meta = parseSnapshotMeta(await readJsonFile(metaPath));
+        meta.name = newName;
+        meta.updated_at = new Date().toISOString();
+        await atomicWriteFile(metaPath, stringifyJson(meta));
+        return this.readManagedAccount(newName);
+    }
+    async doctor() {
+        await this.ensureLayout();
+        const issues = [];
+        const warnings = [];
+        const invalidAccounts = [];
+        const rootStat = await (0, promises_namespaceObject.stat)(this.paths.codexTeamDir);
+        if ((511 & rootStat.mode) !== DIRECTORY_MODE) issues.push(`Store directory permissions are ${(511 & rootStat.mode).toString(8)}, expected 700.`);
+        if (await pathExists(this.paths.statePath)) {
+            const stateStat = await (0, promises_namespaceObject.stat)(this.paths.statePath);
+            if ((511 & stateStat.mode) !== FILE_MODE) issues.push(`State file permissions are ${(511 & stateStat.mode).toString(8)}, expected 600.`);
+            await this.readState();
+        }
+        const { accounts, warnings: accountWarnings } = await this.listAccounts();
+        for (const warning of accountWarnings){
+            warnings.push(warning);
+            const match = warning.match(/^Account "(.+)" is invalid:/);
+            if (match) invalidAccounts.push(match[1]);
+        }
+        for (const account of accounts){
+            const authStat = await (0, promises_namespaceObject.stat)(account.authPath);
+            const metaStat = await (0, promises_namespaceObject.stat)(account.metaPath);
+            if ((511 & authStat.mode) !== FILE_MODE) issues.push(`Account "${account.name}" auth permissions must be 600.`);
+            if ((511 & metaStat.mode) !== FILE_MODE) issues.push(`Account "${account.name}" metadata permissions must be 600.`);
+            if (account.duplicateAccountId) warnings.push(`Account "${account.name}" shares account_id ${account.account_id} with another saved account.`);
+        }
+        let currentAuthPresent = false;
+        if (await pathExists(this.paths.currentAuthPath)) {
+            currentAuthPresent = true;
+            try {
+                await readAuthSnapshotFile(this.paths.currentAuthPath);
+            } catch (error) {
+                issues.push(`Current auth.json is invalid: ${error.message}`);
+            }
+        } else warnings.push("Current ~/.codex/auth.json is missing.");
+        return {
+            healthy: 0 === issues.length,
+            warnings,
+            issues,
+            account_count: accounts.length,
+            invalid_accounts: invalidAccounts,
+            current_auth_present: currentAuthPresent
+        };
+    }
+}
+function createAccountStore(homeDir, options) {
+    return new AccountStore({
+        homeDir,
+        fetchImpl: options?.fetchImpl
+    });
+}
+external_dayjs_default().extend(utc_js_default());
+external_dayjs_default().extend(timezone_js_default());
+function parseArgs(argv) {
+    const flags = new Set();
+    const positionals = [];
+    for (const arg of argv)if (arg.startsWith("--")) flags.add(arg);
+    else positionals.push(arg);
+    return {
+        command: positionals[0] ?? null,
+        positionals: positionals.slice(1),
+        flags
+    };
+}
+function writeJson(stream, value) {
+    stream.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function formatTable(rows, columns) {
+    if (0 === rows.length) return "";
+    const widths = columns.map(({ key, label })=>Math.max(label.length, ...rows.map((row)=>row[key].length)));
+    const renderRow = (row)=>columns.map(({ key }, index)=>row[key].padEnd(widths[index])).join("  ").trimEnd();
+    const header = renderRow(Object.fromEntries(columns.map(({ key, label })=>[
+            key,
+            label
+        ])));
+    const separator = widths.map((width)=>"-".repeat(width)).join("  ");
+    return [
+        header,
+        separator,
+        ...rows.map(renderRow)
+    ].join("\n");
+}
+function printHelp(stream) {
+    stream.write(`codexm - manage multiple Codex ChatGPT auth snapshots
+
+Usage:
+  codexm current [--json]
+  codexm list [--json]
+  codexm save <name> [--force] [--json]
+  codexm update [--json]
+  codexm quota refresh [name] [--json]
+  codexm quota list [--json]
+  codexm switch <name> [--json]
+  codexm remove <name> [--yes] [--json]
+  codexm rename <old> <new> [--json]
+  codexm doctor [--json]
+
+Account names must match /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.
+`);
+}
+function describeCurrentStatus(status) {
+    const lines = [];
+    if (status.exists) {
+        lines.push("Current auth: present");
+        lines.push(`Auth mode: ${status.auth_mode}`);
+        lines.push(`Account ID: ${maskAccountId(status.account_id ?? "")}`);
+        if (0 === status.matched_accounts.length) lines.push("Managed account: no (unmanaged)");
+        else if (1 === status.matched_accounts.length) lines.push(`Managed account: ${status.matched_accounts[0]}`);
+        else lines.push(`Managed account: multiple (${status.matched_accounts.join(", ")})`);
+    } else lines.push("Current auth: missing");
+    for (const warning of status.warnings)lines.push(`Warning: ${warning}`);
+    return lines.join("\n");
+}
+function describeAccounts(accounts, warnings) {
+    if (0 === accounts.length) return 0 === warnings.length ? "No saved accounts." : warnings.map((warning)=>`Warning: ${warning}`).join("\n");
+    const table = formatTable(accounts.map((account)=>({
+            name: account.name,
+            account_id: maskAccountId(account.account_id),
+            auth_mode: account.auth_mode,
+            saved: account.created_at,
+            switched: account.last_switched_at ?? "-",
+            flags: account.duplicateAccountId ? "duplicate-account-id" : "-"
+        })), [
+        {
+            key: "name",
+            label: "NAME"
+        },
+        {
+            key: "account_id",
+            label: "ACCOUNT ID"
+        },
+        {
+            key: "auth_mode",
+            label: "AUTH MODE"
+        },
+        {
+            key: "saved",
+            label: "SAVED AT"
+        },
+        {
+            key: "switched",
+            label: "LAST SWITCHED"
+        },
+        {
+            key: "flags",
+            label: "FLAGS"
+        }
+    ]);
+    const lines = [
+        table
+    ];
+    for (const warning of warnings)lines.push(`Warning: ${warning}`);
+    return lines.join("\n");
+}
+function describeDoctor(report) {
+    const lines = [
+        report.healthy ? "Doctor checks passed." : "Doctor checks found issues.",
+        `Saved accounts: ${report.account_count}`,
+        `Current auth present: ${report.current_auth_present ? "yes" : "no"}`
+    ];
+    for (const issue of report.issues)lines.push(`Issue: ${issue}`);
+    for (const warning of report.warnings)lines.push(`Warning: ${warning}`);
+    return lines.join("\n");
+}
+function formatUsagePercent(window) {
+    if (!window) return "-";
+    return `${window.used_percent}%`;
+}
+function formatResetAt(window) {
+    if (!window?.reset_at) return "-";
+    return external_dayjs_default().utc(window.reset_at).tz(external_dayjs_default().tz.guess()).format("MM-DD HH:mm");
+}
+function describeQuotaAccounts(accounts, warnings) {
+    if (0 === accounts.length) return 0 === warnings.length ? "No saved accounts." : warnings.map((warning)=>`Warning: ${warning}`).join("\n");
+    const table = formatTable(accounts.map((account)=>({
+            name: account.name,
+            account_id: maskAccountId(account.account_id),
+            plan_type: account.plan_type ?? "-",
+            five_hour: formatUsagePercent(account.five_hour),
+            five_hour_reset: formatResetAt(account.five_hour),
+            one_week: formatUsagePercent(account.one_week),
+            one_week_reset: formatResetAt(account.one_week),
+            status: account.status
+        })), [
+        {
+            key: "name",
+            label: "NAME"
+        },
+        {
+            key: "account_id",
+            label: "ACCOUNT ID"
+        },
+        {
+            key: "plan_type",
+            label: "PLAN TYPE"
+        },
+        {
+            key: "five_hour",
+            label: "5H USED"
+        },
+        {
+            key: "five_hour_reset",
+            label: "5H RESET AT"
+        },
+        {
+            key: "one_week",
+            label: "1W USED"
+        },
+        {
+            key: "one_week_reset",
+            label: "1W RESET AT"
+        },
+        {
+            key: "status",
+            label: "STATUS"
+        }
+    ]);
+    const lines = [
+        table
+    ];
+    for (const warning of warnings)lines.push(`Warning: ${warning}`);
+    return lines.join("\n");
+}
+function describeQuotaRefresh(result) {
+    const lines = [];
+    if (result.successes.length > 0) {
+        lines.push("Refreshed quotas:");
+        lines.push(describeQuotaAccounts(result.successes, []));
+    }
+    for (const failure of result.failures)lines.push(`Failure: ${failure.name}: ${failure.error}`);
+    if (0 === lines.length) lines.push("No accounts were refreshed.");
+    return lines.join("\n");
+}
+async function confirmRemoval(name, streams) {
+    if (!streams.stdin.isTTY) throw new Error(`Refusing to remove "${name}" without --yes in a non-interactive terminal.`);
+    streams.stdout.write(`Remove saved account "${name}"? [y/N] `);
+    return await new Promise((resolve)=>{
+        const onData = (buffer)=>{
+            const answer = buffer.toString("utf8").trim().toLowerCase();
+            streams.stdin.off("data", onData);
+            streams.stdout.write("\n");
+            resolve("y" === answer || "yes" === answer);
+        };
+        streams.stdin.on("data", onData);
+    });
+}
+async function runCli(argv, options = {}) {
+    const streams = {
+        stdin: options.stdin ?? external_node_process_namespaceObject.stdin,
+        stdout: options.stdout ?? external_node_process_namespaceObject.stdout,
+        stderr: options.stderr ?? external_node_process_namespaceObject.stderr
+    };
+    const store = options.store ?? createAccountStore();
+    const parsed = parseArgs(argv);
+    const json = parsed.flags.has("--json");
+    try {
+        if (!parsed.command || parsed.flags.has("--help")) {
+            printHelp(streams.stdout);
+            return 0;
+        }
+        switch(parsed.command){
+            case "current":
+                {
+                    const result = await store.getCurrentStatus();
+                    if (json) writeJson(streams.stdout, result);
+                    else streams.stdout.write(`${describeCurrentStatus(result)}\n`);
+                    return 0;
+                }
+            case "list":
+                {
+                    const result = await store.listAccounts();
+                    if (json) writeJson(streams.stdout, result);
+                    else streams.stdout.write(`${describeAccounts(result.accounts, result.warnings)}\n`);
+                    return 0;
+                }
+            case "save":
+                {
+                    const name = parsed.positionals[0];
+                    if (!name) throw new Error("Usage: codexm save <name> [--force]");
+                    const account = await store.saveCurrentAccount(name, parsed.flags.has("--force"));
+                    const payload = {
+                        ok: true,
+                        action: "save",
+                        account: {
+                            name: account.name,
+                            account_id: account.account_id,
+                            auth_mode: account.auth_mode
+                        }
+                    };
+                    if (json) writeJson(streams.stdout, payload);
+                    else streams.stdout.write(`Saved account "${account.name}" (${maskAccountId(account.account_id)}).\n`);
+                    return 0;
+                }
+            case "update":
+                {
+                    const result = await store.updateCurrentManagedAccount();
+                    const warnings = [];
+                    let quota = null;
+                    try {
+                        const quotaResult = await store.refreshQuotaForAccount(result.account.name);
+                        const quotaList = await store.listQuotaSummaries();
+                        quota = quotaList.accounts.find((account)=>account.name === quotaResult.account.name) ?? null;
+                    } catch (error) {
+                        warnings.push(error.message);
+                    }
+                    const payload = {
+                        ok: true,
+                        action: "update",
+                        account: {
+                            name: result.account.name,
+                            account_id: result.account.account_id,
+                            auth_mode: result.account.auth_mode
+                        },
+                        quota,
+                        warnings
+                    };
+                    if (json) writeJson(streams.stdout, payload);
+                    else {
+                        streams.stdout.write(`Updated managed account "${result.account.name}" (${maskAccountId(result.account.account_id)}).\n`);
+                        for (const warning of warnings)streams.stdout.write(`Warning: ${warning}\n`);
+                    }
+                    return 0;
+                }
+            case "quota":
+                {
+                    const quotaCommand = parsed.positionals[0];
+                    if ("list" === quotaCommand) {
+                        const result = await store.listQuotaSummaries();
+                        if (json) writeJson(streams.stdout, result);
+                        else streams.stdout.write(`${describeQuotaAccounts(result.accounts, result.warnings)}\n`);
+                        return 0;
+                    }
+                    if ("refresh" === quotaCommand) {
+                        const targetName = parsed.positionals[1];
+                        const result = await store.refreshAllQuotas(targetName);
+                        if (json) writeJson(streams.stdout, result);
+                        else streams.stdout.write(`${describeQuotaRefresh(result)}\n`);
+                        return 0 === result.failures.length ? 0 : 1;
+                    }
+                    throw new Error("Usage: codexm quota <refresh [name] | list> [--json]");
+                }
+            case "switch":
+                {
+                    const name = parsed.positionals[0];
+                    if (!name) throw new Error("Usage: codexm switch <name>");
+                    const result = await store.switchAccount(name);
+                    let quota = null;
+                    try {
+                        await store.refreshQuotaForAccount(result.account.name);
+                        const quotaList = await store.listQuotaSummaries();
+                        quota = quotaList.accounts.find((account)=>account.name === result.account.name) ?? null;
+                    } catch (error) {
+                        result.warnings.push(error.message);
+                    }
+                    const payload = {
+                        ok: true,
+                        action: "switch",
+                        account: {
+                            name: result.account.name,
+                            account_id: result.account.account_id,
+                            auth_mode: result.account.auth_mode
+                        },
+                        quota,
+                        backup_path: result.backup_path,
+                        warnings: result.warnings
+                    };
+                    if (json) writeJson(streams.stdout, payload);
+                    else {
+                        streams.stdout.write(`Switched to "${result.account.name}" (${maskAccountId(result.account.account_id)}).\n`);
+                        if (result.backup_path) streams.stdout.write(`Backup: ${result.backup_path}\n`);
+                        for (const warning of result.warnings)streams.stdout.write(`Warning: ${warning}\n`);
+                    }
+                    return 0;
+                }
+            case "remove":
+                {
+                    const name = parsed.positionals[0];
+                    if (!name) throw new Error("Usage: codexm remove <name> [--yes]");
+                    const confirmed = parsed.flags.has("--yes") || await confirmRemoval(name, streams);
+                    if (!confirmed) {
+                        if (json) writeJson(streams.stdout, {
+                            ok: false,
+                            action: "remove",
+                            account: name,
+                            cancelled: true
+                        });
+                        else streams.stdout.write("Cancelled.\n");
+                        return 1;
+                    }
+                    await store.removeAccount(name);
+                    if (json) writeJson(streams.stdout, {
+                        ok: true,
+                        action: "remove",
+                        account: name
+                    });
+                    else streams.stdout.write(`Removed account "${name}".\n`);
+                    return 0;
+                }
+            case "rename":
+                {
+                    const oldName = parsed.positionals[0];
+                    const newName = parsed.positionals[1];
+                    if (!oldName || !newName) throw new Error("Usage: codexm rename <old> <new>");
+                    const account = await store.renameAccount(oldName, newName);
+                    if (json) writeJson(streams.stdout, {
+                        ok: true,
+                        action: "rename",
+                        account: {
+                            name: account.name,
+                            account_id: account.account_id,
+                            auth_mode: account.auth_mode
+                        }
+                    });
+                    else streams.stdout.write(`Renamed "${oldName}" to "${newName}".\n`);
+                    return 0;
+                }
+            case "doctor":
+                {
+                    const report = await store.doctor();
+                    if (json) writeJson(streams.stdout, report);
+                    else streams.stdout.write(`${describeDoctor(report)}\n`);
+                    return report.healthy ? 0 : 1;
+                }
+            default:
+                throw new Error(`Unknown command "${parsed.command}".`);
+        }
+    } catch (error) {
+        const message = error.message;
+        if (json) writeJson(streams.stderr, {
+            ok: false,
+            error: message
+        });
+        else streams.stderr.write(`Error: ${message}\n`);
+        return 1;
+    }
+}
+exports.runCli = __webpack_exports__.runCli;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runCli"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});