@imdeadpool/codex-account-switcher 0.1.5 → 0.1.7

package/dist/lib/accounts/auth-parser.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAuthSnapshotData = parseAuthSnapshotData;
+exports.parseAuthSnapshotFile = parseAuthSnapshotFile;
+const promises_1 = __importDefault(require("node:fs/promises"));
+function decodeJwtPayload(idToken) {
+    const parts = idToken.split(".");
+    if (parts.length < 2)
+        return null;
+    try {
+        const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+        const json = Buffer.from(padded, "base64").toString("utf8");
+        const payload = JSON.parse(json);
+        return payload && typeof payload === "object" ? payload : null;
+    }
+    catch {
+        return null;
+    }
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asAuthObject(payload) {
+    if (!payload)
+        return null;
+    const authClaim = payload["https://api.openai.com/auth"];
+    if (!authClaim || typeof authClaim !== "object")
+        return null;
+    return authClaim;
+}
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        const normalized = asNonEmptyString(value);
+        if (normalized)
+            return normalized;
+    }
+    return undefined;
+}
+function parseAuthSnapshotData(data) {
+    var _a;
+    if (!data || typeof data !== "object") {
+        return { authMode: "unknown" };
+    }
+    const root = data;
+    const apiKey = asNonEmptyString(root.OPENAI_API_KEY);
+    if (apiKey) {
+        return { authMode: "apikey" };
+    }
+    const tokens = root.tokens;
+    if (!tokens || typeof tokens !== "object") {
+        return { authMode: "unknown" };
+    }
+    const tokenRecord = tokens;
+    const idToken = asNonEmptyString(tokenRecord.id_token);
+    const payload = idToken ? decodeJwtPayload(idToken) : null;
+    const authObject = asAuthObject(payload);
+    const email = (_a = firstNonEmptyString(payload === null || payload === void 0 ? void 0 : payload.email, root.email)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    const accountId = firstNonEmptyString(tokenRecord.account_id, tokenRecord.chatgpt_account_id, tokenRecord.default_account_id, authObject === null || authObject === void 0 ? void 0 : authObject.chatgpt_account_id, authObject === null || authObject === void 0 ? void 0 : authObject.account_id, authObject === null || authObject === void 0 ? void 0 : authObject.default_account_id, root.account_id, root.chatgpt_account_id);
+    const userId = firstNonEmptyString(authObject === null || authObject === void 0 ? void 0 : authObject.chatgpt_user_id, authObject === null || authObject === void 0 ? void 0 : authObject.user_id, payload === null || payload === void 0 ? void 0 : payload.sub, payload === null || payload === void 0 ? void 0 : payload.user_id, root.user_id, root.chatgpt_user_id);
+    const planType = firstNonEmptyString(authObject === null || authObject === void 0 ? void 0 : authObject.chatgpt_plan_type, payload === null || payload === void 0 ? void 0 : payload.chatgpt_plan_type, root.chatgpt_plan_type);
+    return {
+        authMode: "chatgpt",
+        email,
+        accessToken: asNonEmptyString(tokenRecord.access_token),
+        accountId,
+        userId,
+        planType,
+    };
+}
+async function parseAuthSnapshotFile(snapshotPath) {
+    try {
+        const raw = await promises_1.default.readFile(snapshotPath, "utf8");
+        const data = JSON.parse(raw);
+        return parseAuthSnapshotData(data);
+    }
+    catch {
+        return { authMode: "unknown" };
+    }
+}

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

@@ -13,6 +13,21 @@ export declare class NoAccountsSavedError extends CodexAuthError {
 export declare class InvalidAccountNameError extends CodexAuthError {
     constructor();
 }
+export declare class AccountNameInferenceError extends CodexAuthError {
+    constructor();
+}
+export declare class SnapshotEmailMismatchError extends CodexAuthError {
+    constructor(accountName: string, existingEmail: string, incomingEmail: string);
+}
 export declare class PromptCancelledError extends CodexAuthError {
     constructor();
 }
+export declare class InvalidRemoveSelectionError extends CodexAuthError {
+    constructor();
+}
+export declare class AmbiguousAccountQueryError extends CodexAuthError {
+    constructor(query: string);
+}
+export declare class AutoSwitchConfigError extends CodexAuthError {
+    constructor(message: string);
+}

package/dist/lib/accounts/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptCancelledError = exports.InvalidAccountNameError = exports.NoAccountsSavedError = exports.AccountNotFoundError = exports.AuthFileMissingError = exports.CodexAuthError = void 0;
+exports.AutoSwitchConfigError = exports.AmbiguousAccountQueryError = exports.InvalidRemoveSelectionError = exports.PromptCancelledError = exports.SnapshotEmailMismatchError = exports.AccountNameInferenceError = exports.InvalidAccountNameError = exports.NoAccountsSavedError = exports.AccountNotFoundError = exports.AuthFileMissingError = exports.CodexAuthError = void 0;
 class CodexAuthError extends Error {
     constructor(message) {
         super(message);
@@ -30,13 +30,45 @@ 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.");
+            "may contain letters, numbers, dashes, underscores, dots, and @.");
     }
 }
 exports.InvalidAccountNameError = InvalidAccountNameError;
+class AccountNameInferenceError extends CodexAuthError {
+    constructor() {
+        super("Could not infer account name from auth email. Pass one explicitly: codex-auth save <name>.");
+    }
+}
+exports.AccountNameInferenceError = AccountNameInferenceError;
+class SnapshotEmailMismatchError extends CodexAuthError {
+    constructor(accountName, existingEmail, incomingEmail) {
+        super(`Refusing to overwrite snapshot "${accountName}" because it belongs to ` +
+            `${existingEmail}, but current auth is ${incomingEmail}. ` +
+            `Use a different name, run "codex-auth remove ${accountName}" first, or re-run with --force.`);
+    }
+}
+exports.SnapshotEmailMismatchError = SnapshotEmailMismatchError;
 class PromptCancelledError extends CodexAuthError {
     constructor() {
         super("No account selected. The operation was cancelled.");
     }
 }
 exports.PromptCancelledError = PromptCancelledError;
+class InvalidRemoveSelectionError extends CodexAuthError {
+    constructor() {
+        super("No accounts were selected for removal.");
+    }
+}
+exports.InvalidRemoveSelectionError = InvalidRemoveSelectionError;
+class AmbiguousAccountQueryError extends CodexAuthError {
+    constructor(query) {
+        super(`Query "${query}" matched multiple accounts. Refine the query or use interactive mode.`);
+    }
+}
+exports.AmbiguousAccountQueryError = AmbiguousAccountQueryError;
+class AutoSwitchConfigError extends CodexAuthError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.AutoSwitchConfigError = AutoSwitchConfigError;

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

@@ -1,4 +1,6 @@
 import { AccountService } from "./account-service";
 export { AccountService } from "./account-service";
-export { AccountNotFoundError, AuthFileMissingError, CodexAuthError, InvalidAccountNameError, NoAccountsSavedError, PromptCancelledError, } from "./errors";
+export type { AccountChoice, RemoveResult } from "./account-service";
+export { AccountNotFoundError, AmbiguousAccountQueryError, AuthFileMissingError, AutoSwitchConfigError, CodexAuthError, InvalidAccountNameError, InvalidRemoveSelectionError, NoAccountsSavedError, PromptCancelledError, SnapshotEmailMismatchError, } from "./errors";
+export type { AutoSwitchRunResult, StatusReport } from "./types";
 export declare const accountService: AccountService;

package/dist/lib/accounts/index.js

@@ -1,14 +1,18 @@
 "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;
+exports.accountService = exports.SnapshotEmailMismatchError = exports.PromptCancelledError = exports.NoAccountsSavedError = exports.InvalidRemoveSelectionError = exports.InvalidAccountNameError = exports.CodexAuthError = exports.AutoSwitchConfigError = exports.AuthFileMissingError = exports.AmbiguousAccountQueryError = 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, "AmbiguousAccountQueryError", { enumerable: true, get: function () { return errors_1.AmbiguousAccountQueryError; } });
 Object.defineProperty(exports, "AuthFileMissingError", { enumerable: true, get: function () { return errors_1.AuthFileMissingError; } });
+Object.defineProperty(exports, "AutoSwitchConfigError", { enumerable: true, get: function () { return errors_1.AutoSwitchConfigError; } });
 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, "InvalidRemoveSelectionError", { enumerable: true, get: function () { return errors_1.InvalidRemoveSelectionError; } });
 Object.defineProperty(exports, "NoAccountsSavedError", { enumerable: true, get: function () { return errors_1.NoAccountsSavedError; } });
 Object.defineProperty(exports, "PromptCancelledError", { enumerable: true, get: function () { return errors_1.PromptCancelledError; } });
+Object.defineProperty(exports, "SnapshotEmailMismatchError", { enumerable: true, get: function () { return errors_1.SnapshotEmailMismatchError; } });
 exports.accountService = new account_service_1.AccountService();

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

@@ -0,0 +1,6 @@
+import { RegistryData } from "./types";
+export declare function createDefaultRegistry(): RegistryData;
+export declare function sanitizeRegistry(input: unknown): RegistryData;
+export declare function loadRegistry(): Promise<RegistryData>;
+export declare function saveRegistry(registry: RegistryData): Promise<void>;
+export declare function reconcileRegistryWithAccounts(registry: RegistryData, accountNames: string[]): RegistryData;

package/dist/lib/accounts/registry.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultRegistry = createDefaultRegistry;
+exports.sanitizeRegistry = sanitizeRegistry;
+exports.loadRegistry = loadRegistry;
+exports.saveRegistry = saveRegistry;
+exports.reconcileRegistryWithAccounts = reconcileRegistryWithAccounts;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../config/paths");
+const types_1 = require("./types");
+function nowIso() {
+    return new Date().toISOString();
+}
+function clampPercent(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    const rounded = Math.round(value);
+    if (rounded < 1 || rounded > 100)
+        return fallback;
+    return rounded;
+}
+function sanitizeUsageSnapshot(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const sourceRaw = input.source;
+    const source = sourceRaw === "api" || sourceRaw === "local" || sourceRaw === "cached" ? sourceRaw : "cached";
+    const normalizeWindow = (raw) => {
+        if (!raw || typeof raw !== "object")
+            return undefined;
+        const windowRaw = raw;
+        const used = windowRaw.usedPercent;
+        if (typeof used !== "number" || !Number.isFinite(used))
+            return undefined;
+        const windowMinutes = typeof windowRaw.windowMinutes === "number" && Number.isFinite(windowRaw.windowMinutes)
+            ? Math.round(windowRaw.windowMinutes)
+            : undefined;
+        const resetsAt = typeof windowRaw.resetsAt === "number" && Number.isFinite(windowRaw.resetsAt)
+            ? Math.round(windowRaw.resetsAt)
+            : undefined;
+        return {
+            usedPercent: Math.max(0, Math.min(100, used)),
+            windowMinutes,
+            resetsAt,
+        };
+    };
+    const primary = normalizeWindow(input.primary);
+    const secondary = normalizeWindow(input.secondary);
+    if (!primary && !secondary)
+        return undefined;
+    return {
+        primary,
+        secondary,
+        fetchedAt: typeof input.fetchedAt === "string"
+            ? input.fetchedAt
+            : nowIso(),
+        planType: typeof input.planType === "string"
+            ? input.planType
+            : undefined,
+        source,
+    };
+}
+function sanitizeEntry(name, entry) {
+    const raw = entry && typeof entry === "object" ? entry : {};
+    const sanitizedUsage = sanitizeUsageSnapshot(raw.lastUsage);
+    return {
+        name,
+        createdAt: typeof raw.createdAt === "string" ? raw.createdAt : nowIso(),
+        email: typeof raw.email === "string" ? raw.email : undefined,
+        accountId: typeof raw.accountId === "string" ? raw.accountId : undefined,
+        userId: typeof raw.userId === "string" ? raw.userId : undefined,
+        planType: typeof raw.planType === "string" ? raw.planType : undefined,
+        lastUsageAt: typeof raw.lastUsageAt === "string" ? raw.lastUsageAt : undefined,
+        lastUsage: sanitizedUsage,
+    };
+}
+function createDefaultRegistry() {
+    return {
+        version: 1,
+        autoSwitch: {
+            enabled: false,
+            threshold5hPercent: types_1.DEFAULT_THRESHOLD_5H_PERCENT,
+            thresholdWeeklyPercent: types_1.DEFAULT_THRESHOLD_WEEKLY_PERCENT,
+        },
+        api: {
+            usage: true,
+        },
+        accounts: {},
+    };
+}
+function sanitizeRegistry(input) {
+    const defaults = createDefaultRegistry();
+    if (!input || typeof input !== "object")
+        return defaults;
+    const root = input;
+    const autoSwitch = root.autoSwitch && typeof root.autoSwitch === "object"
+        ? root.autoSwitch
+        : {};
+    const api = root.api && typeof root.api === "object" ? root.api : {};
+    const accountsRaw = root.accounts && typeof root.accounts === "object"
+        ? root.accounts
+        : {};
+    const accounts = {};
+    for (const [name, value] of Object.entries(accountsRaw)) {
+        accounts[name] = sanitizeEntry(name, value);
+    }
+    return {
+        version: 1,
+        autoSwitch: {
+            enabled: typeof autoSwitch.enabled === "boolean" ? autoSwitch.enabled : defaults.autoSwitch.enabled,
+            threshold5hPercent: clampPercent(autoSwitch.threshold5hPercent, defaults.autoSwitch.threshold5hPercent),
+            thresholdWeeklyPercent: clampPercent(autoSwitch.thresholdWeeklyPercent, defaults.autoSwitch.thresholdWeeklyPercent),
+        },
+        api: {
+            usage: typeof api.usage === "boolean" ? api.usage : defaults.api.usage,
+        },
+        activeAccountName: typeof root.activeAccountName === "string" && root.activeAccountName.length > 0
+            ? root.activeAccountName
+            : undefined,
+        accounts,
+    };
+}
+async function loadRegistry() {
+    const registryPath = (0, paths_1.resolveRegistryPath)();
+    try {
+        const raw = await promises_1.default.readFile(registryPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return sanitizeRegistry(parsed);
+    }
+    catch {
+        return createDefaultRegistry();
+    }
+}
+async function saveRegistry(registry) {
+    const registryPath = (0, paths_1.resolveRegistryPath)();
+    await promises_1.default.mkdir(node_path_1.default.dirname(registryPath), { recursive: true });
+    await promises_1.default.writeFile(registryPath, `${JSON.stringify(registry, null, 2)}\n`, "utf8");
+}
+function reconcileRegistryWithAccounts(registry, accountNames) {
+    const next = sanitizeRegistry(registry);
+    const accountSet = new Set(accountNames);
+    const now = nowIso();
+    for (const name of accountNames) {
+        if (!next.accounts[name]) {
+            next.accounts[name] = {
+                name,
+                createdAt: now,
+            };
+        }
+        else {
+            next.accounts[name].name = name;
+        }
+    }
+    for (const name of Object.keys(next.accounts)) {
+        if (!accountSet.has(name)) {
+            delete next.accounts[name];
+        }
+    }
+    if (next.activeAccountName && !accountSet.has(next.activeAccountName)) {
+        delete next.activeAccountName;
+    }
+    return next;
+}

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

@@ -0,0 +1,4 @@
+export type ServiceState = "active" | "inactive" | "unknown";
+export declare function enableManagedService(): Promise<void>;
+export declare function disableManagedService(): Promise<void>;
+export declare function getManagedServiceState(): ServiceState;

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

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableManagedService = enableManagedService;
+exports.disableManagedService = disableManagedService;
+exports.getManagedServiceState = getManagedServiceState;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const LINUX_SERVICE_NAME = "codex-auth-autoswitch.service";
+const MAC_LABEL = "com.codex.auth.autoswitch";
+const WINDOWS_TASK_NAME = "codex-auth-autoswitch";
+function runCommand(command, args) {
+    var _a;
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        code: result.status,
+        stdout: ((_a = result.stdout) !== null && _a !== void 0 ? _a : "").toString(),
+    };
+}
+function linuxUnitPath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), ".config", "systemd", "user", LINUX_SERVICE_NAME);
+}
+function linuxUnitContents() {
+    return [
+        "[Unit]",
+        "Description=codex-auth auto-switch watcher",
+        "",
+        "[Service]",
+        "Type=simple",
+        "Restart=always",
+        "RestartSec=1",
+        "ExecStart=codex-auth daemon --watch",
+        "",
+        "[Install]",
+        "WantedBy=default.target",
+        "",
+    ].join("\n");
+}
+async function enableLinuxService() {
+    const unitPath = linuxUnitPath();
+    await promises_1.default.mkdir(node_path_1.default.dirname(unitPath), { recursive: true });
+    await promises_1.default.writeFile(unitPath, linuxUnitContents(), "utf8");
+    const daemonReload = runCommand("systemctl", ["--user", "daemon-reload"]);
+    if (daemonReload.code !== 0) {
+        throw new Error("systemctl --user daemon-reload failed");
+    }
+    const enable = runCommand("systemctl", ["--user", "enable", LINUX_SERVICE_NAME]);
+    if (enable.code !== 0) {
+        throw new Error("systemctl --user enable failed");
+    }
+    const start = runCommand("systemctl", ["--user", "start", LINUX_SERVICE_NAME]);
+    if (start.code !== 0) {
+        throw new Error("systemctl --user start failed");
+    }
+}
+async function disableLinuxService() {
+    runCommand("systemctl", ["--user", "stop", LINUX_SERVICE_NAME]);
+    runCommand("systemctl", ["--user", "disable", LINUX_SERVICE_NAME]);
+    try {
+        await promises_1.default.rm(linuxUnitPath(), { force: true });
+    }
+    catch {
+        // ignore
+    }
+    runCommand("systemctl", ["--user", "daemon-reload"]);
+}
+function linuxServiceState() {
+    const result = runCommand("systemctl", ["--user", "is-active", LINUX_SERVICE_NAME]);
+    if (result.code === null)
+        return "unknown";
+    if (result.code === 0 && result.stdout.trim().startsWith("active"))
+        return "active";
+    return "inactive";
+}
+function macPlistPath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
+}
+function macPlistContents() {
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        "<dict>",
+        "  <key>Label</key>",
+        `  <string>${MAC_LABEL}</string>`,
+        "  <key>ProgramArguments</key>",
+        "  <array>",
+        "    <string>codex-auth</string>",
+        "    <string>daemon</string>",
+        "    <string>--watch</string>",
+        "  </array>",
+        "  <key>RunAtLoad</key>",
+        "  <true/>",
+        "  <key>KeepAlive</key>",
+        "  <true/>",
+        "</dict>",
+        "</plist>",
+        "",
+    ].join("\n");
+}
+async function enableMacService() {
+    const plistPath = macPlistPath();
+    await promises_1.default.mkdir(node_path_1.default.dirname(plistPath), { recursive: true });
+    await promises_1.default.writeFile(plistPath, macPlistContents(), "utf8");
+    runCommand("launchctl", ["unload", plistPath]);
+    const load = runCommand("launchctl", ["load", plistPath]);
+    if (load.code !== 0) {
+        throw new Error("launchctl load failed");
+    }
+}
+async function disableMacService() {
+    const plistPath = macPlistPath();
+    runCommand("launchctl", ["unload", plistPath]);
+    try {
+        await promises_1.default.rm(plistPath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+function macServiceState() {
+    const result = runCommand("launchctl", ["list", MAC_LABEL]);
+    if (result.code === null)
+        return "unknown";
+    return result.code === 0 ? "active" : "inactive";
+}
+async function enableWindowsService() {
+    const create = runCommand("schtasks", [
+        "/Create",
+        "/TN",
+        WINDOWS_TASK_NAME,
+        "/SC",
+        "ONLOGON",
+        "/TR",
+        "cmd /c codex-auth daemon --watch",
+        "/F",
+    ]);
+    if (create.code !== 0) {
+        throw new Error("schtasks /Create failed");
+    }
+    runCommand("schtasks", ["/Run", "/TN", WINDOWS_TASK_NAME]);
+}
+async function disableWindowsService() {
+    runCommand("schtasks", ["/Delete", "/TN", WINDOWS_TASK_NAME, "/F"]);
+}
+function windowsServiceState() {
+    const query = runCommand("schtasks", ["/Query", "/TN", WINDOWS_TASK_NAME]);
+    if (query.code === null)
+        return "unknown";
+    if (query.code !== 0)
+        return "inactive";
+    const verbose = runCommand("schtasks", ["/Query", "/TN", WINDOWS_TASK_NAME, "/V", "/FO", "LIST"]);
+    if (verbose.code !== 0)
+        return "inactive";
+    const text = verbose.stdout.toLowerCase();
+    if (text.includes("running"))
+        return "active";
+    return "inactive";
+}
+async function enableManagedService() {
+    if (process.platform === "linux") {
+        await enableLinuxService();
+        return;
+    }
+    if (process.platform === "darwin") {
+        await enableMacService();
+        return;
+    }
+    if (process.platform === "win32") {
+        await enableWindowsService();
+        return;
+    }
+    throw new Error(`Managed auto-switch is not supported on platform ${process.platform}.`);
+}
+async function disableManagedService() {
+    if (process.platform === "linux") {
+        await disableLinuxService();
+        return;
+    }
+    if (process.platform === "darwin") {
+        await disableMacService();
+        return;
+    }
+    if (process.platform === "win32") {
+        await disableWindowsService();
+        return;
+    }
+}
+function getManagedServiceState() {
+    if (process.platform === "linux")
+        return linuxServiceState();
+    if (process.platform === "darwin")
+        return macServiceState();
+    if (process.platform === "win32")
+        return windowsServiceState();
+    return "unknown";
+}

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

@@ -0,0 +1,71 @@
+export declare const DEFAULT_THRESHOLD_5H_PERCENT = 10;
+export declare const DEFAULT_THRESHOLD_WEEKLY_PERCENT = 5;
+export type UsageSource = "api" | "local" | "cached";
+export interface RateLimitWindow {
+    usedPercent: number;
+    windowMinutes?: number;
+    resetsAt?: number;
+}
+export interface UsageSnapshot {
+    primary?: RateLimitWindow;
+    secondary?: RateLimitWindow;
+    planType?: string;
+    fetchedAt: string;
+    source: UsageSource;
+}
+export interface AccountRegistryEntry {
+    name: string;
+    email?: string;
+    accountId?: string;
+    userId?: string;
+    planType?: string;
+    createdAt: string;
+    lastUsageAt?: string;
+    lastUsage?: UsageSnapshot;
+}
+export interface AutoSwitchConfig {
+    enabled: boolean;
+    threshold5hPercent: number;
+    thresholdWeeklyPercent: number;
+}
+export interface ApiConfig {
+    usage: boolean;
+}
+export interface RegistryData {
+    version: 1;
+    autoSwitch: AutoSwitchConfig;
+    api: ApiConfig;
+    activeAccountName?: string;
+    accounts: Record<string, AccountRegistryEntry>;
+}
+export interface ParsedAuthSnapshot {
+    authMode: "chatgpt" | "apikey" | "unknown";
+    email?: string;
+    accountId?: string;
+    userId?: string;
+    planType?: string;
+    accessToken?: string;
+}
+export interface StatusReport {
+    autoSwitchEnabled: boolean;
+    serviceState: "active" | "inactive" | "unknown";
+    threshold5hPercent: number;
+    thresholdWeeklyPercent: number;
+    usageMode: "api" | "local";
+}
+export interface AutoSwitchRunResult {
+    switched: boolean;
+    fromAccount?: string;
+    toAccount?: string;
+    reason: string;
+}
+export interface AccountMapping {
+    name: string;
+    active: boolean;
+    email?: string;
+    accountId?: string;
+    userId?: string;
+    planType?: string;
+    lastUsageAt?: string;
+    usageSource?: UsageSource;
+}

package/dist/lib/accounts/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_THRESHOLD_WEEKLY_PERCENT = exports.DEFAULT_THRESHOLD_5H_PERCENT = void 0;
+exports.DEFAULT_THRESHOLD_5H_PERCENT = 10;
+exports.DEFAULT_THRESHOLD_WEEKLY_PERCENT = 5;

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

@@ -0,0 +1,10 @@
+import { ParsedAuthSnapshot, RateLimitWindow, UsageSnapshot } from "./types";
+export declare function resolveRateWindow(snapshot: UsageSnapshot | undefined, minutes: number, fallbackPrimary: boolean): RateLimitWindow | undefined;
+export declare function remainingPercent(window: RateLimitWindow | undefined, nowSeconds: number): number | undefined;
+export declare function usageScore(snapshot: UsageSnapshot | undefined, nowSeconds: number): number | undefined;
+export declare function shouldSwitchCurrent(snapshot: UsageSnapshot | undefined, thresholds: {
+    threshold5hPercent: number;
+    thresholdWeeklyPercent: number;
+}, nowSeconds: number): boolean;
+export declare function fetchUsageFromApi(snapshotInfo: ParsedAuthSnapshot): Promise<UsageSnapshot | null>;
+export declare function fetchUsageFromLocal(codexDir: string): Promise<UsageSnapshot | null>;