@narumitw/pi-codex-usage 0.12.0 → 0.13.1

package/README.md

@@ -98,14 +98,15 @@ The extension does not read Pi or Codex auth files directly, and it does not exp
 ```txt
 extensions/pi-codex-usage/
 ├── src/
-│   └── codex-usage.ts
+│   ├── codex-usage.ts  # Pi entrypoint and cache/lifecycle orchestration
+│   └── *.ts            # Package-local query, RPC, normalization, and format modules
 ├── README.md
 ├── LICENSE
 ├── tsconfig.json
 └── package.json
 ```
 
-The package exposes its Pi extension through `package.json`:
+Only `codex-usage.ts` is a Pi entrypoint; the other source modules are internal. The package exposes its Pi extension through `package.json`:
 
 ```json
 {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-codex-usage",
-	"version": "0.12.0",
+	"version": "0.13.1",
 	"description": "Pi extension that shows Codex ChatGPT subscription usage without requiring Codex CLI.",
 	"type": "module",
 	"license": "MIT",

package/src/app-server-client.ts

@@ -0,0 +1,216 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { normalizeAppServerResponse } from "./normalize.js";
+import type {
+	AppServerRateLimitResponse,
+	CodexUsageReport,
+	PendingRpc,
+	RpcResponse,
+} from "./types.js";
+
+const MAX_ERROR_BODY_CHARS = 600;
+
+export async function queryViaCodexAppServer(timeoutMs: number): Promise<CodexUsageReport> {
+	const client = new CodexAppServerClient(timeoutMs);
+	try {
+		await client.start();
+		await client.request("initialize", {
+			clientInfo: {
+				name: "pi_codex_usage",
+				title: "Pi Codex Usage",
+				version: "0.1.0",
+			},
+			capabilities: {
+				experimentalApi: false,
+				requestAttestation: false,
+				optOutNotificationMethods: [],
+			},
+		});
+		client.notify("initialized");
+		const result = await client.request("account/rateLimits/read", undefined);
+		return normalizeAppServerResponse(
+			assertObject(result, "account/rateLimits/read result") as AppServerRateLimitResponse,
+			Date.now(),
+		);
+	} finally {
+		client.dispose();
+	}
+}
+
+class CodexAppServerClient {
+	private child?: ChildProcessWithoutNullStreams;
+	private nextId = 1;
+	private stderr = "";
+	private readonly pending = new Map<number, PendingRpc>();
+	private startPromise?: Promise<void>;
+	private exitError?: Error;
+	private readonly timeoutMs: number;
+
+	constructor(timeoutMs: number) {
+		this.timeoutMs = timeoutMs;
+	}
+
+	start(): Promise<void> {
+		if (this.startPromise) return this.startPromise;
+
+		this.startPromise = new Promise((resolve, reject) => {
+			const child = spawn("codex", ["app-server", "--listen", "stdio://"], {
+				stdio: ["pipe", "pipe", "pipe"],
+			});
+			this.child = child;
+
+			const startupTimeout = setTimeout(() => {
+				reject(
+					new Error(
+						`Timed out after ${Math.round(this.timeoutMs / 1000)}s starting codex app-server.`,
+					),
+				);
+			}, this.timeoutMs);
+
+			child.once("spawn", () => {
+				clearTimeout(startupTimeout);
+				resolve();
+			});
+
+			child.once("error", (error) => {
+				clearTimeout(startupTimeout);
+				reject(new Error(`Failed to start codex app-server: ${error.message}`));
+				this.rejectAll(error);
+			});
+
+			child.once("exit", (code, signal) => {
+				const suffix = this.stderr ? ` stderr: ${redactErrorBody(this.stderr)}` : "";
+				this.exitError = new Error(
+					`codex app-server exited before completing the request (code ${code ?? "unknown"}, signal ${signal ?? "none"}).${suffix}`,
+				);
+				this.rejectAll(this.exitError);
+			});
+
+			child.stderr.setEncoding("utf8");
+			child.stderr.on("data", (chunk: string) => {
+				this.stderr = truncateEnd(this.stderr + chunk, MAX_ERROR_BODY_CHARS);
+			});
+
+			const lines = createInterface({ input: child.stdout });
+			lines.on("line", (line) => this.handleLine(line));
+		});
+
+		return this.startPromise;
+	}
+
+	request(method: string, params: unknown): Promise<unknown> {
+		const child = this.child;
+		if (!child?.stdin.writable) {
+			throw new Error("codex app-server is not running.");
+		}
+		if (this.exitError) throw this.exitError;
+
+		const id = this.nextId++;
+		const payload = params === undefined ? { method, id } : { method, id, params };
+		const response = new Promise<unknown>((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pending.delete(id);
+				reject(
+					new Error(`Timed out after ${Math.round(this.timeoutMs / 1000)}s waiting for ${method}.`),
+				);
+			}, this.timeoutMs);
+
+			this.pending.set(id, {
+				resolve: (value) => {
+					clearTimeout(timeout);
+					resolve(value);
+				},
+				reject: (error) => {
+					clearTimeout(timeout);
+					reject(error);
+				},
+			});
+		});
+
+		child.stdin.write(`${JSON.stringify(payload)}\n`);
+		return response;
+	}
+
+	notify(method: string): void {
+		const child = this.child;
+		if (!child?.stdin.writable) return;
+		child.stdin.write(`${JSON.stringify({ method })}\n`);
+	}
+
+	dispose(): void {
+		for (const [id, pending] of this.pending) {
+			pending.reject(new Error(`codex app-server request ${id} cancelled.`));
+		}
+		this.pending.clear();
+
+		const child = this.child;
+		if (!child) return;
+		child.stdin.end();
+		if (!child.killed) child.kill();
+		this.child = undefined;
+	}
+
+	private handleLine(line: string): void {
+		let parsed: RpcResponse;
+		try {
+			parsed = JSON.parse(line) as RpcResponse;
+		} catch {
+			return;
+		}
+
+		if (typeof parsed.id !== "number") return;
+		const pending = this.pending.get(parsed.id);
+		if (!pending) return;
+		this.pending.delete(parsed.id);
+
+		if (parsed.error) {
+			const message =
+				typeof parsed.error.message === "string" ? parsed.error.message : "unknown error";
+			pending.reject(new Error(`codex app-server request failed: ${message}`));
+			return;
+		}
+
+		pending.resolve(parsed.result);
+	}
+
+	private rejectAll(error: Error): void {
+		for (const pending of this.pending.values()) pending.reject(error);
+		this.pending.clear();
+	}
+}
+
+function parseJsonObject(text: string, description: string): Record<string, unknown> {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(text) as unknown;
+	} catch (error) {
+		throw new Error(`${description} was not valid JSON: ${errorMessage(error)}`);
+	}
+	return assertObject(parsed, description);
+}
+
+function assertObject(value: unknown, description: string): Record<string, unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error(`${description} was not an object.`);
+	}
+	return value as Record<string, unknown>;
+}
+
+function redactErrorBody(body: string): string {
+	return truncateEnd(
+		body
+			.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer <redacted>")
+			.replace(/"access_token"\s*:\s*"[^"]+"/gi, '"access_token":"<redacted>"')
+			.trim(),
+		MAX_ERROR_BODY_CHARS,
+	);
+}
+
+function truncateEnd(value: string, maxChars: number): string {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars - 1)}…`;
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}