@bjesuiter/codex-switcher 1.8.2 → 1.8.3

package/README.md

@@ -6,15 +6,12 @@ Switch the coding-agents [pi](https://pi.dev/), [codex](https://developers.opena
 
 ## Latest Changes
 
-### 1.8.2
+### 1.8.3
 
-#### Features
+#### Improvements
 
-- Added `update-self` command aliases: `self-update`, `update`, and `updte`.
-
-#### Fixes
-
-- Added an interactive Linux troubleshooting checklist in `cdx doctor` when the secure-store probe fails, guiding sequential checks for `gnome-keyring`, `secret-tool`, and running `gnome-keyring-daemon`.
+- `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
 

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.2";
+var version = "1.8.3";
 
 //#endregion
 //#region lib/platform/path-resolver.ts
@@ -2839,22 +2839,201 @@ const checkGnomeKeyringRunning = async () => {
 		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,
@@ -2888,6 +3067,15 @@ const maybeRunLinuxSecretStoreChecklist = async () => {
 		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`);
 };
@@ -3629,6 +3817,46 @@ 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").aliases([
 		"self-update",
@@ -3703,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.2",
+  "version": "1.8.3",
   "type": "module",
   "description": "CLI tool to switch between multiple OpenAI accounts for OpenCode",
   "bin": {