@cartanova/qgrid-cli 2.10.10 → 2.11.1

package/bundle/dist/utils/providers/grok/grok-oauth.js

@@ -0,0 +1,455 @@
+import { GROK_AUTH_ISSUER, GROK_BUILD_VERSION, GROK_CHAT_PROXY_URL, GROK_DEVICE_CODE_URL, GROK_DEVICE_TOKEN_URL, GROK_OAUTH_CLIENT_ID, GROK_OAUTH_REFERRER, GROK_OAUTH_SCOPES } from "./grok-constants.js";
+import { buildGrokProxyGetHeaders, grokShellUserAgent } from "./grok-headers.js";
+import { GrokCredentials, GrokUserSubscription, decodeGrokJwt, isGrokAccessToken } from "./grok-types.js";
+import { z } from "zod";
+import { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
+//#region src/utils/providers/grok/grok-oauth.ts
+/** Login failure. `retryable` marks network/5xx failures where the same step may be retried. */
+var GrokOAuthError = class extends Error {
+	code;
+	options;
+	name = "GrokOAuthError";
+	constructor(code, message, options = {}) {
+		super(message);
+		this.code = code;
+		this.options = options;
+	}
+	get status() {
+		return this.options.status;
+	}
+	get retryable() {
+		return this.options.retryable ?? false;
+	}
+	/** OAuth `error` code, only when it is a plain lowercase identifier. */
+	get oauthError() {
+		return this.options.oauthError;
+	}
+};
+const GROK_DISCOVERY_TTL_MS = 1440 * 60 * 1e3;
+const GROK_FALLBACK_AUTHORIZATION_ENDPOINT = `${GROK_AUTH_ISSUER}/oauth2/authorize`;
+const GROK_FALLBACK_TOKEN_ENDPOINT = `${GROK_AUTH_ISSUER}/oauth2/token`;
+const DISCOVERY_TIMEOUT_MS = 1e4;
+const TOKEN_TIMEOUT_MS = 15e3;
+const USER_LOOKUP_TIMEOUT_MS = 15e3;
+const DiscoveryDocument = z.looseObject({
+	authorization_endpoint: z.string(),
+	token_endpoint: z.string()
+});
+let discoveryCache;
+/** Clears the module-level discovery cache (tests and operator resets). */
+function resetGrokDiscoveryCache() {
+	discoveryCache = void 0;
+}
+function isTrustedEndpoint(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	return url.protocol === "https:" && !url.username && !url.password && (url.hostname === "x.ai" || url.hostname.endsWith(".x.ai"));
+}
+/**
+* `GET {issuer}/.well-known/openid-configuration`, cached 24 h. Any failure uses the fallback
+* endpoints without caching them, so the next call retries discovery.
+*/
+async function getGrokOAuthEndpoints(io = {}) {
+	const fetchImpl = io.fetch ?? globalThis.fetch;
+	const now = io.now ?? Date.now;
+	const cached = discoveryCache;
+	if (cached && now() - cached.fetchedAt < 864e5) return cached.endpoints;
+	try {
+		const response = await fetchImpl(`${GROK_AUTH_ISSUER}/.well-known/openid-configuration`, {
+			method: "GET",
+			headers: {
+				accept: "application/json",
+				"user-agent": grokShellUserAgent()
+			},
+			signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS)
+		});
+		if (response.ok) {
+			const document = DiscoveryDocument.safeParse(await response.json());
+			if (document.success && isTrustedEndpoint(document.data.authorization_endpoint) && isTrustedEndpoint(document.data.token_endpoint)) {
+				const endpoints = {
+					authorizationEndpoint: document.data.authorization_endpoint,
+					tokenEndpoint: document.data.token_endpoint,
+					source: "discovery"
+				};
+				discoveryCache = {
+					endpoints,
+					fetchedAt: now()
+				};
+				return endpoints;
+			}
+		} else await response.body?.cancel().catch(() => void 0);
+	} catch {}
+	return {
+		authorizationEndpoint: GROK_FALLBACK_AUTHORIZATION_ENDPOINT,
+		tokenEndpoint: GROK_FALLBACK_TOKEN_ENDPOINT,
+		source: "fallback"
+	};
+}
+/** S256 over a base64url verifier of 32 random bytes (oidc/protocol.rs:314-320). */
+function generateGrokPkce() {
+	const codeVerifier = randomBytes(32).toString("base64url");
+	return {
+		codeVerifier,
+		codeChallenge: createHash("sha256").update(codeVerifier).digest("base64url")
+	};
+}
+/** RFC 3986 unreserved-only encoding, matching Rust `urlencoding::encode` (space → %20). */
+function encodeQueryValue(value) {
+	return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+const GROK_OAUTH_SCOPE = GROK_OAUTH_SCOPES.join(" ");
+/** Authorize URL with grok-build's query order (oidc/protocol.rs:321-366). */
+function buildGrokAuthorizeUrl(input) {
+	const search = [
+		["response_type", "code"],
+		["client_id", GROK_OAUTH_CLIENT_ID],
+		["redirect_uri", input.redirectUri],
+		["scope", GROK_OAUTH_SCOPE],
+		["code_challenge", input.codeChallenge],
+		["code_challenge_method", "S256"],
+		["state", input.state],
+		["nonce", input.nonce],
+		["referrer", GROK_OAUTH_REFERRER]
+	].map(([key, value]) => `${key}=${encodeQueryValue(value)}`).join("&");
+	return `${input.authorizationEndpoint}?${search}`;
+}
+function grokLoopbackRedirectUri(port) {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw new RangeError("redirect port must be an integer in 1..65535");
+	return `http://127.0.0.1:${port}/callback`;
+}
+async function startGrokOAuth(input) {
+	if (!input.state) throw new TypeError("state must be non-empty");
+	const endpoints = await getGrokOAuthEndpoints(input);
+	const pkce = generateGrokPkce();
+	const redirectUri = grokLoopbackRedirectUri(input.redirectPort ?? randomInt(49152, 65536));
+	return {
+		authorizeUrl: buildGrokAuthorizeUrl({
+			authorizationEndpoint: endpoints.authorizationEndpoint,
+			redirectUri,
+			codeChallenge: pkce.codeChallenge,
+			state: input.state,
+			nonce: randomUUID()
+		}),
+		verifier: pkce.codeVerifier,
+		redirectUri
+	};
+}
+const OAUTH_ERROR_CODE = /^[a-z_]{1,80}$/;
+function safeOAuthErrorCode(value) {
+	return OAUTH_ERROR_CODE.test(value) ? value : void 0;
+}
+/** Accepts the full callback URL or a bare authorization code (oidc/login.rs:30-60). */
+function parseGrokCallbackInput(input) {
+	const trimmed = input.trim();
+	if (!trimmed) throw new GrokOAuthError("invalid_callback_input", "empty callback input");
+	let url;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		url = void 0;
+	}
+	if (url) {
+		const code = url.searchParams.get("code");
+		if (code) return {
+			code,
+			state: url.searchParams.get("state") ?? ""
+		};
+		const error = url.searchParams.get("error");
+		if (error) {
+			const oauthError = safeOAuthErrorCode(error);
+			throw new GrokOAuthError("authorization_failed", `authorization failed: ${oauthError ?? "unknown_error"}`, oauthError === void 0 ? {} : { oauthError });
+		}
+		throw new GrokOAuthError("invalid_callback_input", "callback URL has no code parameter");
+	}
+	if (/\s/.test(trimmed)) throw new GrokOAuthError("invalid_callback_input", "authorization code contains whitespace");
+	return {
+		code: trimmed,
+		state: ""
+	};
+}
+function statesEqual(expected, received) {
+	const a = Buffer.from(expected);
+	const b = Buffer.from(received);
+	return a.length === b.length && timingSafeEqual(a, b);
+}
+const GrokTokenResponse = z.looseObject({
+	access_token: z.string().min(1),
+	refresh_token: z.string().min(1).nullish(),
+	id_token: z.string().nullish(),
+	expires_in: z.number().nonnegative().nullish(),
+	scope: z.string().nullish(),
+	token_type: z.string().nullish()
+});
+const OAuthErrorBody = z.looseObject({ error: z.string() });
+/** Reads the OAuth `error` code from a failed response without retaining the body. */
+async function readGrokOAuthErrorCode(response) {
+	const text = await response.text().catch(() => "");
+	try {
+		const parsed = OAuthErrorBody.safeParse(JSON.parse(text));
+		return parsed.success ? safeOAuthErrorCode(parsed.data.error) : void 0;
+	} catch {
+		return;
+	}
+}
+function formHeaders(extra = {}) {
+	return {
+		"user-agent": grokShellUserAgent(),
+		...extra,
+		"content-type": "application/x-www-form-urlencoded",
+		accept: "application/json"
+	};
+}
+async function parseTokenResponse(response) {
+	let body;
+	try {
+		body = await response.json();
+	} catch {
+		throw new GrokOAuthError("invalid_token_response", "token response is not JSON");
+	}
+	const parsed = GrokTokenResponse.safeParse(body);
+	if (!parsed.success) throw new GrokOAuthError("invalid_token_response", "token response failed validation");
+	return parsed.data;
+}
+function networkError(code, what, cause) {
+	return new GrokOAuthError(code, `${what} request failed (${cause instanceof Error ? cause.name : "unknown"})`, { retryable: true });
+}
+/**
+* Validates the token response, resolves the account id (JWT `sub`, confirmed by
+* `GET /user?include=subscription`), and builds stored credentials.
+*/
+async function finishGrokLogin(input) {
+	const fetchImpl = input.fetch ?? globalThis.fetch;
+	const now = input.now ?? Date.now;
+	const { tokens } = input;
+	if (!isGrokAccessToken(tokens.access_token)) throw new GrokOAuthError("invalid_access_token", `access token is not an at+jwt issued by ${GROK_AUTH_ISSUER}`);
+	if (!tokens.refresh_token) throw new GrokOAuthError("missing_refresh_token", "token response has no refresh token");
+	const decoded = decodeGrokJwt(tokens.access_token);
+	const subject = decoded?.payload.sub;
+	if (!subject) throw new GrokOAuthError("user_id_unresolved", "access token has no subject (sub) claim");
+	let response;
+	try {
+		response = await fetchImpl(`${GROK_CHAT_PROXY_URL}/user?include=subscription`, {
+			method: "GET",
+			headers: buildGrokProxyGetHeaders({
+				bearer: tokens.access_token,
+				userId: subject
+			}),
+			signal: AbortSignal.timeout(USER_LOOKUP_TIMEOUT_MS)
+		});
+	} catch (error) {
+		throw networkError("user_lookup_failed", "user lookup", error);
+	}
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new GrokOAuthError("user_lookup_failed", `user lookup failed: HTTP ${response.status}`, {
+			status: response.status,
+			retryable: response.status >= 500 || response.status === 429
+		});
+	}
+	let userBody;
+	try {
+		userBody = await response.json();
+	} catch {
+		throw new GrokOAuthError("user_id_unresolved", "user lookup returned non-JSON");
+	}
+	const user = GrokUserSubscription.safeParse(userBody);
+	if (!user.success) throw new GrokOAuthError("user_id_unresolved", "user lookup did not return a valid userId");
+	const issuedAt = now();
+	const expiresIn = tokens.expires_in;
+	const jwtExpiry = decoded?.payload.exp;
+	const expiresAtMs = expiresIn !== void 0 && expiresIn !== null ? issuedAt + expiresIn * 1e3 : jwtExpiry !== void 0 ? jwtExpiry * 1e3 : void 0;
+	if (expiresAtMs === void 0 || !Number.isFinite(expiresAtMs)) throw new GrokOAuthError("missing_expiry", "token response has no expiry");
+	const grantedScopes = tokens.scope?.split(" ").filter(Boolean);
+	const candidate = {
+		authMode: "oauth",
+		accessToken: tokens.access_token,
+		refreshToken: tokens.refresh_token,
+		expiresAt: new Date(expiresAtMs).toISOString(),
+		issuer: GROK_AUTH_ISSUER,
+		clientId: GROK_OAUTH_CLIENT_ID,
+		scopes: grantedScopes && grantedScopes.length > 0 ? grantedScopes : [...input.requestedScopes ?? GROK_OAUTH_SCOPES],
+		userId: user.data.userId,
+		sessionId: randomUUID(),
+		agentId: randomUUID()
+	};
+	if (user.data.subscriptionTier) candidate.subscriptionTier = user.data.subscriptionTier;
+	const credentials = GrokCredentials.safeParse(candidate);
+	if (!credentials.success) throw new GrokOAuthError("invalid_credentials", "credentials failed validation");
+	return credentials.data;
+}
+async function completeGrokOAuth(input) {
+	const fetchImpl = input.fetch ?? globalThis.fetch;
+	const callback = parseGrokCallbackInput(input.codeOrUrl);
+	if (callback.state && !statesEqual(input.state, callback.state)) throw new GrokOAuthError("state_mismatch", "OAuth state mismatch");
+	const endpoints = await getGrokOAuthEndpoints(input);
+	let response;
+	try {
+		response = await fetchImpl(endpoints.tokenEndpoint, {
+			method: "POST",
+			headers: formHeaders({ "x-grok-client-version": GROK_BUILD_VERSION }),
+			body: new URLSearchParams([
+				["grant_type", "authorization_code"],
+				["code", callback.code],
+				["redirect_uri", input.redirectUri],
+				["client_id", GROK_OAUTH_CLIENT_ID],
+				["code_verifier", input.verifier]
+			]),
+			signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS)
+		});
+	} catch (error) {
+		throw networkError("token_exchange_failed", "token exchange", error);
+	}
+	if (!response.ok) {
+		const oauthError = await readGrokOAuthErrorCode(response);
+		const errorOptions = { status: response.status };
+		if (oauthError !== void 0) errorOptions.oauthError = oauthError;
+		errorOptions.retryable = response.status >= 500;
+		throw new GrokOAuthError("token_exchange_failed", `token exchange failed: HTTP ${response.status} ${oauthError ?? "unknown"}`, errorOptions);
+	}
+	return finishGrokLogin({
+		...input,
+		fetch: fetchImpl,
+		tokens: await parseTokenResponse(response)
+	});
+}
+const GROK_DEVICE_DEFAULT_INTERVAL_S = 5;
+const GROK_DEVICE_SLOW_DOWN_INCREMENT_S = 5;
+const DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+const DEVICE_CLIENT_SURFACE = "ui";
+function isAllowedVerificationUri(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code < 32 || code === 127) return false;
+	}
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	if (url.protocol === "https:") return true;
+	return url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1");
+}
+const DeviceCodeResponse = z.looseObject({
+	device_code: z.string().min(1),
+	user_code: z.string().regex(/^[A-Za-z0-9-]+$/),
+	verification_uri: z.string().refine(isAllowedVerificationUri),
+	verification_uri_complete: z.string().refine(isAllowedVerificationUri).nullish(),
+	expires_in: z.number().positive(),
+	interval: z.number().int().positive().nullish()
+});
+function deviceHeaders() {
+	return formHeaders({
+		"x-grok-client-version": GROK_BUILD_VERSION,
+		"x-grok-client-surface": DEVICE_CLIENT_SURFACE
+	});
+}
+async function startGrokDeviceCode(io = {}) {
+	const fetchImpl = io.fetch ?? globalThis.fetch;
+	let response;
+	try {
+		response = await fetchImpl(GROK_DEVICE_CODE_URL, {
+			method: "POST",
+			headers: deviceHeaders(),
+			body: new URLSearchParams([
+				["client_id", GROK_OAUTH_CLIENT_ID],
+				["scope", GROK_OAUTH_SCOPE],
+				["referrer", GROK_OAUTH_REFERRER]
+			]),
+			signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS)
+		});
+	} catch (error) {
+		throw networkError("device_code_failed", "device code", error);
+	}
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		if (response.status === 404) throw new GrokOAuthError("device_flow_not_enabled", "device-code login is not available", { status: 404 });
+		throw new GrokOAuthError("device_code_failed", `device code request failed: HTTP ${response.status}`, {
+			status: response.status,
+			retryable: response.status >= 500 || response.status === 429
+		});
+	}
+	let body;
+	try {
+		body = await response.json();
+	} catch {
+		throw new GrokOAuthError("invalid_device_code_response", "device code response is not JSON");
+	}
+	const parsed = DeviceCodeResponse.safeParse(body);
+	if (!parsed.success) throw new GrokOAuthError("invalid_device_code_response", "device code response failed validation");
+	const data = parsed.data;
+	const deviceCode = {
+		deviceCode: data.device_code,
+		userCode: data.user_code,
+		verificationUri: data.verification_uri,
+		expiresIn: data.expires_in,
+		interval: data.interval ?? 5
+	};
+	if (data.verification_uri_complete) deviceCode.verificationUriComplete = data.verification_uri_complete;
+	return deviceCode;
+}
+/**
+* One poll of the device token endpoint. The caller sleeps `interval` seconds between polls and
+* enforces the device-code expiry; this function never loops.
+*/
+async function pollGrokDeviceCode(input) {
+	const fetchImpl = input.fetch ?? globalThis.fetch;
+	const interval = Math.max(1, Math.ceil(input.interval));
+	let response;
+	try {
+		response = await fetchImpl(GROK_DEVICE_TOKEN_URL, {
+			method: "POST",
+			headers: deviceHeaders(),
+			body: new URLSearchParams([
+				["grant_type", DEVICE_GRANT_TYPE],
+				["device_code", input.deviceCode],
+				["client_id", GROK_OAUTH_CLIENT_ID]
+			]),
+			signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS)
+		});
+	} catch (error) {
+		throw networkError("device_token_failed", "device token", error);
+	}
+	if (response.ok) return {
+		status: "complete",
+		credentials: await finishGrokLogin({
+			...input,
+			fetch: fetchImpl,
+			tokens: await parseTokenResponse(response)
+		})
+	};
+	const oauthError = await readGrokOAuthErrorCode(response);
+	switch (oauthError) {
+		case "authorization_pending": return {
+			status: "pending",
+			interval
+		};
+		case "slow_down": return {
+			status: "pending",
+			interval: interval + 5
+		};
+		case "access_denied": throw new GrokOAuthError("access_denied", "authorization denied by the user", {
+			status: response.status,
+			oauthError
+		});
+		case "expired_token": throw new GrokOAuthError("expired_token", "device code expired", {
+			status: response.status,
+			oauthError
+		});
+		default: throw new GrokOAuthError("device_token_failed", `device token request failed: HTTP ${response.status} ${oauthError ?? "unknown"}`, deviceTokenErrorOptions(response.status, oauthError));
+	}
+}
+function deviceTokenErrorOptions(status, oauthError) {
+	const errorOptions = { status };
+	if (oauthError !== void 0) errorOptions.oauthError = oauthError;
+	errorOptions.retryable = oauthError === void 0 && status >= 500;
+	return errorOptions;
+}
+//#endregion
+export { GROK_DEVICE_DEFAULT_INTERVAL_S, GROK_DEVICE_SLOW_DOWN_INCREMENT_S, GROK_DISCOVERY_TTL_MS, GROK_FALLBACK_AUTHORIZATION_ENDPOINT, GROK_FALLBACK_TOKEN_ENDPOINT, GROK_OAUTH_SCOPE, GrokOAuthError, GrokTokenResponse, buildGrokAuthorizeUrl, completeGrokOAuth, finishGrokLogin, generateGrokPkce, getGrokOAuthEndpoints, grokLoopbackRedirectUri, parseGrokCallbackInput, pollGrokDeviceCode, readGrokOAuthErrorCode, resetGrokDiscoveryCache, startGrokDeviceCode, startGrokOAuth };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-oauth.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-oauth.ts"],"sourcesContent":["// Grok (xAI) login: OIDC discovery, PKCE authorize URL, loopback/paste code exchange, RFC 8628\n// device code, and the post-login identity lookup. Mechanism follows grok-build 1.0.45\n// crates/codegen/xai-grok-login/src (oidc/protocol.rs, oidc/login.rs, device_code.rs).\n// Error messages never carry response bodies: token endpoints can echo credentials.\nimport { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from \"node:crypto\";\n\nimport { z } from \"zod\";\n\nimport {\n  GROK_AUTH_ISSUER,\n  GROK_BUILD_VERSION,\n  GROK_CHAT_PROXY_URL,\n  GROK_DEVICE_CODE_URL,\n  GROK_DEVICE_TOKEN_URL,\n  GROK_OAUTH_CLIENT_ID,\n  GROK_OAUTH_REFERRER,\n  GROK_OAUTH_SCOPES,\n} from \"./grok-constants\";\nimport { buildGrokProxyGetHeaders, grokShellUserAgent } from \"./grok-headers\";\nimport {\n  GrokCredentials,\n  GrokUserSubscription,\n  decodeGrokJwt,\n  isGrokAccessToken,\n} from \"./grok-types\";\n\nexport type GrokFetch = typeof globalThis.fetch;\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\nexport type GrokOAuthErrorCode =\n  | \"invalid_callback_input\"\n  | \"authorization_failed\"\n  | \"state_mismatch\"\n  | \"token_exchange_failed\"\n  | \"invalid_token_response\"\n  | \"invalid_access_token\"\n  | \"missing_refresh_token\"\n  | \"missing_expiry\"\n  | \"user_id_unresolved\"\n  | \"user_lookup_failed\"\n  | \"invalid_credentials\"\n  | \"device_flow_not_enabled\"\n  | \"device_code_failed\"\n  | \"invalid_device_code_response\"\n  | \"device_token_failed\"\n  | \"access_denied\"\n  | \"expired_token\";\n\n/** Login failure. `retryable` marks network/5xx failures where the same step may be retried. */\nexport class GrokOAuthError extends Error {\n  override readonly name = \"GrokOAuthError\";\n  constructor(\n    readonly code: GrokOAuthErrorCode,\n    message: string,\n    readonly options: { status?: number; oauthError?: string; retryable?: boolean } = {},\n  ) {\n    super(message);\n  }\n\n  get status(): number | undefined {\n    return this.options.status;\n  }\n\n  get retryable(): boolean {\n    return this.options.retryable ?? false;\n  }\n\n  /** OAuth `error` code, only when it is a plain lowercase identifier. */\n  get oauthError(): string | undefined {\n    return this.options.oauthError;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Discovery\n// ---------------------------------------------------------------------------\n\nexport interface GrokOAuthEndpoints {\n  authorizationEndpoint: string;\n  tokenEndpoint: string;\n  source: \"discovery\" | \"fallback\";\n}\n\n// grok-build caches 1 h (oidc/protocol.rs:269) and has no fallback (discovery errors abort the\n// login, protocol.rs:279-302). qgrid caches 24 h and falls back to fixed paths: the token path\n// is the one grok-build itself hard-codes for the device grant (device_code.rs:187); the\n// authorize path is not present in the source and is unverified.\nexport const GROK_DISCOVERY_TTL_MS = 24 * 60 * 60 * 1000;\nexport const GROK_FALLBACK_AUTHORIZATION_ENDPOINT = `${GROK_AUTH_ISSUER}/oauth2/authorize`;\nexport const GROK_FALLBACK_TOKEN_ENDPOINT = `${GROK_AUTH_ISSUER}/oauth2/token`;\n\nconst DISCOVERY_TIMEOUT_MS = 10_000;\nconst TOKEN_TIMEOUT_MS = 15_000;\nconst USER_LOOKUP_TIMEOUT_MS = 15_000;\n\nconst DiscoveryDocument = z.looseObject({\n  authorization_endpoint: z.string(),\n  token_endpoint: z.string(),\n});\n\nlet discoveryCache: { endpoints: GrokOAuthEndpoints; fetchedAt: number } | undefined;\n\n/** Clears the module-level discovery cache (tests and operator resets). */\nexport function resetGrokDiscoveryCache(): void {\n  discoveryCache = undefined;\n}\n\n// A discovery document that redirected the token endpoint off xAI would ship refresh tokens to a\n// third party, so only https endpoints on x.ai hosts are accepted; anything else falls back.\nfunction isTrustedEndpoint(value: string): boolean {\n  let url: URL;\n\n  try {\n    url = new URL(value);\n  } catch {\n    return false;\n  }\n\n  return (\n    url.protocol === \"https:\" &&\n    !url.username &&\n    !url.password &&\n    (url.hostname === \"x.ai\" || url.hostname.endsWith(\".x.ai\"))\n  );\n}\n\nexport interface GrokOAuthIo {\n  fetch?: GrokFetch;\n  now?: () => number;\n}\n\n/**\n * `GET {issuer}/.well-known/openid-configuration`, cached 24 h. Any failure uses the fallback\n * endpoints without caching them, so the next call retries discovery.\n */\nexport async function getGrokOAuthEndpoints(io: GrokOAuthIo = {}): Promise<GrokOAuthEndpoints> {\n  const fetchImpl = io.fetch ?? globalThis.fetch;\n  const now = io.now ?? Date.now;\n  const cached = discoveryCache;\n\n  if (cached && now() - cached.fetchedAt < GROK_DISCOVERY_TTL_MS) return cached.endpoints;\n\n  try {\n    const response = await fetchImpl(`${GROK_AUTH_ISSUER}/.well-known/openid-configuration`, {\n      method: \"GET\",\n      headers: { accept: \"application/json\", \"user-agent\": grokShellUserAgent() },\n      signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS),\n    });\n\n    if (response.ok) {\n      const document = DiscoveryDocument.safeParse(await response.json());\n\n      if (\n        document.success &&\n        isTrustedEndpoint(document.data.authorization_endpoint) &&\n        isTrustedEndpoint(document.data.token_endpoint)\n      ) {\n        const endpoints: GrokOAuthEndpoints = {\n          authorizationEndpoint: document.data.authorization_endpoint,\n          tokenEndpoint: document.data.token_endpoint,\n          source: \"discovery\",\n        };\n\n        discoveryCache = { endpoints, fetchedAt: now() };\n\n        return endpoints;\n      }\n    } else {\n      await response.body?.cancel().catch(() => undefined);\n    }\n  } catch {\n    // Network failure, timeout, or a non-JSON body: fall through to the fixed endpoints.\n  }\n\n  return {\n    authorizationEndpoint: GROK_FALLBACK_AUTHORIZATION_ENDPOINT,\n    tokenEndpoint: GROK_FALLBACK_TOKEN_ENDPOINT,\n    source: \"fallback\",\n  };\n}\n\n// ---------------------------------------------------------------------------\n// PKCE and authorize URL\n// ---------------------------------------------------------------------------\n\nexport interface GrokPkce {\n  codeVerifier: string;\n  codeChallenge: string;\n}\n\n/** S256 over a base64url verifier of 32 random bytes (oidc/protocol.rs:314-320). */\nexport function generateGrokPkce(): GrokPkce {\n  const codeVerifier = randomBytes(32).toString(\"base64url\");\n\n  return {\n    codeVerifier,\n    codeChallenge: createHash(\"sha256\").update(codeVerifier).digest(\"base64url\"),\n  };\n}\n\n/** RFC 3986 unreserved-only encoding, matching Rust `urlencoding::encode` (space → %20). */\nfunction encodeQueryValue(value: string): string {\n  return encodeURIComponent(value).replace(\n    /[!'()*]/g,\n    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`,\n  );\n}\n\nexport const GROK_OAUTH_SCOPE = GROK_OAUTH_SCOPES.join(\" \");\n\nexport interface GrokAuthorizeUrlInput {\n  authorizationEndpoint: string;\n  redirectUri: string;\n  codeChallenge: string;\n  state: string;\n  nonce: string;\n}\n\n/** Authorize URL with grok-build's query order (oidc/protocol.rs:321-366). */\nexport function buildGrokAuthorizeUrl(input: GrokAuthorizeUrlInput): string {\n  const query: [string, string][] = [\n    [\"response_type\", \"code\"],\n    [\"client_id\", GROK_OAUTH_CLIENT_ID],\n    [\"redirect_uri\", input.redirectUri],\n    [\"scope\", GROK_OAUTH_SCOPE],\n    [\"code_challenge\", input.codeChallenge],\n    [\"code_challenge_method\", \"S256\"],\n    [\"state\", input.state],\n    [\"nonce\", input.nonce],\n    [\"referrer\", GROK_OAUTH_REFERRER],\n  ];\n\n  const search = query.map(([key, value]) => `${key}=${encodeQueryValue(value)}`).join(\"&\");\n\n  return `${input.authorizationEndpoint}?${search}`;\n}\n\nexport function grokLoopbackRedirectUri(port: number): string {\n  if (!Number.isInteger(port) || port < 1 || port > 65_535)\n    throw new RangeError(\"redirect port must be an integer in 1..65535\");\n\n  return `http://127.0.0.1:${port}/callback`;\n}\n\nexport interface StartGrokOAuthInput extends GrokOAuthIo {\n  state: string;\n  /** Loopback port; defaults to a random port in the ephemeral range. */\n  redirectPort?: number;\n}\n\nexport interface StartGrokOAuthResult {\n  authorizeUrl: string;\n  verifier: string;\n  redirectUri: string;\n}\n\nexport async function startGrokOAuth(input: StartGrokOAuthInput): Promise<StartGrokOAuthResult> {\n  if (!input.state) throw new TypeError(\"state must be non-empty\");\n  const endpoints = await getGrokOAuthEndpoints(input);\n  const pkce = generateGrokPkce();\n  const redirectUri = grokLoopbackRedirectUri(input.redirectPort ?? randomInt(49_152, 65_536));\n\n  return {\n    authorizeUrl: buildGrokAuthorizeUrl({\n      authorizationEndpoint: endpoints.authorizationEndpoint,\n      redirectUri,\n      codeChallenge: pkce.codeChallenge,\n      state: input.state,\n      nonce: randomUUID(),\n    }),\n    verifier: pkce.codeVerifier,\n    redirectUri,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Callback / paste parsing\n// ---------------------------------------------------------------------------\n\nexport interface GrokCallbackInput {\n  code: string;\n  /** Empty for a bare pasted code, which carries no state (oidc/login.rs:33-60). */\n  state: string;\n}\n\nconst OAUTH_ERROR_CODE = /^[a-z_]{1,80}$/;\n\nfunction safeOAuthErrorCode(value: string): string | undefined {\n  return OAUTH_ERROR_CODE.test(value) ? value : undefined;\n}\n\n/** Accepts the full callback URL or a bare authorization code (oidc/login.rs:30-60). */\nexport function parseGrokCallbackInput(input: string): GrokCallbackInput {\n  const trimmed = input.trim();\n\n  if (!trimmed) throw new GrokOAuthError(\"invalid_callback_input\", \"empty callback input\");\n\n  let url: URL | undefined;\n\n  try {\n    url = new URL(trimmed);\n  } catch {\n    url = undefined;\n  }\n\n  if (url) {\n    const code = url.searchParams.get(\"code\");\n\n    if (code) return { code, state: url.searchParams.get(\"state\") ?? \"\" };\n    const error = url.searchParams.get(\"error\");\n\n    if (error) {\n      const oauthError = safeOAuthErrorCode(error);\n      throw new GrokOAuthError(\n        \"authorization_failed\",\n        `authorization failed: ${oauthError ?? \"unknown_error\"}`,\n        oauthError === undefined ? {} : { oauthError },\n      );\n    }\n\n    throw new GrokOAuthError(\"invalid_callback_input\", \"callback URL has no code parameter\");\n  }\n\n  if (/\\s/.test(trimmed))\n    throw new GrokOAuthError(\"invalid_callback_input\", \"authorization code contains whitespace\");\n\n  return { code: trimmed, state: \"\" };\n}\n\nfunction statesEqual(expected: string, received: string): boolean {\n  const a = Buffer.from(expected);\n  const b = Buffer.from(received);\n\n  return a.length === b.length && timingSafeEqual(a, b);\n}\n\n// ---------------------------------------------------------------------------\n// Token exchange and finishing\n// ---------------------------------------------------------------------------\n\nexport const GrokTokenResponse = z.looseObject({\n  access_token: z.string().min(1),\n  refresh_token: z.string().min(1).nullish(),\n  id_token: z.string().nullish(),\n  expires_in: z.number().nonnegative().nullish(),\n  scope: z.string().nullish(),\n  token_type: z.string().nullish(),\n});\n\nexport type GrokTokenResponse = z.infer<typeof GrokTokenResponse>;\n\nconst OAuthErrorBody = z.looseObject({ error: z.string() });\n\n/** Reads the OAuth `error` code from a failed response without retaining the body. */\nexport async function readGrokOAuthErrorCode(response: Response): Promise<string | undefined> {\n  const text = await response.text().catch(() => \"\");\n\n  try {\n    const parsed = OAuthErrorBody.safeParse(JSON.parse(text));\n\n    return parsed.success ? safeOAuthErrorCode(parsed.data.error) : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction formHeaders(extra: Record<string, string> = {}) {\n  return {\n    \"user-agent\": grokShellUserAgent(),\n    ...extra,\n    \"content-type\": \"application/x-www-form-urlencoded\",\n    accept: \"application/json\",\n  };\n}\n\nasync function parseTokenResponse(response: Response): Promise<GrokTokenResponse> {\n  let body: unknown;\n\n  try {\n    body = await response.json();\n  } catch {\n    throw new GrokOAuthError(\"invalid_token_response\", \"token response is not JSON\");\n  }\n\n  const parsed = GrokTokenResponse.safeParse(body);\n\n  if (!parsed.success)\n    throw new GrokOAuthError(\"invalid_token_response\", \"token response failed validation\");\n\n  return parsed.data;\n}\n\nfunction networkError(code: GrokOAuthErrorCode, what: string, cause: unknown): GrokOAuthError {\n  const reason = cause instanceof Error ? cause.name : \"unknown\";\n\n  return new GrokOAuthError(code, `${what} request failed (${reason})`, { retryable: true });\n}\n\nexport interface FinishGrokLoginInput extends GrokOAuthIo {\n  tokens: GrokTokenResponse;\n  requestedScopes?: readonly string[];\n}\n\n/**\n * Validates the token response, resolves the account id (JWT `sub`, confirmed by\n * `GET /user?include=subscription`), and builds stored credentials.\n */\nexport async function finishGrokLogin(input: FinishGrokLoginInput): Promise<GrokCredentials> {\n  const fetchImpl = input.fetch ?? globalThis.fetch;\n  const now = input.now ?? Date.now;\n  const { tokens } = input;\n\n  if (!isGrokAccessToken(tokens.access_token))\n    throw new GrokOAuthError(\n      \"invalid_access_token\",\n      `access token is not an at+jwt issued by ${GROK_AUTH_ISSUER}`,\n    );\n\n  if (!tokens.refresh_token)\n    throw new GrokOAuthError(\"missing_refresh_token\", \"token response has no refresh token\");\n\n  const decoded = decodeGrokJwt(tokens.access_token);\n  const subject = decoded?.payload.sub;\n\n  if (!subject)\n    throw new GrokOAuthError(\"user_id_unresolved\", \"access token has no subject (sub) claim\");\n\n  let response: Response;\n\n  try {\n    response = await fetchImpl(`${GROK_CHAT_PROXY_URL}/user?include=subscription`, {\n      method: \"GET\",\n      headers: buildGrokProxyGetHeaders({ bearer: tokens.access_token, userId: subject }),\n      signal: AbortSignal.timeout(USER_LOOKUP_TIMEOUT_MS),\n    });\n  } catch (error) {\n    throw networkError(\"user_lookup_failed\", \"user lookup\", error);\n  }\n\n  if (!response.ok) {\n    await response.body?.cancel().catch(() => undefined);\n    throw new GrokOAuthError(\"user_lookup_failed\", `user lookup failed: HTTP ${response.status}`, {\n      status: response.status,\n      retryable: response.status >= 500 || response.status === 429,\n    });\n  }\n\n  let userBody: unknown;\n\n  try {\n    userBody = await response.json();\n  } catch {\n    throw new GrokOAuthError(\"user_id_unresolved\", \"user lookup returned non-JSON\");\n  }\n\n  const user = GrokUserSubscription.safeParse(userBody);\n\n  if (!user.success)\n    throw new GrokOAuthError(\"user_id_unresolved\", \"user lookup did not return a valid userId\");\n\n  const issuedAt = now();\n  const expiresIn = tokens.expires_in;\n  const jwtExpiry = decoded?.payload.exp;\n\n  const expiresAtMs =\n    expiresIn !== undefined && expiresIn !== null\n      ? issuedAt + expiresIn * 1000\n      : jwtExpiry !== undefined\n        ? jwtExpiry * 1000\n        : undefined;\n\n  if (expiresAtMs === undefined || !Number.isFinite(expiresAtMs))\n    throw new GrokOAuthError(\"missing_expiry\", \"token response has no expiry\");\n\n  const grantedScopes = tokens.scope?.split(\" \").filter(Boolean);\n\n  const candidate: GrokCredentials = {\n    authMode: \"oauth\" as const,\n    accessToken: tokens.access_token,\n    refreshToken: tokens.refresh_token,\n    expiresAt: new Date(expiresAtMs).toISOString(),\n    issuer: GROK_AUTH_ISSUER,\n    clientId: GROK_OAUTH_CLIENT_ID,\n    scopes:\n      grantedScopes && grantedScopes.length > 0\n        ? grantedScopes\n        : [...(input.requestedScopes ?? GROK_OAUTH_SCOPES)],\n    userId: user.data.userId,\n    sessionId: randomUUID(),\n    agentId: randomUUID(),\n  };\n\n  if (user.data.subscriptionTier) candidate.subscriptionTier = user.data.subscriptionTier;\n\n  const credentials = GrokCredentials.safeParse(candidate);\n\n  if (!credentials.success)\n    throw new GrokOAuthError(\"invalid_credentials\", \"credentials failed validation\");\n\n  return credentials.data;\n}\n\nexport interface CompleteGrokOAuthInput extends GrokOAuthIo {\n  codeOrUrl: string;\n  verifier: string;\n  redirectUri: string;\n  /** The state issued with the authorize URL; a pasted URL must echo it. */\n  state: string;\n}\n\nexport async function completeGrokOAuth(input: CompleteGrokOAuthInput): Promise<GrokCredentials> {\n  const fetchImpl = input.fetch ?? globalThis.fetch;\n  const callback = parseGrokCallbackInput(input.codeOrUrl);\n\n  // A bare code carries no state; the caller binds it to the pending login (oidc/login.rs:452-455).\n  if (callback.state && !statesEqual(input.state, callback.state))\n    throw new GrokOAuthError(\"state_mismatch\", \"OAuth state mismatch\");\n\n  const endpoints = await getGrokOAuthEndpoints(input);\n  let response: Response;\n\n  try {\n    response = await fetchImpl(endpoints.tokenEndpoint, {\n      method: \"POST\",\n      // oidc/protocol.rs:385-399: form body, x-grok-client-version, shared-client UA.\n      headers: formHeaders({ \"x-grok-client-version\": GROK_BUILD_VERSION }),\n      body: new URLSearchParams([\n        [\"grant_type\", \"authorization_code\"],\n        [\"code\", callback.code],\n        [\"redirect_uri\", input.redirectUri],\n        [\"client_id\", GROK_OAUTH_CLIENT_ID],\n        [\"code_verifier\", input.verifier],\n      ]),\n      signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),\n    });\n  } catch (error) {\n    throw networkError(\"token_exchange_failed\", \"token exchange\", error);\n  }\n\n  if (!response.ok) {\n    const oauthError = await readGrokOAuthErrorCode(response);\n    const errorOptions: GrokOAuthError[\"options\"] = { status: response.status };\n\n    if (oauthError !== undefined) errorOptions.oauthError = oauthError;\n    errorOptions.retryable = response.status >= 500;\n    throw new GrokOAuthError(\n      \"token_exchange_failed\",\n      `token exchange failed: HTTP ${response.status} ${oauthError ?? \"unknown\"}`,\n      errorOptions,\n    );\n  }\n\n  return finishGrokLogin({\n    ...input,\n    fetch: fetchImpl,\n    tokens: await parseTokenResponse(response),\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Device code (RFC 8628)\n// ---------------------------------------------------------------------------\n\n// device_code.rs:19-20\nexport const GROK_DEVICE_DEFAULT_INTERVAL_S = 5;\nexport const GROK_DEVICE_SLOW_DOWN_INCREMENT_S = 5;\nconst DEVICE_GRANT_TYPE = \"urn:ietf:params:oauth:grant-type:device_code\";\n\n// The dashboard renders the URL and code to a human (device_code.rs:266-271 → `ui`).\nconst DEVICE_CLIENT_SURFACE = \"ui\";\n\nfunction isAllowedVerificationUri(value: string): boolean {\n  // device_code.rs:475-488: reject control characters, require https (http only on loopback).\n  // Control characters are single UTF-16 code units, so scanning code units is exact.\n  for (let index = 0; index < value.length; index++) {\n    const code = value.charCodeAt(index);\n\n    if (code < 0x20 || code === 0x7f) return false;\n  }\n\n  let url: URL;\n\n  try {\n    url = new URL(value);\n  } catch {\n    return false;\n  }\n\n  if (url.protocol === \"https:\") return true;\n\n  return url.protocol === \"http:\" && (url.hostname === \"localhost\" || url.hostname === \"127.0.0.1\");\n}\n\nconst DeviceCodeResponse = z.looseObject({\n  device_code: z.string().min(1),\n  user_code: z.string().regex(/^[A-Za-z0-9-]+$/),\n  verification_uri: z.string().refine(isAllowedVerificationUri),\n  verification_uri_complete: z.string().refine(isAllowedVerificationUri).nullish(),\n  expires_in: z.number().positive(),\n  interval: z.number().int().positive().nullish(),\n});\n\nexport interface GrokDeviceCode {\n  deviceCode: string;\n  userCode: string;\n  verificationUri: string;\n  verificationUriComplete?: string;\n  /** Seconds until the device code expires. */\n  expiresIn: number;\n  /** Seconds to wait before the next poll. */\n  interval: number;\n}\n\nfunction deviceHeaders(): Record<string, string> {\n  return formHeaders({\n    \"x-grok-client-version\": GROK_BUILD_VERSION,\n    \"x-grok-client-surface\": DEVICE_CLIENT_SURFACE,\n  });\n}\n\nexport async function startGrokDeviceCode(io: GrokOAuthIo = {}): Promise<GrokDeviceCode> {\n  const fetchImpl = io.fetch ?? globalThis.fetch;\n  let response: Response;\n\n  try {\n    response = await fetchImpl(GROK_DEVICE_CODE_URL, {\n      method: \"POST\",\n      headers: deviceHeaders(),\n      body: new URLSearchParams([\n        [\"client_id\", GROK_OAUTH_CLIENT_ID],\n        [\"scope\", GROK_OAUTH_SCOPE],\n        [\"referrer\", GROK_OAUTH_REFERRER],\n      ]),\n      signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),\n    });\n  } catch (error) {\n    throw networkError(\"device_code_failed\", \"device code\", error);\n  }\n\n  if (!response.ok) {\n    await response.body?.cancel().catch(() => undefined);\n\n    if (response.status === 404)\n      throw new GrokOAuthError(\"device_flow_not_enabled\", \"device-code login is not available\", {\n        status: 404,\n      });\n    throw new GrokOAuthError(\n      \"device_code_failed\",\n      `device code request failed: HTTP ${response.status}`,\n      { status: response.status, retryable: response.status >= 500 || response.status === 429 },\n    );\n  }\n\n  let body: unknown;\n\n  try {\n    body = await response.json();\n  } catch {\n    throw new GrokOAuthError(\"invalid_device_code_response\", \"device code response is not JSON\");\n  }\n\n  const parsed = DeviceCodeResponse.safeParse(body);\n\n  if (!parsed.success)\n    throw new GrokOAuthError(\n      \"invalid_device_code_response\",\n      \"device code response failed validation\",\n    );\n  const data = parsed.data;\n\n  const deviceCode: GrokDeviceCode = {\n    deviceCode: data.device_code,\n    userCode: data.user_code,\n    verificationUri: data.verification_uri,\n    expiresIn: data.expires_in,\n    interval: data.interval ?? GROK_DEVICE_DEFAULT_INTERVAL_S,\n  };\n\n  if (data.verification_uri_complete) {\n    deviceCode.verificationUriComplete = data.verification_uri_complete;\n  }\n\n  return deviceCode;\n}\n\nexport type GrokDevicePollResult =\n  | { status: \"pending\"; interval: number }\n  | { status: \"complete\"; credentials: GrokCredentials };\n\nexport interface PollGrokDeviceCodeInput extends GrokOAuthIo {\n  deviceCode: string;\n  /** Current poll interval in seconds; the result carries the interval for the next poll. */\n  interval: number;\n}\n\n/**\n * One poll of the device token endpoint. The caller sleeps `interval` seconds between polls and\n * enforces the device-code expiry; this function never loops.\n */\nexport async function pollGrokDeviceCode(\n  input: PollGrokDeviceCodeInput,\n): Promise<GrokDevicePollResult> {\n  const fetchImpl = input.fetch ?? globalThis.fetch;\n  const interval = Math.max(1, Math.ceil(input.interval));\n  let response: Response;\n\n  try {\n    response = await fetchImpl(GROK_DEVICE_TOKEN_URL, {\n      method: \"POST\",\n      headers: deviceHeaders(),\n      body: new URLSearchParams([\n        [\"grant_type\", DEVICE_GRANT_TYPE],\n        [\"device_code\", input.deviceCode],\n        [\"client_id\", GROK_OAUTH_CLIENT_ID],\n      ]),\n      signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),\n    });\n  } catch (error) {\n    throw networkError(\"device_token_failed\", \"device token\", error);\n  }\n\n  if (response.ok)\n    return {\n      status: \"complete\",\n      credentials: await finishGrokLogin({\n        ...input,\n        fetch: fetchImpl,\n        tokens: await parseTokenResponse(response),\n      }),\n    };\n\n  const oauthError = await readGrokOAuthErrorCode(response);\n\n  switch (oauthError) {\n    case \"authorization_pending\":\n      return { status: \"pending\", interval };\n    case \"slow_down\":\n      return { status: \"pending\", interval: interval + GROK_DEVICE_SLOW_DOWN_INCREMENT_S };\n    case \"access_denied\":\n      throw new GrokOAuthError(\"access_denied\", \"authorization denied by the user\", {\n        status: response.status,\n        oauthError,\n      });\n    case \"expired_token\":\n      throw new GrokOAuthError(\"expired_token\", \"device code expired\", {\n        status: response.status,\n        oauthError,\n      });\n    default:\n      throw new GrokOAuthError(\n        \"device_token_failed\",\n        `device token request failed: HTTP ${response.status} ${oauthError ?? \"unknown\"}`,\n        deviceTokenErrorOptions(response.status, oauthError),\n      );\n  }\n}\n\nfunction deviceTokenErrorOptions(\n  status: number,\n  oauthError: string | undefined,\n): GrokOAuthError[\"options\"] {\n  const errorOptions: GrokOAuthError[\"options\"] = { status };\n\n  if (oauthError !== undefined) errorOptions.oauthError = oauthError;\n  errorOptions.retryable = oauthError === undefined && status >= 500;\n\n  return errorOptions;\n}\n"],"mappings":"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"}