@imdeadpool/codex-account-switcher 0.1.5 → 0.1.6

package/dist/lib/accounts/usage.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRateWindow = resolveRateWindow;
+exports.remainingPercent = remainingPercent;
+exports.usageScore = usageScore;
+exports.shouldSwitchCurrent = shouldSwitchCurrent;
+exports.fetchUsageFromApi = fetchUsageFromApi;
+exports.fetchUsageFromLocal = fetchUsageFromLocal;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
+const REQUEST_TIMEOUT_MS = 5000;
+function coerceWindow(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const value = raw;
+    const usedRaw = value.used_percent;
+    if (typeof usedRaw !== "number" || !Number.isFinite(usedRaw))
+        return undefined;
+    const windowMinutes = typeof value.window_minutes === "number"
+        ? Math.round(value.window_minutes)
+        : typeof value.limit_window_seconds === "number"
+            ? Math.ceil(value.limit_window_seconds / 60)
+            : undefined;
+    const resetsAt = typeof value.resets_at === "number"
+        ? Math.round(value.resets_at)
+        : typeof value.reset_at === "number"
+            ? Math.round(value.reset_at)
+            : undefined;
+    return {
+        usedPercent: Math.max(0, Math.min(100, usedRaw)),
+        windowMinutes,
+        resetsAt,
+    };
+}
+function buildSnapshotFromRateLimits(rateLimits, source) {
+    var _a, _b;
+    if (!rateLimits || typeof rateLimits !== "object")
+        return null;
+    const input = rateLimits;
+    const primary = coerceWindow((_a = input.primary_window) !== null && _a !== void 0 ? _a : input.primary);
+    const secondary = coerceWindow((_b = input.secondary_window) !== null && _b !== void 0 ? _b : input.secondary);
+    if (!primary && !secondary)
+        return null;
+    const planType = typeof input.plan_type === "string" ? input.plan_type : undefined;
+    return {
+        primary,
+        secondary,
+        planType,
+        fetchedAt: new Date().toISOString(),
+        source,
+    };
+}
+function findNestedRateLimits(input) {
+    if (!input || typeof input !== "object")
+        return null;
+    const root = input;
+    if (root.rate_limits)
+        return root.rate_limits;
+    if (root.payload && typeof root.payload === "object") {
+        const payload = root.payload;
+        if (payload.rate_limits)
+            return payload.rate_limits;
+        if (payload.event && typeof payload.event === "object") {
+            const event = payload.event;
+            if (event.rate_limits)
+                return event.rate_limits;
+        }
+    }
+    return null;
+}
+function parseTimestampSeconds(input) {
+    if (typeof input === "number" && Number.isFinite(input)) {
+        if (input > 1000000000000) {
+            return Math.floor(input / 1000);
+        }
+        return Math.floor(input);
+    }
+    if (typeof input === "string") {
+        const parsed = Date.parse(input);
+        if (!Number.isNaN(parsed)) {
+            return Math.floor(parsed / 1000);
+        }
+    }
+    return Math.floor(Date.now() / 1000);
+}
+function resolveRateWindow(snapshot, minutes, fallbackPrimary) {
+    if (!snapshot)
+        return undefined;
+    if (snapshot.primary && snapshot.primary.windowMinutes === minutes) {
+        return snapshot.primary;
+    }
+    if (snapshot.secondary && snapshot.secondary.windowMinutes === minutes) {
+        return snapshot.secondary;
+    }
+    return fallbackPrimary ? snapshot.primary : snapshot.secondary;
+}
+function remainingPercent(window, nowSeconds) {
+    if (!window)
+        return undefined;
+    if (typeof window.resetsAt === "number" && window.resetsAt <= nowSeconds)
+        return 100;
+    const remaining = 100 - window.usedPercent;
+    if (remaining <= 0)
+        return 0;
+    if (remaining >= 100)
+        return 100;
+    return Math.trunc(remaining);
+}
+function usageScore(snapshot, nowSeconds) {
+    const fiveHour = remainingPercent(resolveRateWindow(snapshot, 300, true), nowSeconds);
+    const weekly = remainingPercent(resolveRateWindow(snapshot, 10080, false), nowSeconds);
+    if (typeof fiveHour === "number" && typeof weekly === "number")
+        return Math.min(fiveHour, weekly);
+    if (typeof fiveHour === "number")
+        return fiveHour;
+    if (typeof weekly === "number")
+        return weekly;
+    return undefined;
+}
+function shouldSwitchCurrent(snapshot, thresholds, nowSeconds) {
+    const remaining5h = remainingPercent(resolveRateWindow(snapshot, 300, true), nowSeconds);
+    const remainingWeekly = remainingPercent(resolveRateWindow(snapshot, 10080, false), nowSeconds);
+    return ((typeof remaining5h === "number" && remaining5h < thresholds.threshold5hPercent) ||
+        (typeof remainingWeekly === "number" && remainingWeekly < thresholds.thresholdWeeklyPercent));
+}
+async function fetchUsageFromApi(snapshotInfo) {
+    if (snapshotInfo.authMode !== "chatgpt" || !snapshotInfo.accessToken || !snapshotInfo.accountId) {
+        return null;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(USAGE_ENDPOINT, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${snapshotInfo.accessToken}`,
+                "ChatGPT-Account-Id": snapshotInfo.accountId,
+                "User-Agent": "codex-auth",
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const snapshot = buildSnapshotFromRateLimits(data.rate_limit, "api");
+        if (!snapshot)
+            return null;
+        if (!snapshot.planType && typeof data.plan_type === "string") {
+            snapshot.planType = data.plan_type;
+        }
+        return snapshot;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function collectRolloutFiles(sessionsDir) {
+    const pending = [sessionsDir];
+    const rolloutFiles = [];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current)
+            continue;
+        let entries;
+        try {
+            entries = await promises_1.default.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(fullPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl"))
+                continue;
+            try {
+                const stat = await promises_1.default.stat(fullPath);
+                rolloutFiles.push({ filePath: fullPath, mtimeMs: stat.mtimeMs });
+            }
+            catch {
+                // ignore unreadable files
+            }
+        }
+    }
+    rolloutFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return rolloutFiles.slice(0, 5).map((entry) => entry.filePath);
+}
+async function parseRolloutForUsage(filePath) {
+    var _a, _b;
+    let raw;
+    try {
+        raw = await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let latest = null;
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const rateLimits = findNestedRateLimits(record);
+        const snapshot = buildSnapshotFromRateLimits(rateLimits, "local");
+        if (!snapshot)
+            continue;
+        const row = record;
+        const timestampSeconds = parseTimestampSeconds((_b = (_a = row.event_timestamp_ms) !== null && _a !== void 0 ? _a : row.timestamp_ms) !== null && _b !== void 0 ? _b : row.timestamp);
+        if (!latest || timestampSeconds >= latest.timestampSeconds) {
+            latest = {
+                snapshot,
+                timestampSeconds,
+            };
+        }
+    }
+    return latest;
+}
+async function fetchUsageFromLocal(codexDir) {
+    const sessionsDir = node_path_1.default.join(codexDir, "sessions");
+    const files = await collectRolloutFiles(sessionsDir);
+    for (const filePath of files) {
+        const latest = await parseRolloutForUsage(filePath);
+        if (latest) {
+            return latest.snapshot;
+        }
+    }
+    return null;
+}

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

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

package/dist/lib/base-command.js

@@ -7,9 +7,13 @@ class BaseCommand extends core_1.Command {
     constructor() {
         super(...arguments);
         this.accounts = accounts_1.accountService;
+        this.syncExternalAuthBeforeRun = true;
     }
     async runSafe(action) {
         try {
+            if (this.syncExternalAuthBeforeRun) {
+                await this.accounts.syncExternalAuthSnapshotIfNeeded();
+            }
             await action();
         }
         catch (error) {

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

@@ -1,4 +1,10 @@
+export declare function resolveCodexDir(): string;
+export declare function resolveAccountsDir(): string;
+export declare function resolveAuthPath(): string;
+export declare function resolveCurrentNamePath(): string;
+export declare function resolveRegistryPath(): string;
 export declare const codexDir: string;
 export declare const accountsDir: string;
 export declare const authPath: string;
 export declare const currentNamePath: string;
+export declare const registryPath: string;

package/dist/lib/config/paths.js

@@ -3,10 +3,51 @@ 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;
+exports.registryPath = exports.currentNamePath = exports.authPath = exports.accountsDir = exports.codexDir = void 0;
+exports.resolveCodexDir = resolveCodexDir;
+exports.resolveAccountsDir = resolveAccountsDir;
+exports.resolveAuthPath = resolveAuthPath;
+exports.resolveCurrentNamePath = resolveCurrentNamePath;
+exports.resolveRegistryPath = resolveRegistryPath;
 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");
+function resolvePath(raw) {
+    const expanded = raw.startsWith("~") ? node_path_1.default.join(node_os_1.default.homedir(), raw.slice(1)) : raw;
+    return node_path_1.default.resolve(expanded);
+}
+function resolveCodexDir() {
+    const envPath = process.env.CODEX_AUTH_CODEX_DIR;
+    if (envPath && envPath.trim().length > 0) {
+        return resolvePath(envPath.trim());
+    }
+    return node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+}
+function resolveAccountsDir() {
+    const envPath = process.env.CODEX_AUTH_ACCOUNTS_DIR;
+    if (envPath && envPath.trim().length > 0) {
+        return resolvePath(envPath.trim());
+    }
+    return node_path_1.default.join(resolveCodexDir(), "accounts");
+}
+function resolveAuthPath() {
+    const envPath = process.env.CODEX_AUTH_JSON_PATH;
+    if (envPath && envPath.trim().length > 0) {
+        return resolvePath(envPath.trim());
+    }
+    return node_path_1.default.join(resolveCodexDir(), "auth.json");
+}
+function resolveCurrentNamePath() {
+    const envPath = process.env.CODEX_AUTH_CURRENT_PATH;
+    if (envPath && envPath.trim().length > 0) {
+        return resolvePath(envPath.trim());
+    }
+    return node_path_1.default.join(resolveCodexDir(), "current");
+}
+function resolveRegistryPath() {
+    return node_path_1.default.join(resolveAccountsDir(), "registry.json");
+}
+exports.codexDir = resolveCodexDir();
+exports.accountsDir = resolveAccountsDir();
+exports.authPath = resolveAuthPath();
+exports.currentNamePath = resolveCurrentNamePath();
+exports.registryPath = resolveRegistryPath();

package/dist/tests/auth-parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/auth-parser.test.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const auth_parser_1 = require("../lib/accounts/auth-parser");
+function encodeBase64Url(input) {
+    return Buffer.from(input, "utf8")
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/g, "");
+}
+(0, node_test_1.default)("parseAuthSnapshotData extracts chatgpt metadata from id_token claims", () => {
+    const payload = {
+        email: "ADMIN@EDIXAI.COM",
+        "https://api.openai.com/auth": {
+            chatgpt_account_id: "acct-1",
+            chatgpt_user_id: "user-1",
+            chatgpt_plan_type: "team",
+        },
+    };
+    const idToken = `${encodeBase64Url(JSON.stringify({ alg: "none" }))}.${encodeBase64Url(JSON.stringify(payload))}.sig`;
+    const parsed = (0, auth_parser_1.parseAuthSnapshotData)({
+        tokens: {
+            access_token: "token-123",
+            id_token: idToken,
+            account_id: "acct-1",
+        },
+    });
+    strict_1.default.equal(parsed.authMode, "chatgpt");
+    strict_1.default.equal(parsed.email, "admin@edixai.com");
+    strict_1.default.equal(parsed.accountId, "acct-1");
+    strict_1.default.equal(parsed.userId, "user-1");
+    strict_1.default.equal(parsed.planType, "team");
+    strict_1.default.equal(parsed.accessToken, "token-123");
+});
+(0, node_test_1.default)("parseAuthSnapshotData detects API key mode", () => {
+    const parsed = (0, auth_parser_1.parseAuthSnapshotData)({ OPENAI_API_KEY: "sk-test" });
+    strict_1.default.equal(parsed.authMode, "apikey");
+    strict_1.default.equal(parsed.accessToken, undefined);
+});
+(0, node_test_1.default)("parseAuthSnapshotData falls back to root/sub/default_account_id metadata when auth claim is partial", () => {
+    const payload = {
+        sub: "user-from-sub",
+    };
+    const idToken = `${encodeBase64Url(JSON.stringify({ alg: "none" }))}.${encodeBase64Url(JSON.stringify(payload))}.sig`;
+    const parsed = (0, auth_parser_1.parseAuthSnapshotData)({
+        email: "Fallback@Example.com",
+        chatgpt_plan_type: "plus",
+        tokens: {
+            access_token: "token-xyz",
+            id_token: idToken,
+            default_account_id: "acct-default",
+        },
+    });
+    strict_1.default.equal(parsed.authMode, "chatgpt");
+    strict_1.default.equal(parsed.email, "fallback@example.com");
+    strict_1.default.equal(parsed.accountId, "acct-default");
+    strict_1.default.equal(parsed.userId, "user-from-sub");
+    strict_1.default.equal(parsed.planType, "plus");
+    strict_1.default.equal(parsed.accessToken, "token-xyz");
+});

package/dist/tests/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/registry.test.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const registry_1 = require("../lib/accounts/registry");
+(0, node_test_1.default)("sanitizeRegistry falls back to defaults for invalid thresholds", () => {
+    const registry = (0, registry_1.sanitizeRegistry)({
+        autoSwitch: {
+            enabled: true,
+            threshold5hPercent: 0,
+            thresholdWeeklyPercent: 101,
+        },
+        api: {
+            usage: false,
+        },
+        accounts: {},
+    });
+    strict_1.default.equal(registry.autoSwitch.enabled, true);
+    strict_1.default.equal(registry.autoSwitch.threshold5hPercent, 10);
+    strict_1.default.equal(registry.autoSwitch.thresholdWeeklyPercent, 5);
+    strict_1.default.equal(registry.api.usage, false);
+});
+(0, node_test_1.default)("reconcileRegistryWithAccounts drops missing account entries", () => {
+    const registry = (0, registry_1.sanitizeRegistry)({
+        accounts: {
+            keep: { name: "keep", createdAt: new Date().toISOString() },
+            remove: { name: "remove", createdAt: new Date().toISOString() },
+        },
+        activeAccountName: "remove",
+    });
+    const reconciled = (0, registry_1.reconcileRegistryWithAccounts)(registry, ["keep"]);
+    strict_1.default.deepEqual(Object.keys(reconciled.accounts), ["keep"]);
+    strict_1.default.equal(reconciled.activeAccountName, undefined);
+});

package/dist/tests/save-account-safety.test.d.ts

@@ -0,0 +1 @@
+export {};