@oh-my-pi/pi-ai 3.20.0 → 3.34.0

package/src/utils/oauth/openai-codex.ts

@@ -2,6 +2,8 @@
  * OpenAI Codex (ChatGPT OAuth) flow
  */
 
+import { randomBytes } from "node:crypto";
+import http from "node:http";
 import { generatePKCE } from "./pkce";
 import type { OAuthCredentials, OAuthPrompt } from "./types";
 
@@ -36,9 +38,7 @@ type JwtPayload = {
 };
 
 function createState(): string {
-	const bytes = new Uint8Array(16);
-	crypto.getRandomValues(bytes);
-	return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return randomBytes(16).toString("hex");
 }
 
 function parseAuthorizationInput(input: string): { code?: string; state?: string } {
@@ -187,64 +187,79 @@ async function createAuthorizationFlow(): Promise<{ verifier: string; state: str
 
 type OAuthServerInfo = {
 	close: () => void;
+	cancelWait: () => void;
 	waitForCode: () => Promise<{ code: string } | null>;
 };
 
 function startLocalOAuthServer(state: string): Promise<OAuthServerInfo> {
 	let lastCode: string | null = null;
+	let cancelled = false;
+	const server = http.createServer((req, res) => {
+		try {
+			const url = new URL(req.url || "", "http://localhost");
+			if (url.pathname !== "/auth/callback") {
+				res.statusCode = 404;
+				res.end("Not found");
+				return;
+			}
+			if (url.searchParams.get("state") !== state) {
+				res.statusCode = 400;
+				res.end("State mismatch");
+				return;
+			}
+			const code = url.searchParams.get("code");
+			if (!code) {
+				res.statusCode = 400;
+				res.end("Missing authorization code");
+				return;
+			}
+			res.statusCode = 200;
+			res.setHeader("Content-Type", "text/html; charset=utf-8");
+			res.end(SUCCESS_HTML);
+			lastCode = code;
+		} catch {
+			res.statusCode = 500;
+			res.end("Internal error");
+		}
+	});
 
 	return new Promise((resolve) => {
-		try {
-			const server = Bun.serve({
-				port: 1455,
-				hostname: "127.0.0.1",
-				fetch(req) {
-					try {
-						const url = new URL(req.url);
-						if (url.pathname !== "/auth/callback") {
-							return new Response("Not found", { status: 404 });
-						}
-						if (url.searchParams.get("state") !== state) {
-							return new Response("State mismatch", { status: 400 });
+		server
+			.listen(1455, "127.0.0.1", () => {
+				resolve({
+					close: () => server.close(),
+					cancelWait: () => {
+						cancelled = true;
+					},
+					waitForCode: async () => {
+						const sleep = () => new Promise((r) => setTimeout(r, 100));
+						for (let i = 0; i < 600; i += 1) {
+							if (lastCode) return { code: lastCode };
+							if (cancelled) return null;
+							await sleep();
 						}
-						const code = url.searchParams.get("code");
-						if (!code) {
-							return new Response("Missing authorization code", { status: 400 });
+						return null;
+					},
+				});
+			})
+			.on("error", (err: NodeJS.ErrnoException) => {
+				console.error(
+					"[openai-codex] Failed to bind http://127.0.0.1:1455 (",
+					err.code,
+					") Falling back to manual paste.",
+				);
+				resolve({
+					close: () => {
+						try {
+							server.close();
+						} catch {
+							// ignore
 						}
-						lastCode = code;
-						return new Response(SUCCESS_HTML, {
-							status: 200,
-							headers: { "Content-Type": "text/html; charset=utf-8" },
-						});
-					} catch {
-						return new Response("Internal error", { status: 500 });
-					}
-				},
+					},
+					cancelWait: () => {},
+					waitForCode: async () => null,
+				});
 			});
-
-			resolve({
-				close: () => server.stop(),
-				waitForCode: async () => {
-					const sleep = () => new Promise((r) => setTimeout(r, 100));
-					for (let i = 0; i < 600; i += 1) {
-						if (lastCode) return { code: lastCode };
-						await sleep();
-					}
-					return null;
-				},
-			});
-		} catch (err) {
-			const code = (err as { code?: string }).code;
-			console.error(
-				"[openai-codex] Failed to bind http://127.0.0.1:1455 (",
-				code,
-				") Falling back to manual paste.",
-			);
-			resolve({
-				close: () => {},
-				waitForCode: async () => null,
-			});
-		}
 	});
 }
 
@@ -257,11 +272,19 @@ function getAccountId(accessToken: string): string | null {
 
 /**
  * Login with OpenAI Codex OAuth
+ *
+ * @param options.onAuth - Called with URL and instructions when auth starts
+ * @param options.onPrompt - Called to prompt user for manual code paste (fallback if no onManualCodeInput)
+ * @param options.onProgress - Optional progress messages
+ * @param options.onManualCodeInput - Optional promise that resolves with user-pasted code.
+ *                                    Races with browser callback - whichever completes first wins.
+ *                                    Useful for showing paste input immediately alongside browser flow.
  */
 export async function loginOpenAICodex(options: {
 	onAuth: (info: { url: string; instructions?: string }) => void;
 	onPrompt: (prompt: OAuthPrompt) => Promise<string>;
 	onProgress?: (message: string) => void;
+	onManualCodeInput?: () => Promise<string>;
 }): Promise<OAuthCredentials> {
 	const { verifier, state, url } = await createAuthorizationFlow();
 	const server = await startLocalOAuthServer(state);
@@ -270,11 +293,63 @@ export async function loginOpenAICodex(options: {
 
 	let code: string | undefined;
 	try {
-		const result = await server.waitForCode();
-		if (result?.code) {
-			code = result.code;
+		if (options.onManualCodeInput) {
+			// Race between browser callback and manual input
+			let manualCode: string | undefined;
+			let manualError: Error | undefined;
+			const manualPromise = options
+				.onManualCodeInput()
+				.then((input) => {
+					manualCode = input;
+					server.cancelWait();
+				})
+				.catch((err) => {
+					manualError = err instanceof Error ? err : new Error(String(err));
+					server.cancelWait();
+				});
+
+			const result = await server.waitForCode();
+
+			// If manual input was cancelled, throw that error
+			if (manualError) {
+				throw manualError;
+			}
+
+			if (result?.code) {
+				// Browser callback won
+				code = result.code;
+			} else if (manualCode) {
+				// Manual input won (or callback timed out and user had entered code)
+				const parsed = parseAuthorizationInput(manualCode);
+				if (parsed.state && parsed.state !== state) {
+					throw new Error("State mismatch");
+				}
+				code = parsed.code;
+			}
+
+			// If still no code, wait for manual promise to complete and try that
+			if (!code) {
+				await manualPromise;
+				if (manualError) {
+					throw manualError;
+				}
+				if (manualCode) {
+					const parsed = parseAuthorizationInput(manualCode);
+					if (parsed.state && parsed.state !== state) {
+						throw new Error("State mismatch");
+					}
+					code = parsed.code;
+				}
+			}
+		} else {
+			// Original flow: wait for callback, then prompt if needed
+			const result = await server.waitForCode();
+			if (result?.code) {
+				code = result.code;
+			}
 		}
 
+		// Fallback to onPrompt if still no code
 		if (!code) {
 			const input = await options.onPrompt({
 				message: "Paste the authorization code (or full redirect URL):",

package/src/utils/overflow.ts

@@ -32,7 +32,7 @@ const OVERFLOW_PATTERNS = [
 	/exceeds the limit of \d+/i, // GitHub Copilot
 	/exceeds the available context size/i, // llama.cpp server
 	/greater than the context length/i, // LM Studio
-	/context length exceeded/i, // Generic fallback
+	/context[_ ]length[_ ]exceeded/i, // Generic fallback
 	/too many tokens/i, // Generic fallback
 	/token limit exceeded/i, // Generic fallback
 ];

package/src/bun-imports.d.ts

@@ -1,14 +0,0 @@
-/**
- * Type declarations for Bun's import attributes.
- * These allow importing non-JS files as text at build time.
- */
-
-declare module "*.md" {
-	const content: string;
-	export default content;
-}
-
-declare module "*.txt" {
-	const content: string;
-	export default content;
-}