@bjesuiter/codex-switcher 1.8.1 → 1.8.3

package/README.md

@@ -6,12 +6,12 @@ Switch the coding-agents [pi](https://pi.dev/), [codex](https://developers.opena
 
 ## Latest Changes
 
-### 1.8.1
+### 1.8.3
 
-#### Fixes
+#### Improvements
 
-- Added platform-native secure-store write/read/delete probes to `cdx doctor` on Linux, macOS, and Windows, so runtime secure-store failures are detected directly instead of only reporting adapter capability.
-- Linux secure-store error handling now treats Secret Service `no result found` responses as missing-entry cases and classifies generic `Couldn't access platform secure storage` failures as unavailable-store errors with actionable guidance.
+- `cdx update-self` now prints the detected installed version directly after a successful update, so you don't need to run `cdx version` manually.
+- Linux `cdx doctor` guided checks now offer interactive recovery when `gnome-keyring-daemon` is not running: start now, or (when detectable as disabled) enable autostart and start now.
 
 see full changelog here: https://github.com/bjesuiter/codex-switcher/blob/main/CHANGELOG.md
 
@@ -170,6 +170,8 @@ cdx migrate-secrets
 | `cdx doctor --check-keychain-acl` | Detect macOS keychain ACL/runtime mismatches (`cdx`/Bun vs legacy `security` CLI), warn about prompt-heavy setups, and suggest `cdx migrate-secrets` (slow) |
 | `cdx usage` | Show usage overview for all accounts |
 | `cdx usage <account>` | Show detailed usage for a specific account |
+| `cdx update-self` | Update cdx to the latest version |
+| `cdx self-update` / `cdx update` / `cdx updte` | Aliases for `cdx update-self` |
 | `cdx help [command]` | Show help for all commands or one command |
 | `cdx complete <shell>` | Generate shell completion script (`zsh`, `bash`, `fish`, `powershell`) |
 | `cdx version` | Show CLI version |

package/cdx.mjs

@@ -15,7 +15,7 @@ import { generatePKCE } from "@openauthjs/openauth/pkce";
 import http from "node:http";
 
 //#region package.json
-var version = "1.8.1";
+var version = "1.8.3";
 
 //#endregion
 //#region lib/platform/path-resolver.ts
@@ -256,7 +256,7 @@ const getBrowserLauncher = (platform = process.platform, url) => {
 		label: "xdg-open"
 	};
 };
-const isCommandAvailable$1 = (command, platform = process.platform) => {
+const isCommandAvailable$2 = (command, platform = process.platform) => {
 	const probe = platform === "win32" ? "where" : "which";
 	return Bun.spawnSync({
 		cmd: [probe, command],
@@ -269,13 +269,13 @@ const getBrowserLauncherCapability = (platform = process.platform) => {
 	return {
 		command: launcher.command,
 		label: launcher.label,
-		available: isCommandAvailable$1(launcher.command, platform)
+		available: isCommandAvailable$2(launcher.command, platform)
 	};
 };
 const openBrowserUrl = (url, options = {}) => {
 	const platform = options.platform ?? process.platform;
 	const spawnImpl = options.spawnImpl ?? spawn;
-	const commandAvailable = options.isCommandAvailableImpl ?? isCommandAvailable$1;
+	const commandAvailable = options.isCommandAvailableImpl ?? isCommandAvailable$2;
 	const launcher = getBrowserLauncher(platform, url);
 	if (!commandAvailable(launcher.command, platform)) return {
 		ok: false,
@@ -306,7 +306,7 @@ const openBrowserUrl = (url, options = {}) => {
 
 //#endregion
 //#region lib/platform/clipboard.ts
-const isCommandAvailable = (command, platform = process.platform) => {
+const isCommandAvailable$1 = (command, platform = process.platform) => {
 	const probe = platform === "win32" ? "where" : "which";
 	return Bun.spawnSync({
 		cmd: [probe, command],
@@ -392,7 +392,7 @@ const getLocalClipboardTargets = (platform, env, commandExists) => {
 	});
 	return targets;
 };
-const resolveClipboardTargets = (context = {}, commandExists = isCommandAvailable) => {
+const resolveClipboardTargets = (context = {}, commandExists = isCommandAvailable$1) => {
 	const platform = context.platform ?? process.platform;
 	const env = context.env ?? process.env;
 	const isTTY = context.isTTY ?? (Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY));
@@ -433,7 +433,7 @@ const defaultRunCommand = (command, args, input) => {
 	};
 };
 const tryCopyToClipboard = (text, options = {}) => {
-	const commandExists = options.commandExistsImpl ?? isCommandAvailable;
+	const commandExists = options.commandExistsImpl ?? isCommandAvailable$1;
 	const runCommand = options.runCommandImpl ?? defaultRunCommand;
 	const writeStdout = options.writeStdoutImpl ?? ((chunk) => {
 		process.stdout.write(chunk);
@@ -479,7 +479,7 @@ const tryCopyToClipboard = (text, options = {}) => {
 	};
 };
 const escapePosixSingleQuoted = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
-const buildClipboardHelperCommand = (text, context = {}, commandExists = isCommandAvailable) => {
+const buildClipboardHelperCommand = (text, context = {}, commandExists = isCommandAvailable$1) => {
 	const commandTarget = resolveClipboardTargets(context, commandExists).find((target) => target.kind === "command");
 	if (!commandTarget) return null;
 	if (commandTarget.method === "powershell") {
@@ -2791,6 +2791,294 @@ const getSecretStoreProbeGuidance = (platform) => {
 	if (platform === "win32") return "Suggested fix: ensure Windows Credential Manager is available for this user session, then retry login.";
 	return null;
 };
+const isInteractiveTerminal = () => Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+const runCommandCapture = async (command, args) => await new Promise((resolve) => {
+	const child = spawn(command, args, { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	let stdout = "";
+	let stderr = "";
+	let spawnError = null;
+	child.stdout?.on("data", (chunk) => {
+		stdout += chunk.toString();
+	});
+	child.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+	});
+	child.once("error", (error) => {
+		spawnError = error.message;
+	});
+	child.once("close", (code) => {
+		resolve({
+			ok: spawnError === null && code === 0,
+			stdout: stdout.trim(),
+			stderr: stderr.trim(),
+			...spawnError ? { error: spawnError } : {}
+		});
+	});
+});
+const extractCommandFailureDetails = (result) => result.error || result.stderr || result.stdout || void 0;
+const isCommandAvailable = async (commandName) => {
+	return (await runCommandCapture("sh", ["-lc", `command -v ${commandName} >/dev/null 2>&1`])).ok;
+};
+const checkGnomeKeyringRunning = async () => {
+	if (await isCommandAvailable("pgrep")) {
+		const pgrepResult = await runCommandCapture("pgrep", ["-x", "gnome-keyring-daemon"]);
+		if (pgrepResult.ok) return { ok: true };
+		return {
+			ok: false,
+			details: extractCommandFailureDetails(pgrepResult) ?? "No gnome-keyring-daemon process found."
+		};
+	}
+	const psFallback = await runCommandCapture("sh", ["-lc", "ps -A -o comm= | grep -q '^gnome-keyring-daemon$'"]);
+	if (psFallback.ok) return { ok: true };
+	return {
+		ok: false,
+		details: extractCommandFailureDetails(psFallback) ?? "No gnome-keyring-daemon process found."
+	};
+};
+const parseSystemctlEnabledState = (output) => {
+	const normalized = output.trim().toLowerCase();
+	if ([
+		"enabled",
+		"enabled-runtime",
+		"static",
+		"indirect",
+		"generated"
+	].includes(normalized)) return "enabled";
+	if ([
+		"disabled",
+		"masked",
+		"not-found",
+		"linked",
+		"linked-runtime"
+	].includes(normalized)) return "disabled";
+	return "unknown";
+};
+const getLinuxGnomeKeyringAutoStartStatus = async () => {
+	if (!await isCommandAvailable("systemctl")) return {
+		state: "unknown",
+		details: "systemctl is not available; autostart detection depends on your desktop/session config."
+	};
+	const units = ["gnome-keyring-daemon.socket", "gnome-keyring-daemon.service"];
+	let sawDisabled = false;
+	const details = [];
+	for (const unit of units) {
+		const result = await runCommandCapture("systemctl", [
+			"--user",
+			"is-enabled",
+			unit
+		]);
+		const state = parseSystemctlEnabledState(result.stdout || result.stderr);
+		if (state === "enabled") return {
+			state: "enabled",
+			details: `${unit} is enabled (${result.stdout || "enabled"}).`
+		};
+		if (state === "disabled") {
+			sawDisabled = true;
+			details.push(`${unit}: ${result.stdout || result.stderr || "disabled"}`);
+			continue;
+		}
+		const maybeDetail = extractCommandFailureDetails(result);
+		if (maybeDetail) details.push(`${unit}: ${maybeDetail}`);
+	}
+	if (sawDisabled) return {
+		state: "disabled",
+		details: details.join("; ")
+	};
+	return {
+		state: "unknown",
+		details: details.join("; ") || "Unable to determine gnome-keyring autostart state."
+	};
+};
+const applyKeyringEnvAssignments = (raw) => {
+	const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	for (const line of lines) {
+		const match = line.match(/^([A-Z0-9_]+)=(.*);?$/);
+		if (!match) continue;
+		const key = match[1];
+		const value = match[2].replace(/;$/, "");
+		if (key) process.env[key] = value;
+	}
+};
+const startGnomeKeyringNow = async () => {
+	const directStart = await runCommandCapture("gnome-keyring-daemon", ["--start", "--components=secrets"]);
+	if (directStart.ok) {
+		applyKeyringEnvAssignments(directStart.stdout);
+		const runningCheck = await checkGnomeKeyringRunning();
+		if (runningCheck.ok) return { ok: true };
+		return {
+			ok: false,
+			details: runningCheck.details ?? "gnome-keyring-daemon start command succeeded, but process was not detected afterwards."
+		};
+	}
+	if (await isCommandAvailable("systemctl")) {
+		const serviceStart = await runCommandCapture("systemctl", [
+			"--user",
+			"start",
+			"gnome-keyring-daemon.service"
+		]);
+		if (serviceStart.ok) {
+			const runningCheck = await checkGnomeKeyringRunning();
+			if (runningCheck.ok) return { ok: true };
+			return {
+				ok: false,
+				details: runningCheck.details ?? "systemctl start succeeded, but gnome-keyring-daemon was not detected afterwards."
+			};
+		}
+		return {
+			ok: false,
+			details: extractCommandFailureDetails(directStart) ?? extractCommandFailureDetails(serviceStart) ?? "Failed to start gnome-keyring-daemon."
+		};
+	}
+	return {
+		ok: false,
+		details: extractCommandFailureDetails(directStart) ?? "Failed to start gnome-keyring-daemon."
+	};
+};
+const enableGnomeKeyringAutoStart = async () => {
+	if (!await isCommandAvailable("systemctl")) return {
+		ok: false,
+		details: "systemctl is not available, so cdx cannot automatically enable startup in this session manager."
+	};
+	const units = ["gnome-keyring-daemon.socket", "gnome-keyring-daemon.service"];
+	const failures = [];
+	for (const unit of units) {
+		const result = await runCommandCapture("systemctl", [
+			"--user",
+			"enable",
+			unit
+		]);
+		if (result.ok) return {
+			ok: true,
+			details: `${unit} enabled.`
+		};
+		const detail = extractCommandFailureDetails(result);
+		failures.push(`${unit}: ${detail ?? "enable failed"}`);
+	}
+	return {
+		ok: false,
+		details: failures.join("; ")
+	};
+};
+const maybeOfferToStartGnomeKeyring = async () => {
+	const autoStartStatus = await getLinuxGnomeKeyringAutoStartStatus();
+	if (autoStartStatus.state === "enabled") {
+		const shouldStartNow = await p.confirm({
+			message: "gnome-keyring autostart appears enabled, but it is not running right now. Start it now?",
+			initialValue: true
+		});
+		if (p.isCancel(shouldStartNow) || !shouldStartNow) return false;
+		const startResult = await startGnomeKeyringNow();
+		if (!startResult.ok) {
+			process.stdout.write(`      failed to start gnome-keyring-daemon: ${startResult.details ?? "unknown error"}\n`);
+			return false;
+		}
+		process.stdout.write("      started gnome-keyring-daemon for this session.\n");
+		return true;
+	}
+	if (autoStartStatus.details) process.stdout.write(`      autostart check: ${autoStartStatus.details}\n`);
+	const action = await p.select({
+		message: autoStartStatus.state === "disabled" ? "gnome-keyring autostart seems disabled. What should cdx do?" : "Could not confirm gnome-keyring autostart. What should cdx do?",
+		options: [
+			{
+				value: "start-now",
+				label: "Start now only"
+			},
+			{
+				value: "enable-and-start",
+				label: "Enable on system start and start now"
+			},
+			{
+				value: "skip",
+				label: "Skip"
+			}
+		],
+		initialValue: "start-now"
+	});
+	if (p.isCancel(action) || action === "skip") return false;
+	if (action === "enable-and-start") {
+		const enableResult = await enableGnomeKeyringAutoStart();
+		if (!enableResult.ok) {
+			process.stdout.write(`      failed to enable autostart: ${enableResult.details ?? "unknown error"}\n`);
+			return false;
+		}
+		process.stdout.write(`      autostart enabled${enableResult.details ? ` (${enableResult.details})` : ""}.\n`);
+	}
+	const startResult = await startGnomeKeyringNow();
+	if (!startResult.ok) {
+		process.stdout.write(`      failed to start gnome-keyring-daemon: ${startResult.details ?? "unknown error"}\n`);
+		return false;
+	}
+	process.stdout.write("      started gnome-keyring-daemon for this session.\n");
+	return true;
+};
+const runLinuxSecretStoreChecklist = async () => {
+	const gnomeKeyringInstalled = await isCommandAvailable("gnome-keyring-daemon");
+	const secretToolInstalled = await isCommandAvailable("secret-tool");
+	const gnomeKeyringRunning = await checkGnomeKeyringRunning();
+	return [
+		{
+			id: "gnome-keyring-installed",
+			question: "Is gnome-keyring installed?",
+			ok: gnomeKeyringInstalled,
+			hint: "Install the `gnome-keyring` package, then log out/in (or restart your session)."
+		},
+		{
+			id: "secret-tool-installed",
+			question: "Is secret-tool installed?",
+			ok: secretToolInstalled,
+			hint: "Install the package that provides `secret-tool` (often `libsecret-tools`)."
+		},
+		{
+			id: "gnome-keyring-running",
+			question: "Is gnome-keyring running?",
+			ok: gnomeKeyringRunning.ok,
+			details: gnomeKeyringRunning.details,
+			hint: "Start/unlock gnome-keyring-daemon in your session (for a quick test: `gnome-keyring-daemon --start --components=secrets`)."
+		}
+	];
+};
+const maybeRunLinuxSecretStoreChecklist = async () => {
+	if (!isInteractiveTerminal()) {
+		process.stdout.write("  Tip: run `cdx doctor` in an interactive terminal to start guided Linux secret-store checks.\n");
+		return;
+	}
+	const shouldRunChecklist = await p.confirm({
+		message: "Run guided Linux secret-store checks now? (gnome-keyring installed, secret-tool installed, gnome-keyring running)",
+		initialValue: true
+	});
+	if (p.isCancel(shouldRunChecklist) || !shouldRunChecklist) {
+		process.stdout.write("  Guided Linux checks skipped.\n");
+		return;
+	}
+	process.stdout.write("  Guided Linux checks:\n");
+	const checklist = await runLinuxSecretStoreChecklist();
+	let passed = 0;
+	for (let i = 0; i < checklist.length; i++) {
+		const item = checklist[i];
+		if (item.ok) {
+			passed += 1;
+			process.stdout.write(`    ${i + 1}/3 ${item.question} yes\n`);
+			continue;
+		}
+		process.stdout.write(`    ${i + 1}/3 ${item.question} no\n`);
+		if (item.details) process.stdout.write(`      details: ${item.details}\n`);
+		if (item.hint) process.stdout.write(`      hint: ${item.hint}\n`);
+		if (item.id === "gnome-keyring-running") {
+			if (await maybeOfferToStartGnomeKeyring()) {
+				const runningNow = await checkGnomeKeyringRunning();
+				if (runningNow.ok) {
+					passed += 1;
+					process.stdout.write("      re-check: gnome-keyring-daemon is now running.\n");
+				} else process.stdout.write(`      re-check still failing: ${runningNow.details ?? "process not detected"}\n`);
+			}
+		}
+	}
+	process.stdout.write(`  Guided checklist summary: ${passed}/${checklist.length} checks passed.\n`);
+};
 const registerDoctorCommand = (program) => {
 	program.command("doctor").description("Show auth file paths and runtime capabilities").option("--check-keychain-acl", "Run keychain trusted-app/ACL checks on macOS (can be slow)").action(async (options) => {
 		try {
@@ -2850,6 +3138,7 @@ const registerDoctorCommand = (program) => {
 					process.stdout.write(`  ⚠ ${probeResult.stage} failed: ${probeResult.error.message}\n`);
 					const guidance = getSecretStoreProbeGuidance(process.platform);
 					if (guidance) process.stdout.write(`  ${guidance}\n`);
+					if (process.platform === "linux") await maybeRunLinuxSecretStoreChecklist();
 				}
 			}
 			if (process.platform === "darwin" && !options.checkKeychainAcl) {
@@ -2909,7 +3198,7 @@ const registerDoctorCommand = (program) => {
 const registerHelpCommand = (program) => {
 	program.command("help").description("Show available commands and usage information").argument("[command]", "Show help for a specific command").action((commandName) => {
 		if (commandName) {
-			const command = program.commands.find((entry) => entry.name() === commandName);
+			const command = program.commands.find((entry) => entry.name() === commandName || entry.aliases().includes(commandName));
 			if (command) {
 				command.outputHelp();
 				return;
@@ -3528,8 +3817,52 @@ const executeUpdate = async (command, args) => {
 		});
 	});
 };
+const executeCapture = async (command, args) => await new Promise((resolve) => {
+	const child = spawn(command, args, { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	let stdout = "";
+	child.stdout?.on("data", (chunk) => {
+		stdout += chunk.toString();
+	});
+	child.once("error", () => {
+		resolve({
+			ok: false,
+			output: ""
+		});
+	});
+	child.once("close", (code) => {
+		resolve({
+			ok: code === 0,
+			output: stdout.trim()
+		});
+	});
+});
+const getInstalledCdxVersion = async () => {
+	const attempts = [{
+		command: "cdx",
+		args: ["--version"]
+	}];
+	if (process.argv[0] && process.argv[1]) attempts.push({
+		command: process.argv[0],
+		args: [process.argv[1], "--version"]
+	});
+	for (const attempt of attempts) {
+		const result = await executeCapture(attempt.command, attempt.args);
+		if (!result.ok || !result.output) continue;
+		const version = result.output.split(/\r?\n/).at(-1)?.trim();
+		if (version) return version;
+	}
+	return null;
+};
 const registerUpdateSelfCommand = (program) => {
-	program.command("update-self").description("Update cdx to the latest version").option("--manager <manager>", "Select update manager (auto|bun|npm|deno)", "auto").option("--dry-run", "Print selected manager and update command without executing").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
+	program.command("update-self").aliases([
+		"self-update",
+		"update",
+		"updte"
+	]).description("Update cdx to the latest version").option("--manager <manager>", "Select update manager (auto|bun|npm|deno)", "auto").option("--dry-run", "Print selected manager and update command without executing").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
 		try {
 			const requestedManager = options.manager ?? "auto";
 			if (![
@@ -3598,8 +3931,9 @@ const registerUpdateSelfCommand = (program) => {
 				}
 			}
 			await executeUpdate(command.command, command.args);
+			const installedVersion = await getInstalledCdxVersion();
 			process.stdout.write("Update completed.\n");
-			process.stdout.write("Run `cdx version` to verify the installed version.\n");
+			process.stdout.write(`Installed version: ${installedVersion ?? "unknown"}\n`);
 		} catch (error) {
 			exitWithCommandError(error);
 		}

package/package.json

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