* GitHub Copilot OAuth flow

*/

import {

parseStrictNonNegativeInteger,

parseStrictPositiveInteger,

} from "../../../infra/parse-finite-number.js";

import type { Model } from "../../types.js";

import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderInterface } from "./types.js";

device_code: string;

user_code: string;

verification_uri: string;

interval: number;

expires_in: number;

intervalMs: number;

expiresAt: number;

};

type DeviceTokenSuccessResponse = {

timeoutMs?: number;

};

function secondsToSafeMilliseconds(value: unknown): number | undefined {

const seconds = parseStrictPositiveInteger(value);

if (seconds === undefined) {

return undefined;

}

const milliseconds = seconds * 1000;

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

}

function nonNegativeSecondsToSafeMilliseconds(value: unknown): number | undefined {

const seconds = parseStrictNonNegativeInteger(value);

if (seconds === undefined) {

return undefined;

}

const milliseconds = seconds * 1000;

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

}

function resolveExpiresAtFromDurationSeconds(value: unknown): number | undefined {

const durationMs = secondsToSafeMilliseconds(value);

if (durationMs === undefined) {

return undefined;

}

const expiresAt = Date.now() + durationMs;

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

}

function resolveExpiresAtFromEpochSeconds(value: unknown): number | undefined {

const epochMs = secondsToSafeMilliseconds(value);

if (epochMs === undefined) {

return undefined;

}

const expiresAt = epochMs - 5 * 60 * 1000;

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

}

export function normalizeDomain(input: string): string | null {

const trimmed = input.trim();

if (!trimmed) {

const userCode = (data as Record<string, unknown>).user_code;

const verificationUri = (data as Record<string, unknown>).verification_uri;

const interval = (data as Record<string, unknown>).interval;

const expiresIn = (data as Record<string, unknown>).expires_in;

const intervalMs = nonNegativeSecondsToSafeMilliseconds(interval);

const expiresAt = resolveExpiresAtFromDurationSeconds(

(data as Record<string, unknown>).expires_in,

);

if (

typeof deviceCode !== "string" ||

typeof userCode !== "string" ||

typeof verificationUri !== "string" ||

typeof interval !== "number" ||

typeof expiresIn !== "number"

intervalMs === undefined ||

expiresAt === undefined

) {

throw new Error("Invalid device code response fields");

}

device_code: deviceCode,

user_code: userCode,

verification_uri: verificationUri,

interval,

expires_in: expiresIn,

intervalMs,

expiresAt,

};

}

async function pollForGitHubAccessToken(

domain: string,

deviceCode: string,

intervalSeconds: number,

expiresIn: number,

intervalMs: number,

deadline: number,

signal?: AbortSignal,

) {

const urls = getUrls(domain);

const deadline = Date.now() + expiresIn * 1000;

let intervalMs = Math.max(1000, Math.floor(intervalSeconds * 1000));

let pollingIntervalMs = Math.max(1000, intervalMs);

let intervalMultiplier = INITIAL_POLL_INTERVAL_MULTIPLIER;

let slowDownResponses = 0;

}

const remainingMs = deadline - Date.now();

const waitMs = Math.min(Math.ceil(intervalMs * intervalMultiplier), remainingMs);

const waitMs = Math.min(Math.ceil(pollingIntervalMs * intervalMultiplier), remainingMs);

await abortableSleep(waitMs, signal);

const raw = await fetchJson(

if (error === "slow_down") {

slowDownResponses += 1;

intervalMs =

typeof interval === "number" && interval > 0

? interval * 1000

: Math.max(1000, intervalMs + 5000);

const slowDownIntervalMs = secondsToSafeMilliseconds(interval);

pollingIntervalMs =

slowDownIntervalMs === undefined

? Math.max(1000, pollingIntervalMs + 5000)

: Math.max(1000, slowDownIntervalMs);

intervalMultiplier = SLOW_DOWN_POLL_INTERVAL_MULTIPLIER;

continue;

}

}

const token = (raw as Record<string, unknown>).token;

const expiresAt = (raw as Record<string, unknown>).expires_at;

const expires = resolveExpiresAtFromEpochSeconds((raw as Record<string, unknown>).expires_at);

if (typeof token !== "string" || typeof expiresAt !== "number") {

if (typeof token !== "string" || expires === undefined) {

throw new Error("Invalid Copilot token response fields");

}

return {

refresh: refreshToken,

access: token,

expires: expiresAt * 1000 - 5 * 60 * 1000,

expires,

enterpriseUrl: enterpriseDomain,

};

}

const githubAccessToken = await pollForGitHubAccessToken(

domain,

device.device_code,

device.interval,

device.expires_in,

device.intervalMs,

device.expiresAt,

options.signal,

);

const credentials = await refreshGitHubCopilotToken(