@yukikisaku/pi-reset-codex 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yuki-kisaku
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# pi-reset-codex
+
+## Overview
+
+Use an earned Codex reset credit from inside Pi.
+
+## Requirements
+
+Requires the `codex` CLI, an authenticated Codex account, and an account with reset-credit support. The extension starts `codex app-server` locally and calls its rate-limit reset methods.
+
+## Installation
+
+```sh
+pi install npm:@yukikisaku/pi-reset-codex
+```
+
+## Usage
+
+Run `/reset-codex`. Pi shows current weekly usage and available reset credits before asking for confirmation. Confirming consumes one earned reset credit, changes the Codex weekly usage limit state, and reduces the available reset-credit count by one. The extension does not provide an undo action. After the reset, Pi refreshes the displayed usage and remaining credits.
+
+## Configuration
+
+Set `CODEX_BIN` if the Codex executable is not named `codex`.
+
+## Uninstallation
+
+```sh
+pi uninstall npm:@yukikisaku/pi-reset-codex
+```
+
+Remove any package-specific configuration described above if you no longer need it.
+
+## License
+
+MIT © yuki-kisaku. See [LICENSE](LICENSE).

package/codex-app-server.ts

@@ -0,0 +1,267 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+
+export type RateLimitWindow = {
+	usedPercent: number;
+	windowDurationMins?: number | null;
+	resetsAt?: number | null;
+};
+
+export type RateLimitSnapshot = {
+	limitId?: string | null;
+	limitName?: string | null;
+	primary?: RateLimitWindow | null;
+	secondary?: RateLimitWindow | null;
+};
+
+export type AccountRateLimits = {
+	rateLimits: RateLimitSnapshot;
+	rateLimitsByLimitId?: Record<string, RateLimitSnapshot> | null;
+	rateLimitResetCredits?: {
+		availableCount: number;
+	} | null;
+};
+
+export type ResetOutcome = "reset" | "nothingToReset" | "noCredit" | "alreadyRedeemed";
+
+export type ConsumeResetResponse = {
+	outcome: ResetOutcome;
+};
+
+export type CodexAppServerOptions = {
+	command?: string;
+	args?: string[];
+	timeoutMs?: number;
+	env?: NodeJS.ProcessEnv;
+};
+
+type PendingRequest = {
+	resolve: (value: unknown) => void;
+	reject: (error: Error) => void;
+	timer: NodeJS.Timeout;
+};
+
+type RpcResponse = {
+	id?: number | string;
+	result?: unknown;
+	error?: {
+		code?: number;
+		message?: string;
+		data?: unknown;
+	};
+};
+
+const CLIENT_INFO = {
+	name: "pi-reset-codex",
+	title: "Pi Codex Reset",
+	version: "0.1.0",
+};
+const DEFAULT_TIMEOUT_MS = 15_000;
+const WEEK_MINUTES = 7 * 24 * 60;
+const WEEK_TOLERANCE_MINUTES = 5;
+const STDERR_LIMIT = 8_192;
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function rpcErrorMessage(error: NonNullable<RpcResponse["error"]>): string {
+	const code = typeof error.code === "number" ? ` (${error.code})` : "";
+	return `${error.message ?? "Codex App Server request failed"}${code}`;
+}
+
+export class CodexAppServerClient {
+	private readonly command: string;
+	private readonly args: string[];
+	private readonly timeoutMs: number;
+	private readonly env: NodeJS.ProcessEnv;
+	private child?: ChildProcessWithoutNullStreams;
+	private startPromise?: Promise<void>;
+	private stdoutBuffer = "";
+	private stderrBuffer = "";
+	private nextId = 0;
+	private readonly pending = new Map<number, PendingRequest>();
+	private closed = false;
+
+	constructor(options: CodexAppServerOptions = {}) {
+		this.command = options.command ?? process.env.CODEX_BIN ?? "codex";
+		this.args = options.args ?? [];
+		this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.env = options.env ?? process.env;
+	}
+
+	start(): Promise<void> {
+		if (this.startPromise) return this.startPromise;
+		this.startPromise = this.initialize();
+		return this.startPromise;
+	}
+
+	async request<T>(method: string, params?: unknown): Promise<T> {
+		await this.start();
+		return this.requestRaw<T>(method, params);
+	}
+
+	async close(): Promise<void> {
+		if (this.closed) return;
+		this.closed = true;
+		const child = this.child;
+		if (!child) return;
+
+		for (const pending of this.pending.values()) {
+			clearTimeout(pending.timer);
+			pending.reject(new Error("Codex App Server connection closed"));
+		}
+		this.pending.clear();
+
+		if (child.exitCode !== null || child.signalCode !== null) return;
+		child.stdin.end();
+		child.kill("SIGTERM");
+		await new Promise<void>(resolve => {
+			const timer = setTimeout(() => {
+				if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+				resolve();
+			}, 500);
+			child.once("exit", () => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+	}
+
+	private async initialize(): Promise<void> {
+		if (this.closed) throw new Error("Codex App Server client is closed");
+		const child = spawn(this.command, [...this.args, "app-server"], {
+			stdio: ["pipe", "pipe", "pipe"],
+			env: this.env,
+		});
+		this.child = child;
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", chunk => this.handleStdout(String(chunk)));
+		child.stderr.on("data", chunk => {
+			this.stderrBuffer = (this.stderrBuffer + String(chunk)).slice(-STDERR_LIMIT);
+		});
+		child.once("error", error => this.failAll(new Error(`Codexを起動できません: ${error.message}`)));
+		child.once("exit", (code, signal) => {
+			if (this.closed) return;
+			const detail = this.stderrBuffer.trim();
+			const suffix = detail ? `: ${detail}` : "";
+			this.failAll(new Error(`Codex App Serverが終了しました (code=${code}, signal=${signal})${suffix}`));
+		});
+
+		try {
+			await this.requestRaw("initialize", { clientInfo: CLIENT_INFO });
+			this.send({ method: "initialized", params: {} });
+		} catch (error) {
+			await this.close();
+			throw error;
+		}
+	}
+
+	private requestRaw<T>(method: string, params?: unknown): Promise<T> {
+		const id = this.nextId++;
+		return new Promise<T>((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new Error(`Codex App Serverが${this.timeoutMs}ms以内に応答しませんでした: ${method}`));
+			}, this.timeoutMs);
+			this.pending.set(id, {
+				resolve: value => resolve(value as T),
+				reject,
+				timer,
+			});
+			try {
+				this.send(params === undefined ? { method, id } : { method, id, params });
+			} catch (error) {
+				clearTimeout(timer);
+				this.pending.delete(id);
+				reject(new Error(`Codex App Serverへの送信に失敗しました: ${errorMessage(error)}`));
+			}
+		});
+	}
+
+	private send(message: unknown): void {
+		const child = this.child;
+		if (!child || child.stdin.destroyed || !child.stdin.writable) {
+			throw new Error("Codex App Serverの標準入力を利用できません");
+		}
+		child.stdin.write(`${JSON.stringify(message)}\n`);
+	}
+
+	private handleStdout(chunk: string): void {
+		this.stdoutBuffer += chunk;
+		while (true) {
+			const newline = this.stdoutBuffer.indexOf("\n");
+			if (newline < 0) return;
+			const line = this.stdoutBuffer.slice(0, newline).replace(/\r$/, "");
+			this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1);
+			if (line.trim() === "") continue;
+			let message: RpcResponse;
+			try {
+				message = JSON.parse(line) as RpcResponse;
+			} catch (error) {
+				this.failAll(new Error(`Codex App Serverから不正なJSONを受信しました: ${errorMessage(error)}`));
+				continue;
+			}
+			if (typeof message.id !== "number") continue;
+			const pending = this.pending.get(message.id);
+			if (!pending) continue;
+			clearTimeout(pending.timer);
+			this.pending.delete(message.id);
+			if (message.error) pending.reject(new Error(rpcErrorMessage(message.error)));
+			else pending.resolve(message.result);
+		}
+	}
+
+	private failAll(error: Error): void {
+		for (const pending of this.pending.values()) {
+			clearTimeout(pending.timer);
+			pending.reject(error);
+		}
+		this.pending.clear();
+	}
+}
+
+async function runCodexRequest<T>(method: string, params: unknown, options: CodexAppServerOptions): Promise<T> {
+	const client = new CodexAppServerClient(options);
+	try {
+		return await client.request<T>(method, params);
+	} finally {
+		await client.close();
+	}
+}
+
+export function readAccountRateLimits(options: CodexAppServerOptions = {}): Promise<AccountRateLimits> {
+	return runCodexRequest<AccountRateLimits>("account/rateLimits/read", undefined, options);
+}
+
+export function consumeRateLimitResetCredit(
+	idempotencyKey: string,
+	options: CodexAppServerOptions = {},
+): Promise<ConsumeResetResponse> {
+	return runCodexRequest<ConsumeResetResponse>(
+		"account/rateLimitResetCredit/consume",
+		{ idempotencyKey },
+		options,
+	);
+}
+
+export function getWeeklyWindow(rateLimits: AccountRateLimits): RateLimitWindow | undefined {
+	const snapshots: RateLimitSnapshot[] = [];
+	const byId = rateLimits.rateLimitsByLimitId;
+	if (byId?.codex) snapshots.push(byId.codex);
+	if (byId) {
+		for (const [id, snapshot] of Object.entries(byId)) {
+			if (id !== "codex") snapshots.push(snapshot);
+		}
+	}
+	if (!snapshots.includes(rateLimits.rateLimits)) snapshots.push(rateLimits.rateLimits);
+
+	for (const snapshot of snapshots) {
+		for (const window of [snapshot.primary, snapshot.secondary]) {
+			if (!window || typeof window.windowDurationMins !== "number") continue;
+			if (Math.abs(window.windowDurationMins - WEEK_MINUTES) <= WEEK_TOLERANCE_MINUTES) return window;
+		}
+	}
+
+	return undefined;
+}

package/index.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from "node:crypto";
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import {
+	consumeRateLimitResetCredit,
+	getWeeklyWindow,
+	readAccountRateLimits,
+	type AccountRateLimits,
+	type ConsumeResetResponse,
+	type ResetOutcome,
+} from "./codex-app-server.ts";
+
+const COMMAND = "reset-codex";
+const STATUS_KEY = "pi-reset-codex";
+
+export type ResetCodexDependencies = {
+	readRateLimits: () => Promise<AccountRateLimits>;
+	consumeReset: (idempotencyKey: string) => Promise<ConsumeResetResponse>;
+	createIdempotencyKey: () => string;
+};
+
+const defaultDependencies: ResetCodexDependencies = {
+	readRateLimits: readAccountRateLimits,
+	consumeReset: consumeRateLimitResetCredit,
+	createIdempotencyKey: randomUUID,
+};
+
+function availableCount(rateLimits: AccountRateLimits): number | undefined {
+	const count = rateLimits.rateLimitResetCredits?.availableCount;
+	return typeof count === "number" ? count : undefined;
+}
+
+function formatUsage(rateLimits: AccountRateLimits): string {
+	const weekly = getWeeklyWindow(rateLimits);
+	return weekly ? `${weekly.usedPercent}%` : "不明";
+}
+
+function formatCount(count: number | undefined): string {
+	return count === undefined ? "不明" : `${count}回`;
+}
+
+function notify(
+	ctx: ExtensionCommandContext,
+	message: string,
+	type: "info" | "warning" | "error" = "info",
+): void {
+	if (ctx.mode === "print") {
+		console.log(message);
+		return;
+	}
+	if (ctx.mode === "json") return;
+	ctx.ui.notify(message, type);
+}
+
+function outcomeMessage(outcome: Exclude<ResetOutcome, "reset" | "alreadyRedeemed">): string {
+	if (outcome === "nothingToReset") return "現在リセットできるCodex利用枠はありません。";
+	return "利用可能なCodexリセット権がありません。";
+}
+
+async function showSuccess(
+	ctx: ExtensionCommandContext,
+	before: AccountRateLimits,
+	dependencies: ResetCodexDependencies,
+): Promise<void> {
+	ctx.ui.setStatus(STATUS_KEY, "Codex limitを再確認中…");
+	try {
+		const after = await dependencies.readRateLimits();
+		notify(
+			ctx,
+			`Codex weekly limitをリセットしました（${formatUsage(before)} → ${formatUsage(after)}、残り${formatCount(availableCount(after))}）。`,
+			"info",
+		);
+	} catch {
+		notify(ctx, "Codex weekly limitをリセットしました。最新状態の再取得には失敗しました。", "warning");
+	}
+}
+
+export function createResetCodexHandler(dependencies: ResetCodexDependencies = defaultDependencies) {
+	return async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
+		if (args.trim() !== "") {
+			notify(ctx, "/reset-codex に引数はありません。", "warning");
+			return;
+		}
+		if (!ctx.hasUI) {
+			notify(ctx, "/reset-codex はPiの対話モードで実行してください。", "warning");
+			return;
+		}
+
+		ctx.ui.setStatus(STATUS_KEY, "Codex limitを確認中…");
+		try {
+			const before = await dependencies.readRateLimits();
+			const count = availableCount(before);
+			if (count !== undefined && count <= 0) {
+				notify(ctx, "利用可能なCodexリセット権がありません。", "warning");
+				return;
+			}
+
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			const confirmed = await ctx.ui.confirm(
+				"Codex weekly limitをリセット？",
+				`獲得済みリセット権を1回使用します。\n現在のweekly使用率: ${formatUsage(before)}\n利用可能: ${formatCount(count)}`,
+			);
+			if (!confirmed) {
+				notify(ctx, "Codex limitのリセットをキャンセルしました。", "info");
+				return;
+			}
+
+			ctx.ui.setStatus(STATUS_KEY, "Codex weekly limitをリセット中…");
+			const result = await dependencies.consumeReset(dependencies.createIdempotencyKey());
+			if (result.outcome === "reset" || result.outcome === "alreadyRedeemed") {
+				await showSuccess(ctx, before, dependencies);
+				return;
+			}
+			notify(ctx, outcomeMessage(result.outcome), "warning");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			notify(ctx, `Codex weekly limitのリセットに失敗しました: ${message}`, "error");
+		} finally {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+		}
+	};
+}
+
+export default function piCodexResetExtension(pi: ExtensionAPI) {
+	pi.registerCommand(COMMAND, {
+		description: "獲得済みのリセット権でCodex weekly limitをリセットする",
+		handler: createResetCodexHandler(),
+	});
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@yukikisaku/pi-reset-codex",
+  "version": "0.1.0",
+  "description": "Use an earned Codex reset credit from inside Pi.",
+  "type": "module",
+  "license": "MIT",
+  "author": "yuki-kisaku",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yukikisaku/pi-reset-codex.git"
+  },
+  "homepage": "https://github.com/yukikisaku/pi-reset-codex#readme",
+  "bugs": {
+    "url": "https://github.com/yukikisaku/pi-reset-codex/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension"
+  ],
+  "files": [
+    "index.ts",
+    "codex-app-server.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "scripts": {
+    "test": "node --no-warnings ./test/smoke.ts"
+  }
+}