codex-multi-auth 2.17.0 → 2.17.3

package/dist/lib/auth/auth.js

@@ -33,6 +33,26 @@ const OAUTH_SENSITIVE_QUERY_PARAMS = [
     "code",
     "code_challenge",
     "code_verifier",
+    "access_token",
+    "id_token",
+    "refresh_token",
+    "token",
+    "device_auth_id",
+    "user_code",
+    "authorization_code",
+    "client_secret",
+    "password",
+    // Credential-carrying names the logger's SENSITIVE_KEYS already masks:
+    // keep the query-key set aligned so they cannot reach a log either.
+    "api_key",
+    "apikey",
+    "authorization",
+    "credential",
+    "credentials",
+    "secret",
+    "assertion",
+    "client_assertion",
+    "id_token_hint",
 ];
 function getOAuthResponseLogMetadata(rawResponse) {
     if (Array.isArray(rawResponse)) {
@@ -55,13 +75,118 @@ const OAUTH_SENSITIVE_BODY_KEYS = [
     "id_token",
     "idToken",
     "codeVerifier",
+    "code_verifier",
+    "code_challenge",
+    "codeChallenge",
     "token",
     "code",
-    "code_verifier",
+    "state",
+    "device_auth_id",
+    "deviceAuthId",
+    "user_code",
+    "userCode",
+    "authorization_code",
+    "authorizationCode",
+    "client_secret",
+    "clientSecret",
+    "password",
+    // Credential-carrying names the logger's SENSITIVE_KEYS already masks:
+    // keep the body-key set aligned so they cannot reach a log either.
+    "api_key",
+    "apiKey",
+    "apikey",
+    "authorization",
+    "credential",
+    "credentials",
+    "secret",
+    "assertion",
+    "client_assertion",
+    "clientAssertion",
+    "id_token_hint",
+    "idTokenHint",
+];
+function normalizeOAuthSensitiveKey(key) {
+    return key.toLowerCase().replace(/[\s_-]/g, "");
+}
+const OAUTH_SENSITIVE_KEY_SET = new Set([...OAUTH_SENSITIVE_BODY_KEYS, ...OAUTH_SENSITIVE_QUERY_PARAMS].map(normalizeOAuthSensitiveKey));
+// A normalized key is also sensitive when it *ends* with a compound secret
+// name — `x-api-key`, `x-client-secret`, `my-refresh-token`,
+// `x-ms-token-aad-id-token` are still credentials. Bare `code`/`state`/`token`
+// are excluded so `error_code`, `csrf_token`, `session_state`, `valid_token`
+// and `api_keys` keep their documented over-redaction protection.
+const OAUTH_SENSITIVE_KEY_SUFFIXES = [
+    "accesstoken",
+    "refreshtoken",
+    "idtoken",
+    "clientsecret",
+    "clientassertion",
+    "apikey",
+    "authorizationcode",
+    "codechallenge",
+    "codeverifier",
+    "deviceauthid",
+    "usercode",
+    "idtokenhint",
+    "authorization",
+    "credential",
+    "credentials",
+    "assertion",
+    "password",
+    "passwords",
+    "secret",
 ];
+function isOAuthSensitiveKey(key) {
+    const normalized = normalizeOAuthSensitiveKey(key);
+    return (OAUTH_SENSITIVE_KEY_SET.has(normalized) ||
+        OAUTH_SENSITIVE_KEY_SUFFIXES.some((suffix) => normalized.endsWith(suffix)));
+}
+// Separator inside a compound key spelling: whitespace, `_`, `-`, `+`, and the
+// percent-encoded space all collapse under normalizeOAuthSensitiveKey, so
+// "client-secret", "ACCESS TOKEN" and "access%20token" must match too.
+const OAUTH_KEY_SEPARATOR = "(?:[\\s_+-]|%20)*";
+// Free-text key shapes. `code`/`state`/`token` need a non-word boundary so
+// longer names like `error_code`/`device_code`/`csrf_token` are untouched.
+const OAUTH_TEXT_SECRET_KEY_PATTERN = [
+    `(?:refresh|access|id)${OAUTH_KEY_SEPARATOR}token`,
+    `code${OAUTH_KEY_SEPARATOR}(?:challenge|verifier)`,
+    `device${OAUTH_KEY_SEPARATOR}auth${OAUTH_KEY_SEPARATOR}id`,
+    `user${OAUTH_KEY_SEPARATOR}code`,
+    `authorization${OAUTH_KEY_SEPARATOR}code`,
+    `client${OAUTH_KEY_SEPARATOR}secret`,
+    `api${OAUTH_KEY_SEPARATOR}key`,
+    `client${OAUTH_KEY_SEPARATOR}assertion`,
+    `id${OAUTH_KEY_SEPARATOR}token${OAUTH_KEY_SEPARATOR}hint`,
+    "authorization",
+    "credentials?",
+    "assertion",
+    "password",
+    "secret",
+    "state",
+    "token",
+    "code",
+].join("|");
 function scrubTokenLikeSubstrings(value) {
-    let scrubbed = value.replace(/(\b(?:refresh|access|id)[_-]?token\s*[:=]\s*)([^\s,;"'}]{8,})/gi, (_match, prefix) => `${prefix}***REDACTED***`);
-    scrubbed = scrubbed.replace(/\b(?:RT|AT)_ch_[A-Za-z0-9_-]{20,}\b/g, "***REDACTED***");
+    // Bearer runs first: in a "key: Bearer <jwt>" shape the key pass below
+    // would otherwise consume the literal word "Bearer" as its value and
+    // strand the token behind it.
+    let scrubbed = value.replace(/\bBearer(?:[\s+]|%20)+[A-Za-z0-9._~+/=-]{8,4096}/gi, "Bearer ***REDACTED***");
+    // `key <sep> value` in free text. Quoted keys and encoded separator gaps
+    // (%20/%22/%27) are tolerated; percent-encoded `:`/`=` (%3A/%3D, plus the
+    // double-encoded %253A/%253D) count as separators, and a key directly
+    // behind a %XX escape still counts as boundary (the escape itself is the
+    // delimiter). `_`/`-` are deliberately absent from the gap classes so
+    // `error_code`/`csrf-token` style names still survive. Value length is
+    // capped so a megabyte-scale run cannot exhaust the regex backtrack
+    // stack; the entropy pass below absorbs any leftover tail.
+    scrubbed = scrubbed.replace(new RegExp(`((?:(?<![A-Za-z0-9_])|(?<=%[0-9a-zA-Z]{2}))(?:${OAUTH_TEXT_SECRET_KEY_PATTERN})(?:[\\s'"+]|%2[027])*(?:[:=]|%3[ad]|%253[ad])(?:[\\s'"+]|%2[027])*)([^\\s,;"'{}&=*()<>?]{4,4096})`, "gi"), (_match, prefix) => `${prefix}***REDACTED***`);
+    // Bare high-entropy slugs (32-512 chars of token charset) with no key
+    // context. No word boundaries: consecutive chunks of a giant run each
+    // match, so a huge homogeneous value is consumed piecewise instead of
+    // overflowing the backtrack stack on one giant quantified match.
+    scrubbed = scrubbed.replace(/[A-Za-z0-9_-]{32,512}/g, "***REDACTED***");
+    // ChatGPT opaque token shapes — catches shorter RT_/AT_ values the entropy
+    // rule misses. No leading boundary: they may be glued inside identifiers.
+    scrubbed = scrubbed.replace(/(?:RT|AT)_ch_[A-Za-z0-9_-]{20,512}/g, "***REDACTED***");
     return scrubbed;
 }
 function redactSensitiveFields(value) {
@@ -69,14 +194,17 @@ function redactSensitiveFields(value) {
         return value.map((item) => redactSensitiveFields(item));
     }
     if (value !== null && typeof value === "object") {
-        const out = {};
-        const sensitiveSet = new Set(OAUTH_SENSITIVE_BODY_KEYS);
+        // Null-prototype map so a `__proto__` key stays ordinary data instead of
+        // munging the output object's prototype.
+        const out = Object.create(null);
         for (const [k, v] of Object.entries(value)) {
-            if (sensitiveSet.has(k)) {
+            if (isOAuthSensitiveKey(k)) {
                 out[k] = "***REDACTED***";
             }
             else {
-                out[k] = redactSensitiveFields(v);
+                // The key name itself can smuggle a token (an error response that
+                // echoes request fields verbatim) — scrub token shapes from it.
+                out[scrubTokenLikeSubstrings(k)] = redactSensitiveFields(v);
             }
         }
         return out;
@@ -120,34 +248,98 @@ export function sanitizeOAuthResponseBodyForLog(rawBody) {
             // Fall through to regex scrub for malformed JSON.
         }
     }
+    // Single-pass alternation over the normalized key shapes so case- and
+    // separator-varied spellings ("client-secret", "ACCESS TOKEN",
+    // "access%20token") still match when the body is not parseable JSON.
     let scrubbed = rawBody;
-    for (const key of OAUTH_SENSITIVE_BODY_KEYS) {
-        // "key":"value" style (JSON-like text)
-        const jsonPattern = new RegExp(`("${key}"\\s*:\\s*)"[^"]*"`, "g");
-        scrubbed = scrubbed.replace(jsonPattern, `$1"***REDACTED***"`);
-        // key=value style (urlencoded / query-string)
-        const urlPattern = new RegExp(`(^|[?&\\s])(${key}=)[^&\\s]+`, "g");
-        scrubbed = scrubbed.replace(urlPattern, `$1$2***REDACTED***`);
+    // "key":"value" / 'key':'value' style (JSON-like text); a stray separator
+    // may sit before the closing quote ("access_token ":).
+    scrubbed = scrubbed.replace(new RegExp(`(["'](?:${OAUTH_TEXT_SECRET_KEY_PATTERN})${OAUTH_KEY_SEPARATOR}["']\\s*:\\s*)["'][^"']*["']`, "gi"), `$1"***REDACTED***"`);
+    // key<sep>value style (urlencoded / query-string). The boundary class
+    // excludes `_` and alphanumerics so `device_code`/`error_code`/
+    // `csrf_token`/`opcode` are not redacted; a leading %XX escape does count
+    // as a boundary since it decodes to a delimiter.
+    scrubbed = scrubbed.replace(new RegExp(`(^|[^A-Za-z0-9_]|%[0-9a-zA-Z]{2})((?:${OAUTH_TEXT_SECRET_KEY_PATTERN})${OAUTH_KEY_SEPARATOR}(?:[:=]|%3[ad]|%253[ad]))[^&\\s]+`, "gi"), "$1$2***REDACTED***");
+    return scrubTokenLikeSubstrings(scrubbed);
+}
+function redactUrlSearchParamsForLog(params, depth) {
+    for (const key of new Set(params.keys())) {
+        if (isOAuthSensitiveKey(key)) {
+            params.set(key, "<redacted>");
+            continue;
+        }
+        // Non-sensitive keys still get a free-text scrub at every depth:
+        // `msg=refresh_token%3D...` or `error_description=Bearer ...` would
+        // otherwise carry embedded secrets straight into the log. URL values
+        // recurse structurally while depth remains, then fall back to the
+        // flat scrub so deeper nesting still loses its secrets.
+        const values = params.getAll(key);
+        const redactedValues = values.map((value) => /^https?:\/\//i.test(value) && depth > 0
+            ? redactOAuthUrlForLogDepth(value, depth - 1)
+            : scrubTokenLikeSubstrings(value));
+        if (redactedValues.some((v, i) => v !== values[i])) {
+            params.delete(key);
+            for (const v of redactedValues)
+                params.append(key, v);
+        }
     }
-    return scrubbed;
 }
-/**
- * Redacts sensitive OAuth query parameters for safe logging.
- * Returns the original string when parsing fails.
- */
-export function redactOAuthUrlForLog(rawUrl) {
+function redactOAuthUrlForLogDepth(rawUrl, depth) {
+    let parsed;
     try {
-        const parsed = new URL(rawUrl);
-        for (const key of OAUTH_SENSITIVE_QUERY_PARAMS) {
-            if (parsed.searchParams.has(key)) {
-                parsed.searchParams.set(key, "<redacted>");
-            }
-        }
-        return parsed.toString();
+        parsed = new URL(rawUrl);
     }
     catch {
-        return rawUrl;
+        return "<unparseable-url>";
     }
+    redactUrlSearchParamsForLog(parsed.searchParams, depth);
+    // Fragment params (#access_token=...) live in `hash`, not `searchParams`.
+    // A route-style fragment (#/path?code=...) keeps its prefix, which is
+    // itself free text that can carry secrets like `#code=...?` — scrub it
+    // rather than copying it back verbatim. The body is decoded first so a
+    // fully percent-encoded fragment cannot hide `?`/`=` from the splitter.
+    let hashBody = parsed.hash.startsWith("#") ? parsed.hash.slice(1) : "";
+    if (hashBody.includes("%")) {
+        try {
+            hashBody = decodeURIComponent(hashBody);
+        }
+        catch {
+            // Malformed escape — keep the raw fragment body.
+        }
+    }
+    if (hashBody.includes("=")) {
+        const qIndex = hashBody.indexOf("?");
+        const fragPath = qIndex >= 0 ? hashBody.slice(0, qIndex + 1) : "";
+        const fragParams = qIndex >= 0 ? hashBody.slice(qIndex + 1) : hashBody;
+        const scrubbedPath = scrubTokenLikeSubstrings(fragPath);
+        const params = new URLSearchParams(fragParams);
+        redactUrlSearchParamsForLog(params, depth);
+        const rebuilt = params.toString();
+        if (rebuilt !== fragParams || scrubbedPath !== fragPath) {
+            parsed.hash = `${scrubbedPath}${rebuilt}`;
+        }
+    }
+    else if (hashBody.length > 0) {
+        parsed.hash = scrubTokenLikeSubstrings(hashBody);
+    }
+    if (parsed.username)
+        parsed.username = "***";
+    if (parsed.password)
+        parsed.password = "***";
+    const scrubbedHost = scrubTokenLikeSubstrings(parsed.hostname);
+    if (scrubbedHost !== parsed.hostname)
+        parsed.hostname = scrubbedHost;
+    parsed.pathname = scrubTokenLikeSubstrings(parsed.pathname);
+    return parsed.toString();
+}
+/**
+ * Redacts sensitive OAuth parameters for safe logging: query keys match
+ * case-insensitively, fragment and nested-URL params are covered, userinfo is
+ * masked, and unparseable input collapses to `<unparseable-url>` so the raw
+ * string can never reach a log verbatim.
+ */
+export function redactOAuthUrlForLog(rawUrl) {
+    return redactOAuthUrlForLogDepth(rawUrl, 1);
 }
 /**
  * Generate a random state value for OAuth flow

package/dist/lib/auth/browser.d.ts

@@ -36,4 +36,3 @@ export declare function openBrowserUrl(url: string): boolean;
  * @returns `true` if a clipboard command was launched, `false` otherwise
  */
 export declare function copyTextToClipboard(text: string): boolean;
-//# sourceMappingURL=browser.d.ts.map

package/dist/lib/auth/callback-guidance.d.ts

@@ -36,4 +36,3 @@ export type CallbackFailureContext = {
  * @returns Guidance lines. Empty strings are intentional blank separators.
  */
 export declare function describeCallbackFailure(reason: CallbackFailureReason, context?: CallbackFailureContext): string[];
-//# sourceMappingURL=callback-guidance.d.ts.map

package/dist/lib/auth/device-auth.d.ts

@@ -39,4 +39,3 @@ export declare function requestDeviceAuthorization(options?: DeviceAuthFlowOptio
 export declare function pollDeviceAuthorization(deviceCode: DeviceAuthCode, options?: DeviceAuthFlowOptions): Promise<DeviceAuthCompletionResult>;
 export declare function runDeviceAuthFlow(options?: DeviceAuthFlowOptions): Promise<TokenResult>;
 export {};
-//# sourceMappingURL=device-auth.d.ts.map

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

@@ -1,4 +1,3 @@
 export * from "./auth.js";
 export { runDeviceAuthFlow } from "./device-auth.js";
 export type { DeviceAuthFlowOptions } from "./device-auth.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/auth/org-override.d.ts

@@ -16,4 +16,3 @@
  * @returns the trimmed effective override, or null when neither source provides one
  */
 export declare function resolveOrgOverride(explicitOrg?: string, env?: NodeJS.ProcessEnv): string | null;
-//# sourceMappingURL=org-override.d.ts.map

package/dist/lib/auth/server.d.ts

@@ -6,7 +6,7 @@ import type { OAuthServerInfo } from "../types.js";
  * and retains a single authorization code on the server instance until consumed via `waitForCode`.
  * Only one code is stored at a time; call `close` to abort polling and shut down the server.
  *
- * On platforms such as Windows, binding to localhost:1455 may fail if another process holds the port
+ * On platforms such as Windows, binding the callback port may fail if another process holds it
  * or if firewall/antivirus restrictions prevent local binding; in that case the returned `ready`
  * flag is `false` to allow a manual paste fallback.
  *
@@ -21,4 +21,3 @@ import type { OAuthServerInfo } from "../types.js";
 export declare function startLocalOAuthServer({ state, }: {
     state: string;
 }): Promise<OAuthServerInfo>;
-//# sourceMappingURL=server.d.ts.map

package/dist/lib/auth/server.js

@@ -7,6 +7,22 @@ import { AUTH_REDIRECT } from "./auth.js";
 // Resolve path to oauth-success.html (one level up from auth/ subfolder)
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const successHtml = fs.readFileSync(path.join(__dirname, "..", "oauth-success.html"), "utf-8");
+/**
+ * Host the callback listener actually binds.
+ *
+ * The registered redirect URI keeps its registered host name
+ * (`http://localhost:1455/auth/callback`), but the LISTEN side pins a numeric
+ * IPv4 loopback: Node resolves a listen host through DNS, and on a dual-stack
+ * host "localhost" may resolve to ::1 first (leaving 127.0.0.1 clients unable
+ * to reach the callback) or — with a hostile hosts-file entry — somewhere
+ * off-box entirely. We therefore bind BOTH numeric loopbacks: whichever family
+ * a resolver picks lands on this listener, and a holder of the other family's
+ * same port still surfaces as EADDRINUSE instead of silently receiving the
+ * callback code.
+ */
+const OAUTH_BIND_HOSTS = AUTH_REDIRECT.host === "localhost"
+    ? ["::1", "127.0.0.1"]
+    : [AUTH_REDIRECT.host];
 /**
  * Start a local HTTP server that captures an OAuth authorization code sent to /auth/callback.
  *
@@ -14,7 +30,7 @@ const successHtml = fs.readFileSync(path.join(__dirname, "..", "oauth-success.ht
  * and retains a single authorization code on the server instance until consumed via `waitForCode`.
  * Only one code is stored at a time; call `close` to abort polling and shut down the server.
  *
- * On platforms such as Windows, binding to localhost:1455 may fail if another process holds the port
+ * On platforms such as Windows, binding the callback port may fail if another process holds it
  * or if firewall/antivirus restrictions prevent local binding; in that case the returned `ready`
  * flag is `false` to allow a manual paste fallback.
  *
@@ -26,7 +42,7 @@ const successHtml = fs.readFileSync(path.join(__dirname, "..", "oauth-success.ht
  *          function to abort polling and close the server, and `waitForCode` which returns
  *          `{ code: string }` when a code becomes available or `null` on timeout/abort.
  */
-export function startLocalOAuthServer({ state, }) {
+export async function startLocalOAuthServer({ state, }) {
     let pollAborted = false;
     // Capture the authorization code/state in per-call closure variables rather
     // than mutating the shared http.Server instance. Two logins in the same
@@ -35,7 +51,7 @@ export function startLocalOAuthServer({ state, }) {
     // independent.
     let capturedCode;
     let capturedState;
-    const server = http.createServer((req, res) => {
+    const requestHandler = (req, res) => {
         try {
             const url = new URL(req.url || "", AUTH_REDIRECT.origin);
             if (url.pathname !== AUTH_REDIRECT.path) {
@@ -72,58 +88,89 @@ export function startLocalOAuthServer({ state, }) {
             res.statusCode = 500;
             res.end("Internal error");
         }
-    });
-    server.unref();
-    return new Promise((resolve) => {
-        server
-            .listen(AUTH_REDIRECT.port, AUTH_REDIRECT.host, () => {
-            resolve({
-                port: AUTH_REDIRECT.port,
-                ready: true,
-                close: () => {
-                    pollAborted = true;
-                    server.close();
-                },
-                waitForCode: async (expectedState) => {
-                    const POLL_INTERVAL_MS = 100;
-                    const TIMEOUT_MS = 5 * 60 * 1000;
-                    const maxIterations = Math.floor(TIMEOUT_MS / POLL_INTERVAL_MS);
-                    const poll = () => new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-                    for (let i = 0; i < maxIterations; i++) {
-                        if (pollAborted)
-                            return null;
-                        const lastCode = capturedCode;
-                        if (lastCode) {
-                            if (capturedState !== expectedState) {
-                                logWarn("Discarding OAuth callback due to state mismatch in waitForCode");
-                                return null;
-                            }
-                            return { code: lastCode };
-                        }
-                        await poll();
-                    }
-                    logWarn("OAuth poll timeout after 5 minutes");
-                    return null;
-                },
+    };
+    const attempts = OAUTH_BIND_HOSTS.map((host) => {
+        const candidate = http.createServer(requestHandler);
+        candidate.unref();
+        const bound = new Promise((settle) => {
+            candidate.on("error", (err) => {
+                settle({ server: candidate, ok: false, code: err?.code });
             });
-        })
-            .on("error", (err) => {
-            logError(`Failed to bind ${AUTH_REDIRECT.origin} (${err?.code}). Falling back to manual paste.`);
-            resolve({
-                port: AUTH_REDIRECT.port,
-                ready: false,
-                bindErrorCode: err?.code,
-                close: () => {
-                    pollAborted = true;
-                    try {
-                        server.close();
-                    }
-                    catch (closeErr) {
-                        logError(`Failed to close OAuth server: ${closeErr?.message ?? String(closeErr)}`);
-                    }
-                },
-                waitForCode: (_expectedState) => Promise.resolve(null),
+            candidate.listen(AUTH_REDIRECT.port, host, () => {
+                settle({ server: candidate, ok: true });
             });
         });
+        return { candidate, bound };
     });
+    const servers = attempts.map((attempt) => attempt.candidate);
+    const closeAll = () => {
+        for (const candidate of servers) {
+            try {
+                candidate.close();
+            }
+            catch (closeErr) {
+                logError(`Failed to close OAuth server: ${closeErr?.message ?? String(closeErr)}`);
+            }
+        }
+    };
+    const waitForCode = async (expectedState) => {
+        const POLL_INTERVAL_MS = 100;
+        const TIMEOUT_MS = 5 * 60 * 1000;
+        const maxIterations = Math.floor(TIMEOUT_MS / POLL_INTERVAL_MS);
+        const poll = () => new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+        for (let i = 0; i < maxIterations; i++) {
+            if (pollAborted)
+                return null;
+            const lastCode = capturedCode;
+            if (lastCode) {
+                if (capturedState !== expectedState) {
+                    logWarn("Discarding OAuth callback due to state mismatch in waitForCode");
+                    return null;
+                }
+                return { code: lastCode };
+            }
+            await poll();
+        }
+        logWarn("OAuth poll timeout after 5 minutes");
+        return null;
+    };
+    const outcomes = await Promise.all(attempts.map((attempt) => attempt.bound));
+    const inUse = outcomes.find((outcome) => outcome.code === "EADDRINUSE");
+    const bound = outcomes
+        .filter((outcome) => outcome.ok)
+        .map((outcome) => outcome.server);
+    if (inUse || bound.length === 0) {
+        // A holder on ANY loopback family conflicts with the registered callback
+        // URI — surface it instead of degrading to whichever family was free.
+        // When nothing bound, report the first error observed.
+        const code = inUse?.code ?? outcomes.find((outcome) => !outcome.ok)?.code;
+        logError(`Failed to bind ${AUTH_REDIRECT.origin} (${code}). Falling back to manual paste.`);
+        for (const candidate of bound) {
+            try {
+                candidate.close();
+            }
+            catch {
+                // Best effort — the port was never ours to keep anyway.
+            }
+        }
+        return {
+            port: AUTH_REDIRECT.port,
+            ready: false,
+            bindErrorCode: code,
+            close: () => {
+                pollAborted = true;
+                closeAll();
+            },
+            waitForCode: (_expectedState) => Promise.resolve(null),
+        };
+    }
+    return {
+        port: AUTH_REDIRECT.port,
+        ready: true,
+        close: () => {
+            pollAborted = true;
+            closeAll();
+        },
+        waitForCode,
+    };
 }

package/dist/lib/auth/token-utils.d.ts

@@ -125,4 +125,3 @@ export declare function resolveRuntimeRequestIdentity(input: {
  */
 export declare function sanitizeEmail(email: string | undefined): string | undefined;
 export {};
-//# sourceMappingURL=token-utils.d.ts.map

package/dist/lib/auth-rate-limit.d.ts

@@ -17,4 +17,3 @@ export declare class AuthRateLimitError extends Error {
     constructor(accountId: string, attemptsRemaining: number, resetAfterMs: number);
 }
 export declare function checkAuthRateLimit(accountId: string): void;
-//# sourceMappingURL=auth-rate-limit.d.ts.map

package/dist/lib/budget-guard.d.ts

@@ -32,9 +32,23 @@ export interface BudgetGuardEvaluation {
 export declare function getBudgetGuardPath(): string;
 export declare function normalizeBudgetKey(value: string): string | null;
 export declare function loadBudgetGuardStore(): Promise<BudgetGuardStore>;
-export declare function saveBudgetGuardStore(store: BudgetGuardStore): Promise<void>;
+export declare function saveBudgetGuardStore(store: BudgetGuardStore, baseline?: BudgetGuardStore): Promise<void>;
+/**
+ * Run a budget-guard read→mutate→write inside the write queue (in-process
+ * serialization) AND the cross-process lock directory, with mtime CAS retry:
+ * every attempt re-reads the freshest on-disk store and re-applies `mutate`
+ * before writing — so a mutation is applied to the latest committed state
+ * rather than merged by whole-record `updatedAt`, which can drop or clobber
+ * a concurrent process's change to the same key. `mutate` must be
+ * re-appliable across retries (apply precomputed work onto the store it is
+ * handed, don't capture mutated state). Prefer this over load→upsert→save
+ * whenever the caller is mutating rather than importing a foreign store.
+ */
+export declare function updateBudgetGuardStore<T>(mutate: (store: BudgetGuardStore) => {
+    result: T;
+    dirty: boolean;
+}): Promise<T>;
 export declare function upsertBudgetLimit(store: BudgetGuardStore, limit: Omit<BudgetLimit, "updatedAt">, now?: number): BudgetLimit;
 export declare function getBudgetWindowStart(window: BudgetWindow, now?: number): number;
 export declare function evaluateBudgetGuard(limit: BudgetLimit, summary: UsageSummary): BudgetGuardEvaluation;
 export declare function resetBudgetGuardWriteQueueForTests(): void;
-//# sourceMappingURL=budget-guard.d.ts.map