@oai404iao/pi-codex-minimal-tools 1.3.0

package/src/codex-wire-identity.ts

@@ -0,0 +1,182 @@
+//! Codex wire identity: UUID v7 session/thread/window identifiers and the
+//! sticky-routing turn-state token, matching the Codex CLI's request identity.
+//!
+//! Pi's own session ids are short opaque strings (often 8 hex chars). The
+//! Codex ChatGPT backend expects real UUID-shaped ids in `session-id`,
+//! `thread-id`, `x-codex-window-id`, `prompt_cache_key`, and
+//! `client_metadata`; the CLI generates UUID v7 values. This module derives a
+//! stable UUID v7 identity per (pi session, thread) pair and remembers the
+//! `x-codex-turn-state` sticky-routing token emitted by the backend so later
+//! requests in the same session can replay it.
+
+const WIRE_IDENTITY_CACHE_LIMIT = 1024;
+
+export interface CodexWireIdentity {
+	/** Stable UUID v7 for the pi session. */
+	sessionId: string;
+	/** Stable UUID v7 for the thread (defaults to a per-thread value). */
+	threadId: string;
+	/** UUID v7 for the current auto-compact window; rotated on compaction. */
+	windowId: string;
+}
+
+interface CachedThread {
+	threadId: string;
+	windowId: string;
+}
+
+interface CachedSession {
+	sessionId: string;
+	threads: Map<string, CachedThread>;
+}
+
+const sessionCache = new Map<string, CachedSession>();
+const turnStateCache = new Map<string, string>();
+const installationIdCache = new Map<string, string>();
+
+function randomBytes(count: number): Uint8Array {
+	if (typeof globalThis.crypto?.getRandomValues === "function") {
+		const bytes = new Uint8Array(count);
+		globalThis.crypto.getRandomValues(bytes);
+		return bytes;
+	}
+	const bytes = new Uint8Array(count);
+	for (let index = 0; index < count; index++) {
+		bytes[index] = Math.floor(Math.random() * 256);
+	}
+	return bytes;
+}
+
+function uuidBytesToHex(bytes: Uint8Array): string {
+	const hex: string[] = [];
+	for (const byte of bytes) {
+		hex.push(byte.toString(16).padStart(2, "0"));
+	}
+	return [
+		hex.slice(0, 4).join(""),
+		hex.slice(4, 6).join(""),
+		hex.slice(6, 8).join(""),
+		hex.slice(8, 10).join(""),
+		hex.slice(10, 16).join(""),
+	].join("-");
+}
+
+/** RFC 9562 UUID v7: 48-bit millisecond timestamp + random, version 7, variant RFC 4122. */
+export function uuidV7(): string {
+	const bytes = randomBytes(16);
+	const timestamp = Date.now();
+	bytes[0] = (timestamp / 0x10000000000) & 0xff;
+	bytes[1] = (timestamp / 0x100000000) & 0xff;
+	bytes[2] = (timestamp / 0x1000000) & 0xff;
+	bytes[3] = (timestamp / 0x10000) & 0xff;
+	bytes[4] = (timestamp / 0x100) & 0xff;
+	bytes[5] = timestamp & 0xff;
+	bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x70;
+	bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+	return uuidBytesToHex(bytes);
+}
+
+function uuidV4(): string {
+	const bytes = randomBytes(16);
+	bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40;
+	bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+	return uuidBytesToHex(bytes);
+}
+
+/**
+ * Stable per-session installation id (UUID v4), mirroring the CLI's
+ * `installation_id` file: one opaque id per installation that never changes
+ * for the lifetime of the session.
+ */
+export function codexInstallationIdFor(sessionKey: string): string {
+	let id = installationIdCache.get(sessionKey);
+	if (!id) {
+		id = typeof globalThis.crypto?.randomUUID === "function"
+			? globalThis.crypto.randomUUID()
+			: uuidV4();
+		installationIdCache.set(sessionKey, id);
+	}
+	return id;
+}
+
+function newCachedSession(): CachedSession {
+	return {
+		sessionId: uuidV7(),
+		threads: new Map(),
+	};
+}
+
+function ensureSession(sessionKey: string): CachedSession {
+	let session = sessionCache.get(sessionKey);
+	if (!session) {
+		if (sessionCache.size >= WIRE_IDENTITY_CACHE_LIMIT) {
+			sessionCache.clear();
+			turnStateCache.clear();
+		}
+		session = newCachedSession();
+		sessionCache.set(sessionKey, session);
+	}
+	return session;
+}
+
+function ensureThread(session: CachedSession, threadKey: string): CachedThread {
+	let thread = session.threads.get(threadKey);
+	if (!thread) {
+		thread = { threadId: uuidV7(), windowId: uuidV7() };
+		session.threads.set(threadKey, thread);
+	}
+	return thread;
+}
+
+/**
+ * Resolve the stable UUID v7 wire identity for a (session, thread) pair.
+ * Values are generated once and reused for the lifetime of the pair so the
+ * backend sees consistent `session-id`/`thread-id`/`x-codex-window-id` values,
+ * exactly like the Codex CLI.
+ */
+export function resolveCodexWireIdentity(
+	sessionKey: string,
+	threadKey?: string,
+): CodexWireIdentity {
+	const session = ensureSession(sessionKey);
+	const thread = ensureThread(session, threadKey ?? sessionKey);
+	return {
+		sessionId: session.sessionId,
+		threadId: thread.threadId,
+		windowId: thread.windowId,
+	};
+}
+
+/**
+ * Rotate the auto-compact window id for a (session, thread) pair. Session and
+ * thread ids stay stable; only `x-codex-window-id` changes, mirroring the
+ * CLI's auto-compact window lifecycle.
+ */
+export function rotateCodexWindowId(sessionKey: string, threadKey?: string): void {
+	const session = ensureSession(sessionKey);
+	const thread = ensureThread(session, threadKey ?? sessionKey);
+	thread.windowId = uuidV7();
+}
+
+/** Current sticky-routing turn-state token for a session, if the backend issued one. */
+export function codexTurnStateFor(sessionKey: string): string | undefined {
+	return turnStateCache.get(sessionKey);
+}
+
+/** Remember the sticky-routing token emitted by the backend. */
+export function captureCodexTurnState(sessionKey: string, token: string | undefined): void {
+	if (!sessionKey || typeof token !== "string" || !token.trim()) return;
+	turnStateCache.set(sessionKey, token.trim());
+}
+
+/** Forget all derived identity and turn-state state (tests, session teardown). */
+export function resetCodexWireState(): void {
+	sessionCache.clear();
+	turnStateCache.clear();
+	installationIdCache.clear();
+}
+
+/** Current number of cached identities (diagnostics/tests). */
+export function codexWireIdentityCount(): number {
+	return sessionCache.size;
+}

package/src/fast-mode.ts

@@ -0,0 +1,124 @@
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	modelKey,
+	type ModelLike,
+} from "./capabilities.js";
+import { loadModelSettings } from "./model-catalog/runtime.js";
+import type { ResolvedCodexModelSettings } from "./model-catalog/runtime.js";
+import {
+	configPath,
+	loadSettings,
+	updateConfig,
+	type CodexMinimalToolsSettings,
+} from "./settings.js";
+
+export const FAST_MODE_STATUS_KEY = "codex-fast-mode";
+export const FAST_MODE_SERVICE_TIER = "priority" as const;
+
+export function isFastModeModel(model: ModelLike | undefined): boolean {
+	return Boolean(loadModelSettings(model).fastServiceTier);
+}
+
+export function resolveFastModeServiceTier(
+	settings: Pick<CodexMinimalToolsSettings, "enabled" | "fastMode"> & Partial<ResolvedCodexModelSettings>,
+	model: ModelLike | undefined,
+): string | undefined {
+	if (!settings.enabled || !settings.fastMode) return undefined;
+	if (settings.modelProfile) return settings.fastServiceTier;
+	return loadModelSettings(model, undefined, settings as CodexMinimalToolsSettings).fastServiceTier;
+}
+
+export function applyFastModeServiceTier<T extends Record<string, unknown>>(
+	body: T,
+	settings: Pick<CodexMinimalToolsSettings, "enabled" | "fastMode"> & Partial<ResolvedCodexModelSettings>,
+	model: ModelLike | undefined,
+): T {
+	const serviceTier = resolveFastModeServiceTier(settings, model);
+	if (!serviceTier || body.service_tier !== undefined) return body;
+	return { ...body, service_tier: serviceTier };
+}
+
+function fastModeLines(ctx: ExtensionContext): string[] {
+	const settings = loadSettings(ctx.cwd);
+	const model = ctx.model as ModelLike | undefined;
+	const modelSettings = loadModelSettings(model, ctx.cwd, settings);
+	const activeTier = resolveFastModeServiceTier(modelSettings, model);
+	return [
+		"Codex Fast mode",
+		`enabled: ${settings.fastMode}`,
+		`service tier: ${modelSettings.fastServiceTier ?? "(unsupported)"}`,
+		`model: ${modelKey(model)}`,
+		`active for current model: ${Boolean(activeTier)}`,
+		`config: ${configPath()}`,
+	];
+}
+
+export function syncFastModeStatus(ctx: ExtensionContext): void {
+	const settings = loadSettings(ctx.cwd);
+	const model = ctx.model as ModelLike | undefined;
+	const tier = resolveFastModeServiceTier(loadModelSettings(model, ctx.cwd, settings), model);
+	const ui = ctx.ui as ExtensionContext["ui"] | undefined;
+	ui?.setStatus?.(
+		FAST_MODE_STATUS_KEY,
+		tier,
+	);
+}
+
+function showFastModeStatus(ctx: ExtensionCommandContext): void {
+	syncFastModeStatus(ctx as ExtensionContext);
+	ctx.ui.notify(fastModeLines(ctx as ExtensionContext).join("\n"), "info");
+}
+
+export function registerFastMode(pi: ExtensionAPI): void {
+	pi.registerCommand("fast", {
+		description: "Toggle model-profile Fast mode. Usage: /fast [on|off|status]",
+		handler: async (args: string, ctx) => {
+			const command = args.trim().toLowerCase().split(/\s+/, 1)[0] ?? "";
+			const settings = loadSettings(ctx.cwd);
+			let patch: Partial<CodexMinimalToolsSettings> | undefined;
+
+			switch (command) {
+				case "":
+					patch = { fastMode: !settings.fastMode };
+					break;
+				case "on":
+					patch = { fastMode: true };
+					break;
+				case "off":
+					patch = { fastMode: false };
+					break;
+				case "status":
+					showFastModeStatus(ctx);
+					return;
+				default:
+					ctx.ui.notify("Usage: /fast [on|off|status]", "warning");
+					return;
+			}
+
+			try {
+				updateConfig(patch);
+				showFastModeStatus(ctx);
+			} catch (error) {
+				ctx.ui.notify(
+					`Failed to update Fast mode: ${error instanceof Error ? error.message : String(error)}`,
+					"error",
+				);
+			}
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		syncFastModeStatus(ctx);
+	});
+	pi.on("model_select", async (_event, ctx) => {
+		syncFastModeStatus(ctx);
+	});
+	pi.on("session_shutdown", async (_event, ctx) => {
+		const ui = ctx.ui as ExtensionContext["ui"] | undefined;
+		ui?.setStatus?.(FAST_MODE_STATUS_KEY, undefined);
+	});
+}

package/src/glyphs.ts

@@ -0,0 +1,70 @@
+import { loadSettings } from "./settings.js";
+
+export type GlyphStyle = "unicode" | "ascii";
+
+export function glyphStyle(cwd?: string): GlyphStyle {
+	return loadSettings(cwd).glyphStyle;
+}
+
+export const GLYPHS = {
+	unicode: {
+		frame: { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃" },
+		line: "─",
+		tree: { mid: "├─ ", last: "└─ ", stem: "│  ", blank: "   " },
+		bullet: "● ",
+		emptyBullet: "○ ",
+		dot: " · ",
+		ok: "✓",
+		fail: "✗",
+		warn: "▲",
+		diamond: "◆",
+		prompt: "π",
+		ellipsis: "…",
+		arrow: "→",
+		codeBar: "▌",
+	},
+	ascii: {
+		frame: { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" },
+		line: "-",
+		tree: { mid: "|-- ", last: "`-- ", stem: "|  ", blank: "   " },
+		bullet: "* ",
+		emptyBullet: "o ",
+		dot: " - ",
+		ok: "+",
+		fail: "x",
+		warn: "!",
+		diamond: "*",
+		prompt: "pi",
+		ellipsis: "...",
+		arrow: "->",
+		codeBar: "|",
+	},
+} as const;
+
+export function glyphs(cwd?: string): (typeof GLYPHS)[GlyphStyle] {
+	return GLYPHS[glyphStyle(cwd)];
+}
+
+export function truncateIndicator(cwd?: string): string {
+	return glyphs(cwd).ellipsis;
+}
+
+export function truncateText(text: string, maxChars: number, cwd?: string): string {
+	if (text.length <= maxChars) return text;
+	const indicator = truncateIndicator(cwd);
+	return `${text.slice(0, Math.max(0, maxChars - indicator.length))}${indicator}`;
+}
+
+export function dot(cwd?: string): string {
+	return glyphs(cwd).dot;
+}
+
+export function treeGlyph(branch: "├" | "└" | "│", cwd?: string): string {
+	const tree = glyphs(cwd).tree;
+	if (branch === "│") return tree.stem;
+	return branch === "└" ? tree.last : tree.mid;
+}
+
+export function frameGlyphs(cwd?: string): (typeof GLYPHS)[GlyphStyle]["frame"] {
+	return glyphs(cwd).frame;
+}