osdy-pi 1.2.0 → 1.3.0

package/extensions/osdy-pi/codex-usage.test.ts

@@ -0,0 +1,276 @@
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { registerHooks } from "node:module";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (
+			specifier.startsWith(".") &&
+			specifier.endsWith(".js") &&
+			context.parentURL?.endsWith(".ts")
+		) {
+			const sourceUrl = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+			if (existsSync(fileURLToPath(sourceUrl))) {
+				return { shortCircuit: true, url: sourceUrl.href };
+			}
+		}
+		return nextResolve(specifier, context);
+	},
+	load(url, context, nextLoad) {
+		if (url.endsWith(".ts")) {
+			const source = readFileSync(fileURLToPath(url), "utf8");
+			return {
+				format: "module",
+				shortCircuit: true,
+				source: ts.transpileModule(source, {
+					compilerOptions: {
+						module: ts.ModuleKind.ESNext,
+						target: ts.ScriptTarget.ES2022,
+					},
+				}).outputText,
+			};
+		}
+		return nextLoad(url, context);
+	},
+});
+
+const { extractCodexAccountId, fetchCodexUsage, parseCodexUsagePayload } =
+	await import("./codex-usage.js");
+
+function codexToken(accountId: string): string {
+	const encode = (value: unknown): string =>
+		Buffer.from(JSON.stringify(value)).toString("base64url");
+	return `${encode({ alg: "none" })}.${encode({
+		"https://api.openai.com/auth": { chatgpt_account_id: accountId },
+	})}.signature`;
+}
+
+const payload = {
+	plan_type: "plus",
+	ordinary_usage_allowed: true,
+	rate_limit: {
+		primary_window: {
+			used_percent: 37,
+			limit_window_seconds: 18_000,
+			reset_at: 2_000_000_000,
+		},
+		secondary_window: {
+			used_percent: 71,
+			limit_window_seconds: 604_800,
+			reset_at: 2_000_100_000,
+		},
+	},
+	credits: {
+		has_credits: true,
+		unlimited: false,
+		balance: "12.50",
+		reset_credit_count: 3,
+	},
+	additional_rate_limits: [
+		{
+			metered_feature: "codex_spark",
+			limit_name: "Spark",
+			rate_limit: {
+				primary_window: {
+					used_percent: 12,
+					limit_window_seconds: 3_600,
+					reset_at: 2_000_200_000,
+				},
+			},
+		},
+	],
+};
+
+void test("parses subscription windows, credits, and additional buckets", () => {
+	const snapshot = parseCodexUsagePayload(payload, 1_900_000_000_000);
+
+	assert.equal(snapshot.planType, "plus");
+	assert.equal(snapshot.ordinaryUsageAllowed, true);
+	assert.equal(snapshot.fetchedAt, 1_900_000_000_000);
+	assert.deepEqual(snapshot.buckets[0], {
+		id: "codex",
+		label: undefined,
+		primary: {
+			usedPercent: 37,
+			windowMinutes: 300,
+			resetsAt: 2_000_000_000,
+		},
+		secondary: {
+			usedPercent: 71,
+			windowMinutes: 10_080,
+			resetsAt: 2_000_100_000,
+		},
+	});
+	assert.equal(snapshot.buckets[1]?.id, "codex_spark");
+	assert.equal(snapshot.buckets[1]?.label, "Spark");
+	assert.deepEqual(snapshot.credits, {
+		hasCredits: true,
+		unlimited: false,
+		balance: "12.50",
+		resetCreditCount: 3,
+	});
+});
+
+void test("accepts null additional rate limits as no additional buckets", () => {
+	const snapshot = parseCodexUsagePayload(
+		{ ...payload, additional_rate_limits: null },
+		1_900_000_000_000,
+	);
+
+	assert.deepEqual(snapshot.buckets, [
+		{
+			id: "codex",
+			label: undefined,
+			primary: {
+				usedPercent: 37,
+				windowMinutes: 300,
+				resetsAt: 2_000_000_000,
+			},
+			secondary: {
+				usedPercent: 71,
+				windowMinutes: 10_080,
+				resetsAt: 2_000_100_000,
+			},
+		},
+	]);
+});
+
+void test("skips valid additional buckets without nested rate limits", () => {
+	for (const rate_limit of [undefined, null]) {
+		const snapshot = parseCodexUsagePayload({
+			...payload,
+			additional_rate_limits: [{ metered_feature: "codex_spark", rate_limit }],
+		});
+
+		assert.equal(snapshot.buckets.length, 1);
+	}
+});
+
+void test("rejects invalid additional rate limit containers", () => {
+	for (const additional_rate_limits of ["invalid", {}, 1, ["invalid"]]) {
+		assert.throws(
+			() => parseCodexUsagePayload({ ...payload, additional_rate_limits }),
+			/additional(?:_| )rate.limit/i,
+		);
+	}
+});
+
+void test("rejects additional buckets without a non-empty metered feature", () => {
+	for (const entry of [
+		{},
+		{ metered_feature: null },
+		{ metered_feature: "" },
+		{ metered_feature: 1 },
+		{ metered_feature: {} },
+	]) {
+		assert.throws(
+			() =>
+				parseCodexUsagePayload({
+					...payload,
+					additional_rate_limits: [entry],
+				}),
+			/metered_feature/i,
+		);
+	}
+});
+
+void test("rejects malformed quota payloads without guessing", () => {
+	assert.throws(
+		() => parseCodexUsagePayload({ plan_type: "plus", rate_limit: {} }),
+		/does not contain any quota windows/i,
+	);
+	assert.throws(
+		() =>
+			parseCodexUsagePayload({
+				plan_type: "plus",
+				rate_limit: { primary_window: { used_percent: "37" } },
+			}),
+		/used_percent/i,
+	);
+});
+
+void test("extracts the current ChatGPT account id without exposing the token", () => {
+	assert.equal(extractCodexAccountId(codexToken("acct_123")), "acct_123");
+	assert.throws(() => extractCodexAccountId("not-a-token"), /account id/i);
+});
+
+void test("fetches usage with bounded, non-redirecting authenticated request", async () => {
+	const accessToken = codexToken("acct_123");
+	let receivedUrl: string | undefined;
+	let receivedInit: RequestInit | undefined;
+	const fakeFetch: typeof fetch = (url, init) => {
+		receivedUrl =
+			typeof url === "string"
+				? url
+				: url instanceof URL
+					? url.toString()
+					: url.url;
+		receivedInit = init;
+		return Promise.resolve(
+			new Response(JSON.stringify(payload), {
+				status: 200,
+				headers: { "content-type": "application/json" },
+			}),
+		);
+	};
+
+	const snapshot = await fetchCodexUsage(
+		{ accessToken, accountId: "acct_123" },
+		{ fetch: fakeFetch, now: () => 1_900_000_000_000 },
+	);
+
+	assert.equal(receivedUrl, "https://chatgpt.com/backend-api/wham/usage");
+	assert.equal(receivedInit?.method, "GET");
+	assert.equal(receivedInit?.redirect, "error");
+	const headers = new Headers(receivedInit?.headers);
+	assert.equal(headers.get("authorization"), `Bearer ${accessToken}`);
+	assert.equal(headers.get("chatgpt-account-id"), "acct_123");
+	assert.equal(headers.get("originator"), "pi");
+	assert.equal(headers.get("accept"), "application/json");
+	assert.match(headers.get("user-agent") ?? "", /^pi \(.+; .+\)$/);
+	assert.equal(snapshot.planType, "plus");
+});
+
+void test("reports expired Codex sessions on 401 without exposing response bodies or tokens", async () => {
+	const accessToken = "secret-access-token";
+	const fakeFetch: typeof fetch = () =>
+		Promise.resolve(new Response("sensitive upstream response", { status: 401 }));
+
+	await assert.rejects(
+		fetchCodexUsage({ accessToken, accountId: "acct_123" }, { fetch: fakeFetch }),
+		(error: unknown) => {
+			assert(error instanceof Error);
+			assert.match(
+				error.message,
+				/session expired.*\/login|\/login.*session expired/i,
+			);
+			assert.doesNotMatch(
+				error.message,
+				/sensitive upstream response|secret-access-token/i,
+			);
+			return true;
+		},
+	);
+});
+
+void test("reports unavailable usage access on 403 without claiming the session is logged out", async () => {
+	const accessToken = "secret-access-token";
+	const fakeFetch: typeof fetch = () =>
+		Promise.resolve(new Response("sensitive upstream response", { status: 403 }));
+
+	await assert.rejects(
+		fetchCodexUsage({ accessToken, accountId: "acct_123" }, { fetch: fakeFetch }),
+		(error: unknown) => {
+			assert(error instanceof Error);
+			assert.match(error.message, /usage access.*unavailable|forbidden/i);
+			assert.doesNotMatch(
+				error.message,
+				/login|logged out|sensitive upstream response|secret-access-token/i,
+			);
+			return true;
+		},
+	);
+});

package/extensions/osdy-pi/codex-usage.ts

@@ -0,0 +1,276 @@
+import { arch, platform, release } from "node:os";
+
+export type CodexUsageWindow = {
+	usedPercent: number;
+	windowMinutes: number | undefined;
+	resetsAt: number | undefined;
+};
+
+export type CodexUsageBucket = {
+	id: string;
+	label: string | undefined;
+	primary: CodexUsageWindow | undefined;
+	secondary: CodexUsageWindow | undefined;
+};
+
+export type CodexUsageCredits = {
+	hasCredits: boolean;
+	unlimited: boolean;
+	balance: string | undefined;
+	resetCreditCount: number | undefined;
+};
+
+export type CodexUsageSnapshot = {
+	planType: string | undefined;
+	ordinaryUsageAllowed: boolean | undefined;
+	buckets: CodexUsageBucket[];
+	credits: CodexUsageCredits | undefined;
+	fetchedAt: number;
+};
+
+export type CodexUsageAuth = {
+	accessToken: string;
+	accountId: string;
+};
+
+type FetchCodexUsageOptions = {
+	fetch?: typeof globalThis.fetch;
+	now?: () => number;
+	signal?: AbortSignal;
+	timeoutMs?: number;
+};
+
+const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const MAX_RESPONSE_BYTES = 1_000_000;
+const DEFAULT_TIMEOUT_MS = 10_000;
+
+type UnknownRecord = Record<string, unknown>;
+
+function createPiUserAgent(): string {
+	return `pi (${platform()} ${release()}; ${arch()})`;
+}
+
+function asRecord(value: unknown, label: string): UnknownRecord {
+	if (!value || typeof value !== "object" || Array.isArray(value))
+		throw new Error(`Codex usage ${label} is invalid`);
+	return value as UnknownRecord;
+}
+
+function optionalString(value: unknown, label: string): string | undefined {
+	if (value === undefined || value === null) return undefined;
+	if (typeof value !== "string")
+		throw new Error(`Codex usage ${label} is invalid`);
+	return value;
+}
+
+function optionalBoolean(value: unknown, label: string): boolean | undefined {
+	if (value === undefined || value === null) return undefined;
+	if (typeof value !== "boolean")
+		throw new Error(`Codex usage ${label} is invalid`);
+	return value;
+}
+
+function optionalNumber(value: unknown, label: string): number | undefined {
+	if (value === undefined || value === null) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value))
+		throw new Error(`Codex usage ${label} is invalid`);
+	return value;
+}
+
+function parseWindow(
+	value: unknown,
+	label: string,
+): CodexUsageWindow | undefined {
+	if (value === undefined || value === null) return undefined;
+	const window = asRecord(value, label);
+	const usedPercent = window.used_percent;
+	if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent))
+		throw new Error("Codex usage used_percent is invalid");
+	if (usedPercent < 0 || usedPercent > 100)
+		throw new Error("Codex usage used_percent is out of range");
+	const seconds = window.limit_window_seconds;
+	if (
+		seconds !== undefined &&
+		(typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0)
+	)
+		throw new Error("Codex usage limit_window_seconds is invalid");
+	const resetAt = window.reset_at;
+	if (
+		resetAt !== undefined &&
+		(typeof resetAt !== "number" || !Number.isFinite(resetAt))
+	)
+		throw new Error("Codex usage reset_at is invalid");
+	return {
+		usedPercent,
+		windowMinutes:
+			typeof seconds === "number" ? Math.round(seconds / 60) : undefined,
+		resetsAt: typeof resetAt === "number" ? resetAt : undefined,
+	};
+}
+
+function parseBucket(value: unknown): CodexUsageBucket | undefined {
+	const bucket = asRecord(value, "additional rate limit");
+	const id = bucket.metered_feature;
+	if (typeof id !== "string" || id.trim().length === 0)
+		throw new Error("Codex usage metered_feature is invalid");
+	const rateLimit = bucket.rate_limit;
+	if (rateLimit === undefined || rateLimit === null) return undefined;
+	const rate = asRecord(rateLimit, "additional rate limit");
+	const primary = parseWindow(rate.primary_window, "primary_window");
+	const secondary = parseWindow(rate.secondary_window, "secondary_window");
+	if (!primary && !secondary) return undefined;
+	return {
+		id,
+		label: optionalString(bucket.limit_name, "limit_name"),
+		primary,
+		secondary,
+	};
+}
+
+export function parseCodexUsagePayload(
+	input: unknown,
+	fetchedAt = Date.now(),
+): CodexUsageSnapshot {
+	const payload = asRecord(input, "payload");
+	const rateLimit = asRecord(payload.rate_limit, "rate_limit");
+	const primary = parseWindow(rateLimit.primary_window, "primary_window");
+	const secondary = parseWindow(rateLimit.secondary_window, "secondary_window");
+	if (!primary && !secondary)
+		throw new Error("Codex usage does not contain any quota windows");
+	const additional = payload.additional_rate_limits;
+	if (
+		additional !== undefined &&
+		additional !== null &&
+		!Array.isArray(additional)
+	)
+		throw new Error("Codex usage additional_rate_limits is invalid");
+	const buckets: CodexUsageBucket[] = [
+		{ id: "codex", label: undefined, primary, secondary },
+	];
+	for (const bucket of additional ?? []) {
+		const parsed = parseBucket(bucket);
+		if (parsed) buckets.push(parsed);
+	}
+	const creditsValue = payload.credits;
+	let credits: CodexUsageCredits | undefined;
+	if (creditsValue !== undefined && creditsValue !== null) {
+		const rawCredits = asRecord(creditsValue, "credits");
+		const hasCredits = optionalBoolean(rawCredits.has_credits, "has_credits");
+		const unlimited = optionalBoolean(rawCredits.unlimited, "unlimited");
+		if (hasCredits === undefined || unlimited === undefined)
+			throw new Error("Codex usage credits are invalid");
+		credits = {
+			hasCredits,
+			unlimited,
+			balance: optionalString(rawCredits.balance, "credit balance"),
+			resetCreditCount: optionalNumber(
+				rawCredits.reset_credit_count,
+				"reset_credit_count",
+			),
+		};
+	}
+	return {
+		planType: optionalString(payload.plan_type, "plan_type"),
+		ordinaryUsageAllowed: optionalBoolean(
+			payload.ordinary_usage_allowed,
+			"ordinary_usage_allowed",
+		),
+		buckets,
+		credits,
+		fetchedAt,
+	};
+}
+
+export function extractCodexAccountId(accessToken: string): string {
+	const payload = accessToken.split(".")[1];
+	if (!payload) throw new Error("Codex account ID is unavailable");
+	try {
+		const decoded = JSON.parse(
+			Buffer.from(payload, "base64url").toString("utf8"),
+		) as unknown;
+		const token = asRecord(decoded, "token");
+		const auth = asRecord(token["https://api.openai.com/auth"], "token auth");
+		const accountId = auth.chatgpt_account_id;
+		if (typeof accountId !== "string" || accountId.length === 0)
+			throw new Error("Codex account ID is unavailable");
+		return accountId;
+	} catch {
+		throw new Error("Codex account ID is unavailable");
+	}
+}
+
+async function readBoundedJson(response: Response): Promise<unknown> {
+	const length = response.headers.get("content-length");
+	if (
+		length !== null &&
+		(!/^\d+$/.test(length) || Number(length) > MAX_RESPONSE_BYTES)
+	)
+		throw new Error("Codex usage response is too large");
+	if (!response.body) throw new Error("Codex usage response is unavailable");
+	const reader = response.body.getReader();
+	const chunks: Uint8Array[] = [];
+	let size = 0;
+	try {
+		while (true) {
+			const next = await reader.read();
+			if (next.done) break;
+			size += next.value.byteLength;
+			if (size > MAX_RESPONSE_BYTES)
+				throw new Error("Codex usage response is too large");
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const merged = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	try {
+		return JSON.parse(new TextDecoder().decode(merged)) as unknown;
+	} catch {
+		throw new Error("Codex usage response is invalid");
+	}
+}
+
+export async function fetchCodexUsage(
+	auth: CodexUsageAuth,
+	options: FetchCodexUsageOptions = {},
+): Promise<CodexUsageSnapshot> {
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const timeout = AbortSignal.timeout(options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+	const signal = options.signal
+		? AbortSignal.any([options.signal, timeout])
+		: timeout;
+	let response: Response;
+	try {
+		response = await fetcher(USAGE_URL, {
+			method: "GET",
+			headers: {
+				accept: "application/json",
+				authorization: `Bearer ${auth.accessToken}`,
+				"chatgpt-account-id": auth.accountId,
+				originator: "pi",
+				"user-agent": createPiUserAgent(),
+			},
+			redirect: "error",
+			signal,
+		});
+	} catch (error) {
+		if (signal.aborted)
+			throw new Error("Codex usage request timed out or was cancelled");
+		void error;
+		throw new Error("Codex usage is temporarily unavailable");
+	}
+	if (response.status === 401)
+		throw new Error("Codex session expired; use /login to sign in again");
+	if (response.status === 403)
+		throw new Error("Codex usage access is unavailable or forbidden");
+	if (!response.ok) throw new Error("Codex usage is temporarily unavailable");
+	return parseCodexUsagePayload(
+		await readBoundedJson(response),
+		(options.now ?? Date.now)(),
+	);
+}