@bjesuiter/codex-switcher 1.7.1 → 1.7.3

package/README.md

@@ -6,15 +6,15 @@ Switch the coding-agents [pi](https://pi.dev/), [codex](https://developers.opena
 
 ## Latest Changes
 
-### 1.7.1
-
-#### Features
-
-- Add a release helper script (`scripts/wait-for-npm-latest.ts`) plus `bun run wait-npm-latest` to poll npm until the package `latest` tag matches the target version.
+### 1.7.3
 
 #### Fixes
 
-- Fix Windows CI completion test behavior by providing `APPDATA` in the account-completion test environment, so account suggestions are resolved correctly on `windows-latest`.
+- Add recovery for OAuth callback port conflicts (`127.0.0.1:1455`) during login/relogin:
+  - detect `EADDRINUSE` as a port-in-use condition
+  - prompt to kill the existing listener and retry, switch to device flow, or cancel
+  - show detected PID/command details when available before confirmation
+- Improve callback server startup diagnostics by exposing startup error reason/code details, making port/listen failures easier to troubleshoot.
 
 see full changelog here: https://github.com/bjesuiter/codex-switcher/blob/main/CHANGELOG.md
 

package/cdx.mjs

@@ -15,7 +15,7 @@ import { generatePKCE } from "@openauthjs/openauth/pkce";
 import http from "node:http";
 
 //#region package.json
-var version = "1.7.1";
+var version = "1.7.3";
 
 //#endregion
 //#region lib/platform/path-resolver.ts
@@ -1032,6 +1032,10 @@ const createAuthorizationFlow = async () => {
 		url: url.toString()
 	};
 };
+const truncateForLog = (value, maxLength = 300) => {
+	if (value.length <= maxLength) return value;
+	return `${value.slice(0, maxLength)}…`;
+};
 const startDeviceAuthorizationFlow = async () => {
 	try {
 		const res = await fetch(DEVICE_CODE_URL, {
@@ -1042,19 +1046,53 @@ const startDeviceAuthorizationFlow = async () => {
 				scope: SCOPE
 			})
 		});
-		if (!res.ok) return null;
+		if (!res.ok) {
+			let oauthError;
+			let responseBody;
+			try {
+				const json = await res.json();
+				oauthError = json.error;
+				responseBody = truncateForLog(JSON.stringify({
+					...json.error ? { error: json.error } : {},
+					...json.error_description ? { error_description: json.error_description } : {}
+				}));
+			} catch {
+				try {
+					responseBody = truncateForLog(await res.text());
+				} catch {
+					responseBody = void 0;
+				}
+			}
+			return {
+				type: "failed",
+				error: `Device code request failed with HTTP ${res.status} ${res.statusText}`,
+				status: res.status,
+				...oauthError ? { oauthError } : {},
+				...responseBody ? { responseBody } : {}
+			};
+		}
 		const json = await res.json();
-		if (!json?.device_code || !json?.user_code || !json?.verification_uri || typeof json?.expires_in !== "number") return null;
+		if (!json?.device_code || !json?.user_code || !json?.verification_uri || typeof json?.expires_in !== "number") return {
+			type: "failed",
+			error: "Device code response is missing required fields.",
+			responseBody: truncateForLog(JSON.stringify(json))
+		};
 		return {
-			deviceCode: json.device_code,
-			userCode: json.user_code,
-			verificationUri: json.verification_uri,
-			verificationUriComplete: json.verification_uri_complete,
-			expiresIn: json.expires_in,
-			interval: typeof json.interval === "number" && json.interval > 0 ? json.interval : 5
+			type: "success",
+			flow: {
+				deviceCode: json.device_code,
+				userCode: json.user_code,
+				verificationUri: json.verification_uri,
+				verificationUriComplete: json.verification_uri_complete,
+				expiresIn: json.expires_in,
+				interval: typeof json.interval === "number" && json.interval > 0 ? json.interval : 5
+			}
+		};
+	} catch (error) {
+		return {
+			type: "failed",
+			error: `Device code request failed: ${error instanceof Error ? error.message : String(error)}`
 		};
-	} catch {
-		return null;
 	}
 };
 const pollDeviceAuthorizationToken = async (deviceCode) => {
@@ -1070,7 +1108,11 @@ const pollDeviceAuthorizationToken = async (deviceCode) => {
 		});
 		if (res.ok) {
 			const json = await res.json();
-			if (!json?.access_token || !json?.refresh_token || typeof json?.expires_in !== "number") return { type: "failed" };
+			if (!json?.access_token || !json?.refresh_token || typeof json?.expires_in !== "number") return {
+				type: "failed",
+				error: "Device token response is missing access_token/refresh_token/expires_in.",
+				responseBody: truncateForLog(JSON.stringify(json))
+			};
 			return {
 				type: "success",
 				access: json.access_token,
@@ -1081,11 +1123,23 @@ const pollDeviceAuthorizationToken = async (deviceCode) => {
 		}
 		let errorCode;
 		let interval;
+		let responseBody;
 		try {
 			const json = await res.json();
 			errorCode = json.error;
 			interval = json.interval;
-		} catch {}
+			responseBody = truncateForLog(JSON.stringify({
+				...json.error ? { error: json.error } : {},
+				...json.error_description ? { error_description: json.error_description } : {},
+				...typeof json.interval === "number" ? { interval: json.interval } : {}
+			}));
+		} catch {
+			try {
+				responseBody = truncateForLog(await res.text());
+			} catch {
+				responseBody = void 0;
+			}
+		}
 		if (errorCode === "authorization_pending") return {
 			type: "pending",
 			interval: typeof interval === "number" && interval > 0 ? interval : 5
@@ -1096,9 +1150,18 @@ const pollDeviceAuthorizationToken = async (deviceCode) => {
 		};
 		if (errorCode === "access_denied") return { type: "access_denied" };
 		if (errorCode === "expired_token") return { type: "expired" };
-		return { type: "failed" };
-	} catch {
-		return { type: "failed" };
+		return {
+			type: "failed",
+			error: `Device token polling failed with HTTP ${res.status} ${res.statusText}`,
+			status: res.status,
+			...errorCode ? { oauthError: errorCode } : {},
+			...responseBody ? { responseBody } : {}
+		};
+	} catch (error) {
+		return {
+			type: "failed",
+			error: `Device token polling request failed: ${error instanceof Error ? error.message : String(error)}`
+		};
 	}
 };
 const exchangeAuthorizationCode = async (code, verifier) => {
@@ -1247,10 +1310,14 @@ const startOAuthServer = (state) => {
 				},
 				waitForCode: () => codePromise
 			});
-		}).on("error", () => {
+		}).on("error", (error) => {
+			const err = error;
 			resolve({
 				port: CALLBACK_PORT,
 				ready: false,
+				reason: err?.code === "EADDRINUSE" ? "port_in_use" : "listen_failed",
+				...typeof err?.message === "string" ? { error: err.message } : {},
+				...typeof err?.code === "string" ? { errorCode: err.code } : {},
 				close: () => {
 					try {
 						server.close();
@@ -1270,6 +1337,101 @@ const isLikelyRemoteEnvironment = () => {
 	if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY) return true;
 	return !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY;
 };
+const parseLsofListeningProcess = (output) => {
+	const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	let pid = null;
+	let command;
+	for (const line of lines) {
+		if (line.startsWith("p") && pid === null) {
+			const parsedPid = Number.parseInt(line.slice(1), 10);
+			if (!Number.isNaN(parsedPid) && parsedPid > 0) pid = parsedPid;
+			continue;
+		}
+		if (line.startsWith("c") && pid !== null && !command) {
+			const parsedCommand = line.slice(1).trim();
+			if (parsedCommand) command = parsedCommand;
+		}
+		if (pid !== null && command) break;
+	}
+	if (pid === null) return null;
+	return {
+		pid,
+		...command ? { command } : {}
+	};
+};
+const parseWindowsNetstatListeningPid = (output, port) => {
+	const lines = output.split(/\r?\n/);
+	const portSuffix = `:${port}`;
+	for (const rawLine of lines) {
+		const line = rawLine.trim();
+		if (!line || !/LISTENING/i.test(line) || !line.includes(portSuffix)) continue;
+		const pidRaw = line.split(/\s+/).at(-1);
+		const parsedPid = pidRaw ? Number.parseInt(pidRaw, 10) : NaN;
+		if (!Number.isNaN(parsedPid) && parsedPid > 0) return parsedPid;
+	}
+	return null;
+};
+const findListeningProcessOnPort = (port, platform = process.platform) => {
+	if (platform === "win32") {
+		const netstat = Bun.spawnSync({
+			cmd: [
+				"netstat",
+				"-ano",
+				"-p",
+				"tcp"
+			],
+			stdout: "pipe",
+			stderr: "pipe"
+		});
+		if (netstat.exitCode !== 0) return null;
+		const pid = parseWindowsNetstatListeningPid(Buffer.from(netstat.stdout).toString("utf8"), port);
+		if (!pid) return null;
+		const tasklist = Bun.spawnSync({
+			cmd: [
+				"tasklist",
+				"/FI",
+				`PID eq ${pid}`,
+				"/FO",
+				"CSV",
+				"/NH"
+			],
+			stdout: "pipe",
+			stderr: "pipe"
+		});
+		if (tasklist.exitCode !== 0) return { pid };
+		const line = Buffer.from(tasklist.stdout).toString("utf8").trim().split(/\r?\n/)[0] ?? "";
+		if (!line || /No tasks are running/i.test(line)) return { pid };
+		const command = line.replace(/^"|"$/g, "").split("\",\"")[0]?.trim();
+		return {
+			pid,
+			...command ? { command } : {}
+		};
+	}
+	const lsof = Bun.spawnSync({
+		cmd: [
+			"lsof",
+			"-nP",
+			`-iTCP:${port}`,
+			"-sTCP:LISTEN",
+			"-FpPc"
+		],
+		stdout: "pipe",
+		stderr: "pipe"
+	});
+	if (lsof.exitCode !== 0) return null;
+	return parseLsofListeningProcess(Buffer.from(lsof.stdout).toString("utf8"));
+};
+const killProcessByPid = (pid) => {
+	try {
+		process.kill(pid, "SIGTERM");
+		return { ok: true };
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+};
 const parseOAuthCallbackInput = (input) => {
 	const trimmed = input.trim();
 	if (!trimmed) return null;
@@ -1336,6 +1498,34 @@ const promptBrowserFallbackChoice = async () => {
 	if (p.isCancel(selection)) return "cancel";
 	return selection;
 };
+const promptPortConflictChoice = async (listeningProcess) => {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		p.log.info("Non-interactive terminal detected. Falling back to device OAuth flow.");
+		return "device";
+	}
+	const killHint = listeningProcess ? `PID ${listeningProcess.pid}${listeningProcess.command ? ` (${listeningProcess.command})` : ""}` : "Attempt to free port and retry";
+	const selection = await p.select({
+		message: `Port ${CALLBACK_PORT} is already in use. How do you want to continue?`,
+		options: [
+			{
+				value: "kill_and_retry",
+				label: `Kill existing listener on port ${CALLBACK_PORT} and retry browser flow`,
+				hint: killHint
+			},
+			{
+				value: "device",
+				label: "Continue with OAuth device flow",
+				hint: "No local callback server required"
+			},
+			{
+				value: "cancel",
+				label: "Cancel login"
+			}
+		]
+	});
+	if (p.isCancel(selection)) return "cancel";
+	return selection;
+};
 const promptManualAuthorizationCode = async (authorizationUrl, expectedState) => {
 	p.log.info("Manual login selected.");
 	p.log.message(`Open this URL in a browser:\n${authorizationUrl}`);
@@ -1364,11 +1554,16 @@ const promptManualAuthorizationCode = async (authorizationUrl, expectedState) =>
 	return null;
 };
 const runDeviceOAuthFlow = async (useSpinner) => {
-	const deviceFlow = await startDeviceAuthorizationFlow();
-	if (!deviceFlow) {
+	const deviceFlowResult = await startDeviceAuthorizationFlow();
+	if (deviceFlowResult.type !== "success") {
 		p.log.error("Device OAuth flow is not available right now.");
+		p.log.error(`Technical details: ${deviceFlowResult.error}`);
+		if (typeof deviceFlowResult.status === "number") p.log.error(`HTTP status: ${deviceFlowResult.status}`);
+		if (deviceFlowResult.oauthError) p.log.error(`OAuth error: ${deviceFlowResult.oauthError}`);
+		if (deviceFlowResult.responseBody) p.log.error(`Response: ${deviceFlowResult.responseBody}`);
 		return null;
 	}
+	const deviceFlow = deviceFlowResult.flow;
 	p.log.info("Using device OAuth flow.");
 	p.log.message(`Verification URL: ${deviceFlow.verificationUri}`);
 	p.log.message(`User code: ${deviceFlow.userCode}`);
@@ -1410,6 +1605,12 @@ const runDeviceOAuthFlow = async (useSpinner) => {
 		}
 		if (spinner) spinner.stop("Device authorization failed.");
 		else p.log.error("Device authorization failed.");
+		if (pollResult.type === "failed") {
+			if (pollResult.error) p.log.error(`Technical details: ${pollResult.error}`);
+			if (typeof pollResult.status === "number") p.log.error(`HTTP status: ${pollResult.status}`);
+			if (pollResult.oauthError) p.log.error(`OAuth error: ${pollResult.oauthError}`);
+			if (pollResult.responseBody) p.log.error(`Response: ${pollResult.responseBody}`);
+		}
 		return null;
 	}
 	if (spinner) spinner.stop("Device authorization timed out.");
@@ -1418,9 +1619,48 @@ const runDeviceOAuthFlow = async (useSpinner) => {
 };
 const requestTokenViaOAuth = async (flow, options) => {
 	if (options.authFlow === "device") return runDeviceOAuthFlow(options.useSpinner);
-	const server = await startOAuthServer(flow.state);
-	if (!server.ready) {
-		p.log.error("Failed to start local server on port 1455.");
+	let server = await startOAuthServer(flow.state);
+	if (!server.ready) if (server.reason === "port_in_use") {
+		p.log.warning(`Local callback server port ${CALLBACK_PORT} is already in use.`);
+		const listeningProcess = findListeningProcessOnPort(CALLBACK_PORT);
+		if (listeningProcess) p.log.info(`Detected listener on port ${CALLBACK_PORT}: PID ${listeningProcess.pid}${listeningProcess.command ? ` (${listeningProcess.command})` : ""}`);
+		const choice = await promptPortConflictChoice(listeningProcess);
+		if (choice === "cancel") {
+			p.log.info("Login cancelled.");
+			return null;
+		}
+		if (choice === "device") return runDeviceOAuthFlow(options.useSpinner);
+		if (listeningProcess) {
+			const confirmed = await p.confirm({
+				message: `Kill PID ${listeningProcess.pid}${listeningProcess.command ? ` (${listeningProcess.command})` : ""}?`,
+				initialValue: false
+			});
+			if (p.isCancel(confirmed) || !confirmed) {
+				p.log.info("Cancelled. No process was terminated.");
+				return null;
+			}
+			const killResult = killProcessByPid(listeningProcess.pid);
+			if (!killResult.ok) {
+				p.log.error(`Failed to terminate PID ${listeningProcess.pid}.`);
+				p.log.error(`Technical details: ${killResult.error ?? "unknown error"}`);
+				p.log.info("Try device flow instead: cdx login --device-flow");
+				return null;
+			}
+			p.log.success(`Sent SIGTERM to PID ${listeningProcess.pid}. Retrying local server...`);
+			await sleep(250);
+		} else p.log.warning(`Could not identify which process is listening on port ${CALLBACK_PORT}. Retrying once...`);
+		server = await startOAuthServer(flow.state);
+		if (!server.ready) {
+			p.log.error(`Failed to start local server on port ${CALLBACK_PORT} after retry.`);
+			if (server.error) p.log.error(`Technical details: ${server.error}`);
+			if (server.errorCode) p.log.error(`Error code: ${server.errorCode}`);
+			p.log.info("Try device flow instead: cdx login --device-flow");
+			return null;
+		}
+	} else {
+		p.log.error(`Failed to start local server on port ${CALLBACK_PORT}.`);
+		if (server.error) p.log.error(`Technical details: ${server.error}`);
+		if (server.errorCode) p.log.error(`Error code: ${server.errorCode}`);
 		p.log.info("Please ensure the port is not in use.");
 		return null;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bjesuiter/codex-switcher",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "type": "module",
   "description": "CLI tool to switch between multiple OpenAI accounts for OpenCode",
   "bin": {