oc-chatgpt-multi-auth 5.3.2 → 5.3.3

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA0I/D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MAosG/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA0I/D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MAu7G/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}

package/dist/index.js

@@ -226,7 +226,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
         await withAccountStorageTransaction(async (loadedStorage, persist) => {
             const now = Date.now();
             const stored = replaceAll ? null : loadedStorage;
-            const accounts = stored?.accounts ? [...stored.accounts] : [];
+            let accounts = stored?.accounts ? [...stored.accounts] : [];
             const pushIndex = (map, key, index) => {
                 const existing = map.get(key);
                 if (existing) {
@@ -241,6 +241,93 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                 const [onlyIndex] = indices;
                 return typeof onlyIndex === "number" ? onlyIndex : undefined;
             };
+            const pickNewestAccountIndex = (existingIndex, candidateIndex) => {
+                const existing = accounts[existingIndex];
+                const candidate = accounts[candidateIndex];
+                if (!existing)
+                    return candidateIndex;
+                if (!candidate)
+                    return existingIndex;
+                const existingLastUsed = existing.lastUsed ?? 0;
+                const candidateLastUsed = candidate.lastUsed ?? 0;
+                if (candidateLastUsed > existingLastUsed)
+                    return candidateIndex;
+                if (candidateLastUsed < existingLastUsed)
+                    return existingIndex;
+                const existingAddedAt = existing.addedAt ?? 0;
+                const candidateAddedAt = candidate.addedAt ?? 0;
+                return candidateAddedAt >= existingAddedAt ? candidateIndex : existingIndex;
+            };
+            const mergeAccountRecords = (targetIndex, sourceIndex) => {
+                const target = accounts[targetIndex];
+                const source = accounts[sourceIndex];
+                if (!target || !source)
+                    return;
+                const targetLastUsed = target.lastUsed ?? 0;
+                const sourceLastUsed = source.lastUsed ?? 0;
+                const targetAddedAt = target.addedAt ?? 0;
+                const sourceAddedAt = source.addedAt ?? 0;
+                const sourceIsNewer = sourceLastUsed > targetLastUsed ||
+                    (sourceLastUsed === targetLastUsed && sourceAddedAt > targetAddedAt);
+                const newer = sourceIsNewer ? source : target;
+                const older = sourceIsNewer ? target : source;
+                const mergedRateLimitResetTimes = {};
+                const rateLimitResetKeys = new Set([
+                    ...Object.keys(older.rateLimitResetTimes ?? {}),
+                    ...Object.keys(newer.rateLimitResetTimes ?? {}),
+                ]);
+                for (const key of rateLimitResetKeys) {
+                    const olderRaw = older.rateLimitResetTimes?.[key];
+                    const newerRaw = newer.rateLimitResetTimes?.[key];
+                    const olderValue = typeof olderRaw === "number" && Number.isFinite(olderRaw) ? olderRaw : 0;
+                    const newerValue = typeof newerRaw === "number" && Number.isFinite(newerRaw) ? newerRaw : 0;
+                    const resolved = Math.max(olderValue, newerValue);
+                    if (resolved > 0) {
+                        mergedRateLimitResetTimes[key] = resolved;
+                    }
+                }
+                const mergedEnabled = target.enabled === false || source.enabled === false
+                    ? false
+                    : target.enabled ?? source.enabled;
+                const targetCoolingDownUntil = typeof target.coolingDownUntil === "number" && Number.isFinite(target.coolingDownUntil)
+                    ? target.coolingDownUntil
+                    : 0;
+                const sourceCoolingDownUntil = typeof source.coolingDownUntil === "number" && Number.isFinite(source.coolingDownUntil)
+                    ? source.coolingDownUntil
+                    : 0;
+                const mergedCoolingDownUntilValue = Math.max(targetCoolingDownUntil, sourceCoolingDownUntil);
+                const mergedCoolingDownUntil = mergedCoolingDownUntilValue > 0 ? mergedCoolingDownUntilValue : undefined;
+                const mergedCooldownReason = (() => {
+                    if (mergedCoolingDownUntilValue <= 0) {
+                        return target.cooldownReason ?? source.cooldownReason;
+                    }
+                    if (sourceCoolingDownUntil > targetCoolingDownUntil) {
+                        return source.cooldownReason ?? target.cooldownReason;
+                    }
+                    if (targetCoolingDownUntil > sourceCoolingDownUntil) {
+                        return target.cooldownReason ?? source.cooldownReason;
+                    }
+                    return source.cooldownReason ?? target.cooldownReason;
+                })();
+                accounts[targetIndex] = {
+                    ...target,
+                    accountId: target.accountId ?? source.accountId,
+                    organizationId: target.organizationId ?? source.organizationId,
+                    accountIdSource: target.accountIdSource ?? source.accountIdSource,
+                    accountLabel: target.accountLabel ?? source.accountLabel,
+                    email: target.email ?? source.email,
+                    refreshToken: newer.refreshToken || older.refreshToken,
+                    accessToken: newer.accessToken || older.accessToken,
+                    expiresAt: newer.expiresAt ?? older.expiresAt,
+                    enabled: mergedEnabled,
+                    addedAt: Math.max(target.addedAt ?? 0, source.addedAt ?? 0),
+                    lastUsed: Math.max(target.lastUsed ?? 0, source.lastUsed ?? 0),
+                    lastSwitchReason: target.lastSwitchReason ?? source.lastSwitchReason,
+                    rateLimitResetTimes: mergedRateLimitResetTimes,
+                    coolingDownUntil: mergedCoolingDownUntil,
+                    cooldownReason: mergedCooldownReason,
+                };
+            };
             const resolveUniqueOrgScopedMatch = (indexes, accountId, refreshToken) => {
                 const byAccountId = accountId
                     ? asUniqueIndex(indexes.byAccountIdOrgScoped.get(accountId))
@@ -260,6 +347,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                 const byEmailNoOrg = new Map();
                 const byAccountIdOrgScoped = new Map();
                 const byRefreshTokenOrgScoped = new Map();
+                const byRefreshTokenGlobal = new Map();
                 for (let i = 0; i < accounts.length; i += 1) {
                     const account = accounts[i];
                     if (!account)
@@ -268,6 +356,10 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     const accountId = account.accountId?.trim();
                     const refreshToken = account.refreshToken?.trim();
                     const email = account.email?.trim();
+                    // Global refresh token index: first entry wins (keeps earliest/primary).
+                    if (refreshToken && !byRefreshTokenGlobal.has(refreshToken)) {
+                        byRefreshTokenGlobal.set(refreshToken, i);
+                    }
                     if (organizationId) {
                         byOrganizationId.set(organizationId, i);
                         if (accountId) {
@@ -295,6 +387,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     byEmailNoOrg,
                     byAccountIdOrgScoped,
                     byRefreshTokenOrgScoped,
+                    byRefreshTokenGlobal,
                 };
             };
             let identityIndexes = buildIdentityIndexes();
@@ -328,7 +421,12 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                             return byEmail;
                         }
                     }
-                    return resolveUniqueOrgScopedMatch(identityIndexes, normalizedAccountId, result.refresh);
+                    const orgScoped = resolveUniqueOrgScopedMatch(identityIndexes, normalizedAccountId, result.refresh);
+                    if (orgScoped !== undefined)
+                        return orgScoped;
+                    // Absolute last resort: same refresh token = same human account.
+                    // Catches org-scoped entries invisible to no-org lookups.
+                    return identityIndexes.byRefreshTokenGlobal.get(result.refresh);
                 })();
                 if (existingIndex === undefined) {
                     accounts.push({
@@ -351,11 +449,20 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     continue;
                 const nextEmail = accountEmail ?? existing.email;
                 const nextOrganizationId = organizationId ?? existing.organizationId;
-                const nextAccountId = normalizedAccountId ?? existing.accountId;
-                const nextAccountIdSource = normalizedAccountId
-                    ? accountIdSource ?? existing.accountIdSource
-                    : existing.accountIdSource;
-                const nextAccountLabel = accountLabel ?? existing.accountLabel;
+                const preserveOrgIdentity = typeof existing.organizationId === "string" &&
+                    existing.organizationId.trim().length > 0 &&
+                    !organizationId;
+                const nextAccountId = preserveOrgIdentity
+                    ? existing.accountId ?? normalizedAccountId
+                    : normalizedAccountId ?? existing.accountId;
+                const nextAccountIdSource = preserveOrgIdentity
+                    ? existing.accountIdSource ?? accountIdSource
+                    : normalizedAccountId
+                        ? accountIdSource ?? existing.accountIdSource
+                        : existing.accountIdSource;
+                const nextAccountLabel = preserveOrgIdentity
+                    ? existing.accountLabel ?? accountLabel
+                    : accountLabel ?? existing.accountLabel;
                 accounts[existingIndex] = {
                     ...existing,
                     accountId: nextAccountId,
@@ -370,22 +477,140 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                 };
                 identityIndexes = buildIdentityIndexes();
             }
+            const pruneRefreshTokenCollisions = () => {
+                const indicesToRemove = new Set();
+                const refreshMap = new Map();
+                for (let i = 0; i < accounts.length; i += 1) {
+                    const account = accounts[i];
+                    if (!account)
+                        continue;
+                    const refreshToken = account.refreshToken?.trim();
+                    if (!refreshToken)
+                        continue;
+                    const orgKey = account.organizationId?.trim() ?? "";
+                    let entry = refreshMap.get(refreshToken);
+                    if (!entry) {
+                        entry = { byOrg: new Map(), fallbackIndex: undefined };
+                        refreshMap.set(refreshToken, entry);
+                    }
+                    if (orgKey) {
+                        const existingIndex = entry.byOrg.get(orgKey);
+                        if (existingIndex !== undefined) {
+                            const newestIndex = pickNewestAccountIndex(existingIndex, i);
+                            const obsoleteIndex = newestIndex === existingIndex ? i : existingIndex;
+                            mergeAccountRecords(newestIndex, obsoleteIndex);
+                            indicesToRemove.add(obsoleteIndex);
+                            entry.byOrg.set(orgKey, newestIndex);
+                            continue;
+                        }
+                        entry.byOrg.set(orgKey, i);
+                        continue;
+                    }
+                    const existingFallback = entry.fallbackIndex;
+                    if (typeof existingFallback === "number") {
+                        const newestIndex = pickNewestAccountIndex(existingFallback, i);
+                        const obsoleteIndex = newestIndex === existingFallback ? i : existingFallback;
+                        mergeAccountRecords(newestIndex, obsoleteIndex);
+                        indicesToRemove.add(obsoleteIndex);
+                        entry.fallbackIndex = newestIndex;
+                        continue;
+                    }
+                    entry.fallbackIndex = i;
+                }
+                for (const entry of refreshMap.values()) {
+                    const fallbackIndex = entry.fallbackIndex;
+                    if (typeof fallbackIndex !== "number")
+                        continue;
+                    const orgIndices = Array.from(entry.byOrg.values());
+                    if (orgIndices.length === 0)
+                        continue;
+                    const [firstOrgIndex, ...otherOrgIndices] = orgIndices;
+                    if (typeof firstOrgIndex !== "number")
+                        continue;
+                    let preferredOrgIndex = firstOrgIndex;
+                    for (const orgIndex of otherOrgIndices) {
+                        preferredOrgIndex = pickNewestAccountIndex(preferredOrgIndex, orgIndex);
+                    }
+                    mergeAccountRecords(preferredOrgIndex, fallbackIndex);
+                    indicesToRemove.add(fallbackIndex);
+                }
+                if (indicesToRemove.size > 0) {
+                    accounts = accounts.filter((_, index) => !indicesToRemove.has(index));
+                }
+            };
+            const collectIdentityKeys = (account) => {
+                const keys = [];
+                const organizationId = account?.organizationId?.trim();
+                if (organizationId)
+                    keys.push(`org:${organizationId}`);
+                const accountId = account?.accountId?.trim();
+                if (accountId)
+                    keys.push(`account:${accountId}`);
+                const refreshToken = account?.refreshToken?.trim();
+                if (refreshToken)
+                    keys.push(`refresh:${refreshToken}`);
+                return keys;
+            };
+            const getStoredAccountAtIndex = (rawIndex) => {
+                const storedAccounts = stored?.accounts;
+                if (!storedAccounts)
+                    return undefined;
+                if (typeof rawIndex !== "number" || !Number.isFinite(rawIndex))
+                    return undefined;
+                const candidate = Math.floor(rawIndex);
+                if (candidate < 0 || candidate >= storedAccounts.length)
+                    return undefined;
+                return storedAccounts[candidate];
+            };
+            const storedActiveKeys = replaceAll
+                ? []
+                : collectIdentityKeys(getStoredAccountAtIndex(stored?.activeIndex));
+            const storedActiveKeysByFamily = {};
+            if (!replaceAll) {
+                for (const family of MODEL_FAMILIES) {
+                    const familyKeys = collectIdentityKeys(getStoredAccountAtIndex(stored?.activeIndexByFamily?.[family]));
+                    if (familyKeys.length > 0) {
+                        storedActiveKeysByFamily[family] = familyKeys;
+                    }
+                }
+            }
+            pruneRefreshTokenCollisions();
             if (accounts.length === 0)
                 return;
-            const activeIndex = replaceAll
+            const resolveIndexByIdentityKeys = (identityKeys) => {
+                if (!identityKeys || identityKeys.length === 0)
+                    return undefined;
+                for (const identityKey of identityKeys) {
+                    const index = accounts.findIndex((account) => collectIdentityKeys(account).includes(identityKey));
+                    if (index >= 0) {
+                        return index;
+                    }
+                }
+                return undefined;
+            };
+            const fallbackActiveIndex = replaceAll
                 ? 0
                 : typeof stored?.activeIndex === "number" && Number.isFinite(stored.activeIndex)
                     ? stored.activeIndex
                     : 0;
-            const clampedActiveIndex = Math.max(0, Math.min(activeIndex, accounts.length - 1));
+            const remappedActiveIndex = replaceAll
+                ? undefined
+                : resolveIndexByIdentityKeys(storedActiveKeys);
+            const activeIndex = remappedActiveIndex ?? fallbackActiveIndex;
+            const clampedActiveIndex = Math.max(0, Math.min(Math.floor(activeIndex), accounts.length - 1));
             const activeIndexByFamily = {};
             for (const family of MODEL_FAMILIES) {
                 const storedFamilyIndex = stored?.activeIndexByFamily?.[family];
+                const remappedFamilyIndex = replaceAll
+                    ? undefined
+                    : resolveIndexByIdentityKeys(storedActiveKeysByFamily[family]);
                 const rawFamilyIndex = replaceAll
                     ? 0
-                    : typeof storedFamilyIndex === "number" && Number.isFinite(storedFamilyIndex)
-                        ? storedFamilyIndex
-                        : clampedActiveIndex;
+                    : typeof remappedFamilyIndex === "number"
+                        ? remappedFamilyIndex
+                        : typeof storedFamilyIndex === "number" && Number.isFinite(storedFamilyIndex)
+                            ? storedFamilyIndex
+                            : clampedActiveIndex;
                 activeIndexByFamily[family] = Math.max(0, Math.min(Math.floor(rawFamilyIndex), accounts.length - 1));
             }
             await persist({
@@ -1414,7 +1639,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                     const headers = createCodexHeaders(undefined, params.accountId, params.accessToken, {
                                         model,
                                     });
-                                    headers.set("content-type", "application/json; charset=utf-8");
+                                    headers.set("content-type", "application/json");
                                     const controller = new AbortController();
                                     const timeout = setTimeout(() => controller.abort(), 15_000);
                                     let response;