it("preserves absolute millisecond timestamps", () => {

expect(normalizeOAuthExpires(1_700_000_000_000)).toBe(1_700_000_000_000);

});

it("rejects unsafe and malformed expiry values", () => {

expect(normalizeOAuthExpires(Number.POSITIVE_INFINITY)).toBeUndefined();

expect(normalizeOAuthExpires(Number.MAX_SAFE_INTEGER + 1)).toBeUndefined();

expect(normalizeOAuthExpires("3600s")).toBeUndefined();

});

});

import { randomBytes, randomUUID } from "node:crypto";

import { resolveExpiresAtMsFromDurationOrEpoch } from "openclaw/plugin-sdk/number-runtime";

import { generatePkceVerifierChallenge, toFormUrlEncoded } from "openclaw/plugin-sdk/provider-auth";

import { ensureGlobalUndiciEnvProxyDispatcher } from "openclaw/plugin-sdk/runtime-env";

* Normalize MiniMax token endpoint `expired_in` values to the auth-profile

* contract: absolute Unix milliseconds.

*/

export function normalizeOAuthExpires(expiredIn: number, now = Date.now()): number {

if (expiredIn < MINIMAX_RELATIVE_EXPIRY_SECONDS_THRESHOLD) {

return now + expiredIn * 1000;

}

if (expiredIn < MINIMAX_ABSOLUTE_EXPIRY_MS_THRESHOLD) {

return expiredIn * 1000;

}

return expiredIn;

export function normalizeOAuthExpires(expiredIn: unknown, now = Date.now()): number | undefined {

return resolveExpiresAtMsFromDurationOrEpoch(expiredIn, {

nowMs: now,

relativeSecondsThreshold: MINIMAX_RELATIVE_EXPIRY_SECONDS_THRESHOLD,

absoluteMillisecondsThreshold: MINIMAX_ABSOLUTE_EXPIRY_MS_THRESHOLD,

});

}

function generatePkce(): { verifier: string; challenge: string; state: string } {

status: string;

access_token?: string | null;

refresh_token?: string | null;

expired_in?: number | null;

expired_in?: unknown;

token_type?: string;

resource_url?: string;

notification_message?: string;

if (!tokenPayload.access_token || !tokenPayload.refresh_token || !tokenPayload.expired_in) {

return { status: "error", message: "MiniMax OAuth returned incomplete token payload." };

}

const expires = normalizeOAuthExpires(tokenPayload.expired_in);

if (expires === undefined) {

return { status: "error", message: "MiniMax OAuth returned invalid token expiry." };

}

return {

status: "success",

token: {

access: tokenPayload.access_token,

refresh: tokenPayload.refresh_token,

expires: normalizeOAuthExpires(tokenPayload.expired_in),

expires,

resourceUrl: tokenPayload.resource_url,

notification_message: tokenPayload.notification_message,

},

positiveSecondsToSafeMilliseconds,

nonNegativeSecondsToSafeMilliseconds,

resolveExpiresAtMsFromDurationSeconds,

resolveExpiresAtMsFromDurationOrEpoch,

resolveExpiresAtMsFromEpochSeconds,

} from "../shared/number-coercion.js";

positiveSecondsToSafeMilliseconds,

nonNegativeSecondsToSafeMilliseconds,

resolveExpiresAtMsFromDurationSeconds,

resolveExpiresAtMsFromDurationOrEpoch,

resolveExpiresAtMsFromEpochSeconds,

} from "../shared/number-coercion.js";

export { MAX_TCP_PORT, parseTcpPort } from "../infra/tcp-port.js";

positiveSecondsToSafeMilliseconds,

resolveIntegerOption,

resolveExpiresAtMsFromDurationSeconds,

resolveExpiresAtMsFromDurationOrEpoch,

resolveExpiresAtMsFromEpochSeconds,

resolveNonNegativeIntegerOption,

resolveOptionalIntegerOption,

expect(resolveExpiresAtMsFromEpochSeconds("1e309")).toBeUndefined();

});

test("mixed expiry helper handles relative seconds, epoch seconds, and absolute milliseconds", () => {

expect(resolveExpiresAtMsFromDurationOrEpoch(86_400, { nowMs: 1_700_000_000_000 })).toBe(

1_700_086_400_000,

);

expect(resolveExpiresAtMsFromDurationOrEpoch(1_700_000_000)).toBe(1_700_000_000_000);

expect(resolveExpiresAtMsFromDurationOrEpoch(1_700_000_000_000)).toBe(1_700_000_000_000);

expect(resolveExpiresAtMsFromDurationOrEpoch(Number.POSITIVE_INFINITY)).toBeUndefined();

expect(resolveExpiresAtMsFromDurationOrEpoch(Number.MAX_SAFE_INTEGER + 1)).toBeUndefined();

});

test("integer option helpers floor finite values and fall back for non-finite values", () => {

expect(resolveIntegerOption(7.9, 1, { min: 1, max: 10 })).toBe(7);

expect(resolveIntegerOption(Number.NaN, 4.9, { min: 1 })).toBe(4);

const expiresAt = epochMs - (opts.bufferMs ?? 0);

return Number.isSafeInteger(expiresAt) ? expiresAt : undefined;

}

export function resolveExpiresAtMsFromDurationOrEpoch(

value: unknown,

opts: {

nowMs?: number;

relativeSecondsThreshold?: number;

absoluteMillisecondsThreshold?: number;

} = {},

): number | undefined {

const parsed = parseStrictPositiveInteger(value);

if (parsed === undefined) {

return undefined;

}

const relativeSecondsThreshold = opts.relativeSecondsThreshold ?? 1_000_000_000;

if (parsed < relativeSecondsThreshold) {

return resolveExpiresAtMsFromDurationSeconds(parsed, { nowMs: opts.nowMs });

}

const absoluteMillisecondsThreshold = opts.absoluteMillisecondsThreshold ?? 1_000_000_000_000;

if (parsed < absoluteMillisecondsThreshold) {

return positiveSecondsToSafeMilliseconds(parsed);

}

return parsed;

}