@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
307 lines (262 loc) • 9.63 kB
text/typescript
import { XAI_GROK_COMPATIBILITY } from "../providers/xai-transport";
import {
decodeGrpcWebResponse,
encodeGrpcWebEnvelope,
GrpcWebError,
} from "./grpc-web";
export const GROK_CONSUMER_UI_BASE_URL = "https://grok.com";
export const GROK_GET_REMAINING_RESETS_ENDPOINT =
"https://grok.com/prod_mc_billing.ConsumerUiSvc/GetRemainingResets";
export const GROK_REDEEM_RESET_ENDPOINT =
"https://grok.com/prod_mc_billing.ConsumerUiSvc/RedeemReset";
export interface GrokResetCoupon {
tokenId: string;
validityStart: string;
validityEnd: string;
}
export interface GetRemainingResetsOptions {
accessToken: string;
fetchFn?: typeof globalThis.fetch;
signal?: AbortSignal;
endpoint?: string;
}
export interface RedeemResetOptions {
accessToken: string;
tokenId: string;
fetchFn?: typeof globalThis.fetch;
signal?: AbortSignal;
endpoint?: string;
}
export interface RedeemResetResult {
success: boolean;
status: number;
statusMessage?: string;
}
/**
* Encodes a 32/64-bit non-negative integer into protobuf varint wire bytes.
*/
export function encodeVarint(value: number | bigint): Uint8Array {
const bytes: number[] = [];
let val = BigInt(value);
while (val >= 0x80n) {
bytes.push(Number((val & 0x7fn) | 0x80n));
val >>= 7n;
}
bytes.push(Number(val & 0x7fn));
return new Uint8Array(bytes);
}
const MAX_PROTOBUF_VARINT_BYTES = 10;
/**
* Decodes a protobuf varint from bytes at offset.
*/
export function decodeVarint(bytes: Uint8Array, offset: number): { value: number; bytesRead: number } {
if (!Number.isInteger(offset) || offset < 0 || offset >= bytes.length) {
throw new Error("Invalid protobuf varint offset");
}
let result = 0;
let count = 0;
while (offset + count < bytes.length) {
// Protobuf caps a varint at the ten bytes a 64-bit value needs. The safe-integer guard
// below cannot stand in for this bound, because a continuation byte carrying no payload
// bits contributes a part of zero, which IS a safe integer: without an explicit length
// limit an arbitrarily long run of 0x80 followed by 0x00 decoded as a valid zero, and an
// overlong zero length can normalize a malformed body into an empty coupon list.
if (count >= MAX_PROTOBUF_VARINT_BYTES) {
throw new Error("Overlong protobuf varint");
}
const b = bytes[offset + count];
const part = (b & 0x7f) * (2 ** (7 * count));
if (!Number.isSafeInteger(part) || result > Number.MAX_SAFE_INTEGER - part) {
throw new Error("Protobuf varint exceeds JavaScript safe integer range");
}
result += part;
count++;
if ((b & 0x80) === 0) return { value: result, bytesRead: count };
}
throw new Error("Truncated protobuf varint");
}
function decodeLength(bytes: Uint8Array, offset: number): { start: number; end: number } {
const { value: length, bytesRead } = decodeVarint(bytes, offset);
const start = offset + bytesRead;
if (!Number.isSafeInteger(length) || length < 0 || length > bytes.length - start) {
throw new Error("Invalid protobuf length-delimited field");
}
return { start, end: start + length };
}
/**
* Encodes RedeemResetRequest protobuf: field 1 (string token_id).
*/
export function encodeRedeemResetRequest(tokenId: string): Uint8Array {
const tokenBytes = new TextEncoder().encode(tokenId);
const tag = (1 << 3) | 2; // Field 1, Wire Type 2
const tagBytes = encodeVarint(tag);
const lenBytes = encodeVarint(tokenBytes.length);
const out = new Uint8Array(tagBytes.length + lenBytes.length + tokenBytes.length);
out.set(tagBytes, 0);
out.set(lenBytes, tagBytes.length);
out.set(tokenBytes, tagBytes.length + lenBytes.length);
return out;
}
/**
* Decodes a Timestamp submessage (field 1: int64 seconds).
*/
function decodeTimestamp(bytes: Uint8Array): number {
let offset = 0;
let seconds = 0;
while (offset < bytes.length) {
const { value: tag, bytesRead: tagLen } = decodeVarint(bytes, offset);
offset += tagLen;
const fieldNum = tag >> 3;
const wireType = tag & 0x7;
if (wireType === 0) {
const { value, bytesRead } = decodeVarint(bytes, offset);
offset += bytesRead;
if (fieldNum === 1) seconds = value;
} else if (wireType === 2) {
const { end } = decodeLength(bytes, offset);
offset = end;
} else {
break;
}
}
return seconds;
}
/**
* Decodes a ConsumerResetToken submessage.
*/
function decodeConsumerResetToken(bytes: Uint8Array): GrokResetCoupon | null {
let offset = 0;
let tokenId = "";
let startSec = 0;
let endSec = 0;
while (offset < bytes.length) {
const { value: tag, bytesRead: tagLen } = decodeVarint(bytes, offset);
offset += tagLen;
const fieldNum = tag >> 3;
const wireType = tag & 0x7;
if (wireType === 2) {
const { start, end } = decodeLength(bytes, offset);
const sub = bytes.subarray(start, end);
offset = end;
if (fieldNum === 10) {
tokenId = new TextDecoder("utf-8").decode(sub);
} else if (fieldNum === 20) {
startSec = decodeTimestamp(sub);
} else if (fieldNum === 30) {
endSec = decodeTimestamp(sub);
}
} else if (wireType === 0) {
const { bytesRead } = decodeVarint(bytes, offset);
offset += bytesRead;
} else {
break;
}
}
if (!tokenId) return null;
return {
tokenId,
validityStart: startSec > 0 ? new Date(startSec * 1000).toISOString() : "",
validityEnd: endSec > 0 ? new Date(endSec * 1000).toISOString() : "",
};
}
/**
* Decodes GetRemainingResetsResponse protobuf message: field 10 (repeated ConsumerResetToken).
*/
export function decodeGetRemainingResetsResponse(payload: Uint8Array): GrokResetCoupon[] {
const tokens: GrokResetCoupon[] = [];
let offset = 0;
while (offset < payload.length) {
const { value: tag, bytesRead: tagLen } = decodeVarint(payload, offset);
offset += tagLen;
const fieldNum = tag >> 3;
const wireType = tag & 0x7;
if (wireType === 2) {
const { start, end } = decodeLength(payload, offset);
const sub = payload.subarray(start, end);
offset = end;
if (fieldNum === 10) {
const token = decodeConsumerResetToken(sub);
if (token) tokens.push(token);
}
} else if (wireType === 0) {
const { bytesRead } = decodeVarint(payload, offset);
offset += bytesRead;
} else {
break;
}
}
return tokens;
}
function buildGrokHeaders(accessToken: string): Record<string, string> {
return {
"Content-Type": "application/grpc-web+proto",
"X-Grpc-Web": "1",
"Accept": "application/grpc-web+proto",
"Authorization": `Bearer ${accessToken}`,
[XAI_GROK_COMPATIBILITY.headers.tokenAuth]: "xai-grok-cli",
};
}
/**
* Reads available Grok reset tokens for the authenticated xAI account.
*/
function assertConfirmedCouponStatus(decoded: ReturnType<typeof decodeGrpcWebResponse>): void {
const rawStatus = decoded.statusValues[0];
// The shared decoder defaults a missing/malformed status to zero. Coupon
// availability and an irreversible redemption need affirmative confirmation.
if (decoded.framingComplete !== true || rawStatus === undefined
|| decoded.statusValues.some((value) => !/^\d+$/.test(value)
|| !Number.isSafeInteger(Number(value)) || value !== rawStatus)) {
throw new Error("Grok coupon response has no confirmed gRPC status");
}
const status = Number(rawStatus);
if (status !== 0) throw new GrpcWebError(status, decoded.statusMessage ?? "Unknown gRPC error");
}
export async function getGrokRemainingResets(options: GetRemainingResetsOptions): Promise<{ tokens: GrokResetCoupon[] }> {
const fetchImpl = options.fetchFn ?? globalThis.fetch;
const endpoint = options.endpoint ?? GROK_GET_REMAINING_RESETS_ENDPOINT;
// BodyInit requires a plain ArrayBuffer backing store; the encoder's generic
// Uint8Array<ArrayBufferLike> is not assignable under TS 5.7 lib.dom types.
const emptyBody = encodeGrpcWebEnvelope(new Uint8Array(0)) as Uint8Array<ArrayBuffer>;
const res = await fetchImpl(endpoint, {
method: "POST",
headers: buildGrokHeaders(options.accessToken),
body: emptyBody,
signal: options.signal,
});
if (!res.ok) {
throw new Error(`GetRemainingResets HTTP error ${res.status}: ${res.statusText}`);
}
const rawBytes = new Uint8Array(await res.arrayBuffer());
const decoded = decodeGrpcWebResponse(rawBytes);
assertConfirmedCouponStatus(decoded);
if (decoded.messages.length === 0) {
return { tokens: [] };
}
return { tokens: decodeGetRemainingResetsResponse(decoded.messages[0]) };
}
/**
* Redeems a specific Grok reset token by tokenId.
*/
export async function redeemGrokResetCoupon(options: RedeemResetOptions): Promise<RedeemResetResult> {
const fetchImpl = options.fetchFn ?? globalThis.fetch;
const endpoint = options.endpoint ?? GROK_REDEEM_RESET_ENDPOINT;
const protoMessage = encodeRedeemResetRequest(options.tokenId);
const envelope = encodeGrpcWebEnvelope(protoMessage) as Uint8Array<ArrayBuffer>;
const res = await fetchImpl(endpoint, {
method: "POST",
headers: buildGrokHeaders(options.accessToken),
body: envelope,
signal: options.signal,
});
if (!res.ok) {
throw new Error(`RedeemReset HTTP error ${res.status}: ${res.statusText}`);
}
const rawBytes = new Uint8Array(await res.arrayBuffer());
const decoded = decodeGrpcWebResponse(rawBytes);
assertConfirmedCouponStatus(decoded);
return {
success: true,
status: decoded.status,
statusMessage: decoded.statusMessage,
};
}