rinco-pi-hud 1.0.0

package/extensions/hud/state/telemetry.ts

@@ -0,0 +1,261 @@
+import { stripVTControlCharacters } from "node:util";
+
+export const TRACKED_TOOL_NAMES = ["read", "write", "edit", "bash", "grep", "ls", "find"] as const;
+
+export type TrackedToolName = (typeof TRACKED_TOOL_NAMES)[number];
+export type ToolStatus = "running" | "completed" | "error";
+export type AgentRunStatus = "running" | "completed";
+
+export interface ToolRecord {
+	toolCallId: string;
+	name: string;
+	target?: string;
+	status: ToolStatus;
+	startTime: number;
+	endTime?: number;
+}
+
+export interface AgentRunRecord {
+	status: AgentRunStatus;
+	startTime: number;
+	endTime?: number;
+}
+
+export interface TelemetryState {
+	sessionName: string | undefined;
+	turnIndex: number;
+	thinkingLevel: string;
+	modelSupportsReasoning: boolean;
+	tools: readonly ToolRecord[];
+	agentRuns: readonly AgentRunRecord[];
+}
+
+export interface TelemetryInitialValues {
+	sessionName?: string;
+	turnIndex?: number;
+	thinkingLevel?: string;
+	modelSupportsReasoning?: boolean;
+}
+
+export type TelemetryUpdate =
+	| ({ type: "metadata" } & TelemetryInitialValues)
+	| { type: "turn-start"; turnIndex?: number }
+	| {
+			type: "tool-call";
+			toolCallId: string;
+			name: string;
+			args?: Record<string, unknown> | null;
+			at: number;
+		}
+	| { type: "tool-result"; toolCallId: string; isError: boolean; at: number }
+	| { type: "agent-start"; at: number }
+	| { type: "agent-end"; at: number };
+
+export interface TelemetryStats {
+	completedToolCounts: Record<TrackedToolName, number>;
+	recentRunningTools: readonly ToolRecord[];
+	activeAgentRuns: number;
+}
+
+const trackedToolNames = new Set<string>(TRACKED_TOOL_NAMES);
+const TOOL_HISTORY_LIMIT = 500;
+const TOOL_HISTORY_RETAINED = 400;
+const AGENT_HISTORY_LIMIT = 500;
+const AGENT_HISTORY_RETAINED = 400;
+const MAX_EXTERNAL_TEXT_LENGTH = 2048;
+const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+
+function sanitizeExternalText(value: string, maxLength = 256): string {
+	return stripVTControlCharacters(value.slice(0, MAX_EXTERNAL_TEXT_LENGTH))
+		.replace(/[\r\n\t\f\v]+/g, " ")
+		.replace(/[\u0000-\u001f\u007f-\u009f]/g, "")
+		.replace(/ +/g, " ")
+		.trim()
+		.slice(0, maxLength);
+}
+
+function normalizeThinkingLevel(value: string | undefined): string {
+	return value && thinkingLevels.has(value) ? value : "off";
+}
+
+export function createTelemetryState(initial: TelemetryInitialValues = {}): TelemetryState {
+	return {
+		sessionName: initial.sessionName ? sanitizeExternalText(initial.sessionName) || undefined : undefined,
+		turnIndex: initial.turnIndex ?? 0,
+		thinkingLevel: normalizeThinkingLevel(initial.thinkingLevel),
+		modelSupportsReasoning: initial.modelSupportsReasoning ?? false,
+		tools: [],
+		agentRuns: [],
+	};
+}
+
+export function resetTelemetryState(
+	_state: TelemetryState,
+	initial: TelemetryInitialValues = {},
+): TelemetryState {
+	return createTelemetryState(initial);
+}
+
+export function sanitizeToolTarget(value: string): string | undefined {
+	return sanitizeExternalText(value, 512) || undefined;
+}
+
+/**
+ * Look up the sanitized `target` (e.g. file path) recorded for a tool call at
+ * `tool_execution_start` time. `ToolExecutionEndEvent` does not carry `args`,
+ * so callers that need the original arguments (e.g. to detect which file a
+ * `read` call touched) must recover them from telemetry state instead of the
+ * end event.
+ */
+export function findToolTarget(state: TelemetryState, toolCallId: string): string | undefined {
+	const sanitizedId = sanitizeExternalText(toolCallId, 256);
+	for (let index = state.tools.length - 1; index >= 0; index -= 1) {
+		const tool = state.tools[index];
+		if (tool?.toolCallId === sanitizedId) return tool.target;
+	}
+	return undefined;
+}
+
+function getToolTarget(args: Record<string, unknown> | null | undefined): string | undefined {
+	if (!args) return undefined;
+	const value = typeof args.path === "string"
+		? args.path
+		: typeof args.filePath === "string"
+			? args.filePath
+			: undefined;
+	return value === undefined ? undefined : sanitizeToolTarget(value);
+}
+
+function updateMetadata(
+	state: TelemetryState,
+	update: Extract<TelemetryUpdate, { type: "metadata" }>,
+): TelemetryState {
+	return {
+		...state,
+		...(Object.hasOwn(update, "sessionName")
+			? {
+					sessionName: update.sessionName
+						? sanitizeExternalText(update.sessionName) || undefined
+						: undefined,
+				}
+			: {}),
+		...(Object.hasOwn(update, "turnIndex") ? { turnIndex: update.turnIndex ?? 0 } : {}),
+		...(Object.hasOwn(update, "thinkingLevel")
+			? { thinkingLevel: normalizeThinkingLevel(update.thinkingLevel) }
+			: {}),
+		...(Object.hasOwn(update, "modelSupportsReasoning")
+			? { modelSupportsReasoning: update.modelSupportsReasoning ?? false }
+			: {}),
+	};
+}
+
+function addTool(
+	state: TelemetryState,
+	update: Extract<TelemetryUpdate, { type: "tool-call" }>,
+): TelemetryState {
+	const target = getToolTarget(update.args);
+	const record: ToolRecord = {
+		toolCallId: sanitizeExternalText(update.toolCallId, 256),
+		name: sanitizeExternalText(update.name, 64) || "tool",
+		...(target === undefined ? {} : { target }),
+		status: "running",
+		startTime: update.at,
+	};
+	let tools = [...state.tools, record];
+	if (tools.length > TOOL_HISTORY_LIMIT) tools = tools.slice(-TOOL_HISTORY_RETAINED);
+	return { ...state, tools };
+}
+
+function finishTool(
+	state: TelemetryState,
+	update: Extract<TelemetryUpdate, { type: "tool-result" }>,
+): TelemetryState {
+	const toolCallId = sanitizeExternalText(update.toolCallId, 256);
+	let matchIndex = -1;
+	for (let index = state.tools.length - 1; index >= 0; index -= 1) {
+		const tool = state.tools[index];
+		if (tool?.toolCallId === toolCallId && tool.status === "running") {
+			matchIndex = index;
+			break;
+		}
+	}
+	if (matchIndex < 0) return state;
+
+	const tools = [...state.tools];
+	tools[matchIndex] = {
+		...tools[matchIndex]!,
+		status: update.isError ? "error" : "completed",
+		endTime: update.at,
+	};
+	return { ...state, tools };
+}
+
+function finishLatestAgentRun(state: TelemetryState, at: number): TelemetryState {
+	let matchIndex = -1;
+	for (let index = state.agentRuns.length - 1; index >= 0; index -= 1) {
+		if (state.agentRuns[index]?.status === "running") {
+			matchIndex = index;
+			break;
+		}
+	}
+	if (matchIndex < 0) return state;
+
+	const agentRuns = [...state.agentRuns];
+	agentRuns[matchIndex] = { ...agentRuns[matchIndex]!, status: "completed", endTime: at };
+	return { ...state, agentRuns };
+}
+
+export function updateTelemetryState(state: TelemetryState, update: TelemetryUpdate): TelemetryState {
+	switch (update.type) {
+		case "metadata":
+			return updateMetadata(state, update);
+		case "turn-start":
+			return { ...state, turnIndex: update.turnIndex ?? state.turnIndex + 1 };
+		case "tool-call":
+			return addTool(state, update);
+		case "tool-result":
+			return finishTool(state, update);
+		case "agent-start": {
+			let agentRuns = [...state.agentRuns, { status: "running" as const, startTime: update.at }];
+			if (agentRuns.length > AGENT_HISTORY_LIMIT) {
+				agentRuns = agentRuns.slice(-AGENT_HISTORY_RETAINED);
+			}
+			return { ...state, agentRuns };
+		}
+		case "agent-end":
+			return finishLatestAgentRun(state, update.at);
+	}
+}
+
+export function getTelemetryStats(state: TelemetryState): TelemetryStats {
+	const completedToolCounts: Record<TrackedToolName, number> = {
+		read: 0,
+		write: 0,
+		edit: 0,
+		bash: 0,
+		grep: 0,
+		ls: 0,
+		find: 0,
+	};
+
+	for (const tool of state.tools) {
+		if (tool.status === "completed" && trackedToolNames.has(tool.name)) {
+			completedToolCounts[tool.name as TrackedToolName] += 1;
+		}
+	}
+
+	const recentRunningTools = state.tools
+		.filter((tool) => tool.status === "running")
+		.slice(-2)
+		.map((tool) => ({ ...tool }));
+	const activeAgentRuns = state.agentRuns.reduce(
+		(count, run) => count + (run.status === "running" ? 1 : 0),
+		0,
+	);
+
+	return { completedToolCounts, recentRunningTools, activeAgentRuns };
+}
+
+export const createTelemetry = createTelemetryState;
+export const resetTelemetry = resetTelemetryState;
+export const updateTelemetry = updateTelemetryState;

package/extensions/hud/telemetry/codex-usage/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 narumiruna
+
+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/extensions/hud/telemetry/codex-usage/app-server-client.ts

@@ -0,0 +1,231 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { normalizeAppServerResponse } from "./normalize.ts";
+import { safeCodexErrorMessage } from "./safety.ts";
+import type {
+	AppServerRateLimitResponse,
+	CodexUsageReport,
+	PendingRpc,
+	RpcResponse,
+} from "./types.ts";
+
+const MAX_ERROR_BODY_CHARS = 600;
+const MAX_RPC_LINE_BYTES = 64 * 1024;
+
+export async function queryViaCodexAppServer(
+	timeoutMs: number,
+	signal?: AbortSignal,
+): Promise<CodexUsageReport> {
+	const client = new CodexAppServerClient(timeoutMs, signal);
+	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 stdoutBuffer = "";
+	private readonly pending = new Map<number, PendingRpc>();
+	private startPromise?: Promise<void>;
+	private exitError?: Error;
+	private readonly timeoutMs: number;
+	private readonly signal?: AbortSignal;
+	private readonly abortHandler = () => {
+		this.rejectAll(new Error("Codex app-server query was cancelled."));
+		this.dispose();
+	};
+
+	constructor(timeoutMs: number, signal?: AbortSignal) {
+		this.timeoutMs = timeoutMs;
+		this.signal = signal;
+	}
+
+	start(): Promise<void> {
+		if (this.startPromise) return this.startPromise;
+		if (this.signal?.aborted) return Promise.reject(new Error("Codex app-server query was cancelled."));
+		this.signal?.addEventListener("abort", this.abortHandler, { once: true });
+
+		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) => {
+				this.exitError = new Error(
+					`codex app-server exited before completing the request (code ${code ?? "unknown"}, signal ${signal ?? "none"}).`,
+				);
+				this.rejectAll(this.exitError);
+			});
+
+			child.stderr.setEncoding("utf8");
+			child.stderr.on("data", (chunk: string) => {
+				this.stderr = truncateEnd(`${this.stderr}${chunk.slice(0, MAX_ERROR_BODY_CHARS)}`, MAX_ERROR_BODY_CHARS);
+			});
+			child.stderr.on("error", () => undefined);
+			child.stdin.on("error", (error) => this.rejectAll(error));
+			child.stdout.setEncoding("utf8");
+			child.stdout.on("data", (chunk: string) => this.handleChunk(chunk));
+			child.stdout.on("error", (error) => this.rejectAll(error));
+		});
+
+		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 {
+		this.signal?.removeEventListener("abort", this.abortHandler);
+		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.exitCode === null && child.signalCode === null) {
+			child.kill("SIGTERM");
+			const forceKill = setTimeout(() => {
+				if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+			}, 1000);
+			forceKill.unref?.();
+		}
+		this.child = undefined;
+	}
+
+	private handleChunk(chunk: string): void {
+		this.stdoutBuffer += chunk.slice(0, MAX_RPC_LINE_BYTES + 1);
+		if (this.stdoutBuffer.length > MAX_RPC_LINE_BYTES) {
+			this.rejectAll(new Error("codex app-server response exceeded the size limit."));
+			this.dispose();
+			return;
+		}
+		let newline = this.stdoutBuffer.indexOf("\n");
+		while (newline >= 0) {
+			const line = this.stdoutBuffer.slice(0, newline);
+			this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1);
+			this.handleLine(line);
+			newline = this.stdoutBuffer.indexOf("\n");
+		}
+	}
+
+	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"
+					? safeCodexErrorMessage(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 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 truncateEnd(value: string, maxChars: number): string {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars - 1)}…`;
+}