@gajae-gateway/cli 0.1.8 → 0.2.1

package/src/update.ts

@@ -3,7 +3,6 @@ import {
 	copyFile,
 	mkdir,
 	mkdtemp,
-	open,
 	readdir,
 	readFile,
 	realpath,
@@ -14,8 +13,17 @@ import {
 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
+import { acquireLease, homeLayout, type Lease, LeaseHeldError } from "@gajae-gateway/home";
 import pkg from "../package.json";
+import { type GjcInstallRunner, installPinnedGjc } from "./gjc-install";
 import { launchRestartStack } from "./restart-stack";
+import {
+	type InstallServicesOptions,
+	installServices,
+	type ServicePlatform,
+	serviceSpecs,
+	systemdUnitName,
+} from "./services";
 
 /**
  * `gajaeway update`: self-update a binary install from the project's GitHub
@@ -31,6 +39,8 @@ export const UPDATE_USAGE = "usage: gajaeway update [--check] [--force] [--bin-d
 
 export const DEFAULT_RELEASE_REPO = "Yeachan-Heo/gajae-way";
 const RELEASE_REPO_OVERRIDE_ENV = "GAJAEWAY_UPDATE_REPO";
+/** The release manifest carrying the gjc pin; installed beside the binaries. */
+const PIN_MANIFEST = "package.json";
 /** A fork can point updates at its own releases; the declared upstream stays the default. */
 export function releaseRepo(env: NodeJS.ProcessEnv = process.env): string {
 	const override = env[RELEASE_REPO_OVERRIDE_ENV]?.trim();
@@ -127,7 +137,6 @@ const MIN_BINARY_BYTES = 1_048_576;
 const MAX_ASSET_BYTES = 512 * 1024 * 1024;
 
 const RELEASE_MARKER = ".gajaeway-release";
-const LOCK_FILE = ".gajaeway-update.lock";
 
 export function releaseMarkerPath(binDir: string): string {
 	return join(binDir, RELEASE_MARKER);
@@ -168,6 +177,7 @@ export interface UpdateResult {
 	readonly installed: readonly string[];
 	readonly backupDir?: string;
 	readonly restartQueued?: string;
+	readonly brokerNotEnabled?: boolean;
 	readonly restartSkipped?: boolean;
 }
 
@@ -191,6 +201,7 @@ export function renderUpdate(result: UpdateResult): string[] {
 	if (result.restartQueued !== undefined)
 		lines.push(`restart: queued ${result.restartQueued} — check with: gajaeway ops restart-stack --status`);
 	else if (result.restartSkipped) lines.push("restart: skipped (--no-restart)");
+	if (result.brokerNotEnabled) lines.push("broker unit installed, not enabled: run gajaeway setup --broker-agent");
 	return lines;
 }
 
@@ -202,7 +213,13 @@ export interface RestartQueueReceipt {
 export type ReleaseFetcher = (repo: string) => Promise<ReleaseInfo>;
 export type AssetDownloader = (asset: ReleaseAsset) => Promise<Uint8Array>;
 export type TarballExtractor = (tarball: Uint8Array, intoDir: string) => Promise<void>;
-export type RestartQueuer = (home: string) => Promise<RestartQueueReceipt>;
+export type RestartQueuer = (home: string, binDir: string, trigger: "update") => Promise<RestartQueueReceipt>;
+export type UpdateCommandRunner = (command: readonly string[]) => Promise<number>;
+
+type UpdateServiceOptions = Pick<
+	InstallServicesOptions,
+	"launchAgentsDir" | "unitDir" | "loginPathRunner" | "writeFile"
+>;
 
 export interface UpdateDeps {
 	readonly fetchLatestRelease?: ReleaseFetcher;
@@ -214,6 +231,9 @@ export interface UpdateDeps {
 	readonly env?: NodeJS.ProcessEnv;
 	readonly execPath?: string;
 	readonly now?: () => number;
+	readonly gjcInstallRunner?: GjcInstallRunner;
+	readonly serviceRunner?: UpdateCommandRunner;
+	readonly serviceOptions?: UpdateServiceOptions;
 }
 
 export interface RunUpdateOptions {
@@ -222,6 +242,77 @@ export interface RunUpdateOptions {
 	readonly deps?: UpdateDeps;
 }
 
+async function readPinnedGjcVersion(path: string): Promise<string> {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(await readFile(path, "utf8"));
+	} catch (error) {
+		throw new Error(
+			`could not read pinned gjc version from ${path}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+		throw new Error(`invalid release package metadata at ${path}`);
+	const gjc = (parsed as { gjc?: unknown }).gjc;
+	if (typeof gjc !== "object" || gjc === null || Array.isArray(gjc))
+		throw new Error(`release package metadata at ${path} has no gjc.version`);
+	const version = (gjc as { version?: unknown }).version;
+	if (typeof version !== "string" || version.trim() === "")
+		throw new Error(`release package metadata at ${path} has no gjc.version`);
+	return version;
+}
+
+async function defaultUpdateCommandRunner(command: readonly string[]): Promise<number> {
+	const child = Bun.spawn([...command], { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
+	const [stderr, exitCode] = await Promise.all([new Response(child.stderr).text(), child.exited]);
+	if (exitCode !== 0) {
+		const detail = stderr.trim();
+		throw new Error(`${command.join(" ")} exited with status ${exitCode}${detail.length === 0 ? "" : `: ${detail}`}`);
+	}
+	return exitCode;
+}
+
+async function installUpdatedServices(options: {
+	readonly home: string;
+	readonly binDir: string;
+	readonly platform: ServicePlatform;
+	readonly noRestart: boolean;
+	readonly deps: UpdateDeps;
+}): Promise<boolean> {
+	const { home, binDir, platform, noRestart, deps } = options;
+	const brokerProvisioned = await exists(homeLayout(home).brokerProvisionManifest);
+	const env = { ...(deps.env ?? process.env), GAJAEWAY_HOME: home };
+	await installServices({
+		binDir,
+		platform,
+		env,
+		configuredAdaptersOnly: true,
+		compareAndWrite: true,
+		...deps.serviceOptions,
+	});
+	if (platform === "linux") {
+		const run = deps.serviceRunner ?? defaultUpdateCommandRunner;
+		const execute = async (command: readonly string[]): Promise<void> => {
+			const exitCode = await run(command);
+			if (exitCode !== 0) throw new Error(`${command.join(" ")} exited with status ${exitCode}`);
+		};
+		await execute(["systemctl", "--user", "daemon-reload"]);
+		if (!noRestart) {
+			const enableUnits: string[] = [];
+			for (const spec of serviceSpecs()) {
+				if (spec.id === "broker" && !brokerProvisioned) continue;
+				if (
+					spec.id.startsWith("adapter-") &&
+					!(await Bun.file(join(home, `adapter-${spec.id.slice(8)}.json`)).exists())
+				)
+					continue;
+				enableUnits.push(systemdUnitName(spec));
+			}
+			if (enableUnits.length > 0) await execute(["systemctl", "--user", "enable", ...enableUnits]);
+		}
+	}
+	return !brokerProvisioned;
+}
 export async function runUpdate(options: RunUpdateOptions): Promise<UpdateResult> {
 	const deps = options.deps ?? {};
 	const platform = deps.platform ?? process.platform;
@@ -247,45 +338,70 @@ export async function runUpdate(options: RunUpdateOptions): Promise<UpdateResult
 		return { current, latest, tag: release.tag, repo, checkedOnly: true, upToDate: false, installed: [] };
 	if (binDir === undefined) throw new Error("run the update from a compiled gajaeway binary, or pass --bin-dir DIR");
 
-	const unlock = await acquireUpdateLock(binDir);
+	let lease: Lease;
 	try {
-		const staged = await stageRelease(asset, deps);
-		const installedNames = await knownBinariesIn(binDir);
-		const toInstall = binariesToInstall(staged.names, installedNames);
-		const missingCore = CORE_BINARIES.filter((name) => !toInstall.includes(name));
-		if (missingCore.length > 0) throw new Error(`release tarball is missing core binaries: ${missingCore.join(", ")}`);
-		await assertStagedBinariesUsable(staged, toInstall);
-
-		const stamp = new Date((deps.now ?? Date.now)()).toISOString().replace(/[-:]/g, "").slice(0, 15);
-		const backupDir = join(binDir, `backup-${current}-${stamp}Z`);
-		await mkdir(backupDir, { recursive: false });
-		for (const name of toInstall) {
-			const target = join(binDir, name);
-			if (await exists(target)) await copyFile(target, join(backupDir, name));
+		lease = await acquireLease(options.home, "update");
+		console.info(`lease_acquired name=update pid=${process.pid}`);
+	} catch (error) {
+		if (error instanceof LeaseHeldError) {
+			console.error(error.message);
+			throw new Error(`another gajaeway update is running (${error.message})`, { cause: error });
 		}
-		for (const name of toInstall) {
-			const stagedPath = join(staged.dir, name);
-			const tempPath = join(binDir, `.update-${name}`);
-			await copyFile(stagedPath, tempPath);
-			await chmod(tempPath, 0o755);
-			await rename(tempPath, join(binDir, name));
+		console.error(`lease_failed name=update detail=${error instanceof Error ? error.message : String(error)}`);
+		throw error;
+	}
+
+	const installed = await (async () => {
+		let staged: StagedRelease | undefined;
+		try {
+			staged = await stageRelease(asset, deps);
+			const installedNames = await knownBinariesIn(binDir);
+			const toInstall = binariesToInstall(staged.names, installedNames);
+			const missingCore = CORE_BINARIES.filter((name) => !toInstall.includes(name));
+			if (missingCore.length > 0)
+				throw new Error(`release tarball is missing core binaries: ${missingCore.join(", ")}`);
+			await assertStagedBinariesUsable(staged, toInstall);
+
+			const gjcVersion = await readPinnedGjcVersion(join(staged.dir, PIN_MANIFEST));
+			await installPinnedGjc({
+				home: options.home,
+				version: gjcVersion,
+				...(deps.gjcInstallRunner === undefined ? {} : { runner: deps.gjcInstallRunner }),
+			});
+
+			const stamp = new Date((deps.now ?? Date.now)()).toISOString().replace(/[-:]/g, "").slice(0, 15);
+			const backupDir = join(binDir, `backup-${current}-${stamp}Z`);
+			await mkdir(backupDir, { recursive: false });
+			// The compiled gateway and broker host read the gjc pin from the package.json
+			// beside them; a stale one makes the new binaries refuse the gjc just installed.
+			const replaced = [...toInstall, PIN_MANIFEST];
+			for (const name of replaced) {
+				const target = join(binDir, name);
+				if (await exists(target)) await copyFile(target, join(backupDir, name));
+			}
+			for (const name of replaced) {
+				const stagedPath = join(staged.dir, name);
+				const tempPath = join(binDir, `.update-${name}`);
+				await copyFile(stagedPath, tempPath);
+				await chmod(tempPath, name === PIN_MANIFEST ? 0o644 : 0o755);
+				await rename(tempPath, join(binDir, name));
+			}
+			await writeFile(releaseMarkerPath(binDir), `${latest}\n`, "utf8");
+			const brokerNotEnabled = await installUpdatedServices({
+				home: options.home,
+				binDir,
+				platform,
+				noRestart: options.args.noRestart,
+				deps,
+			});
+			return { toInstall, backupDir, brokerNotEnabled };
+		} finally {
+			if (staged !== undefined) await rm(staged.dir, { recursive: true, force: true });
+			await lease.release();
 		}
-		await writeFile(releaseMarkerPath(binDir), `${latest}\n`, "utf8");
-		await rm(staged.dir, { recursive: true, force: true });
-
-		if (options.args.noRestart)
-			return {
-				current,
-				latest,
-				tag: release.tag,
-				repo,
-				checkedOnly: false,
-				upToDate: false,
-				installed: toInstall,
-				backupDir,
-				restartSkipped: true,
-			};
-		const receipt = await (deps.queueRestart ?? defaultQueueRestart)(options.home);
+	})();
+
+	if (options.args.noRestart)
 		return {
 			current,
 			latest,
@@ -293,13 +409,25 @@ export async function runUpdate(options: RunUpdateOptions): Promise<UpdateResult
 			repo,
 			checkedOnly: false,
 			upToDate: false,
-			installed: toInstall,
-			backupDir,
-			restartQueued: receipt.receiptId,
+			installed: installed.toInstall,
+			backupDir: installed.backupDir,
+			brokerNotEnabled: installed.brokerNotEnabled,
+			restartSkipped: true,
 		};
-	} finally {
-		await unlock();
-	}
+	const receipt = await (deps.queueRestart ?? defaultQueueRestart)(options.home, binDir, "update");
+
+	return {
+		current,
+		latest,
+		tag: release.tag,
+		repo,
+		checkedOnly: false,
+		upToDate: false,
+		installed: installed.toInstall,
+		backupDir: installed.backupDir,
+		brokerNotEnabled: installed.brokerNotEnabled,
+		restartQueued: receipt.receiptId,
+	};
 }
 
 function binariesToInstall(stagedNames: readonly string[], installedNames: readonly string[]): string[] {
@@ -393,58 +521,7 @@ async function defaultExtractTarball(tarball: Uint8Array, intoDir: string): Prom
 	await rm(tarballPath, { force: true });
 }
 
-async function defaultQueueRestart(home: string): Promise<RestartQueueReceipt> {
-	const { receipt, supervisorPid } = await launchRestartStack({ home });
+async function defaultQueueRestart(home: string, binDir: string, trigger: "update"): Promise<RestartQueueReceipt> {
+	const { receipt, supervisorPid } = await launchRestartStack({ home, binDir, trigger });
 	return { receiptId: receipt.id, supervisorPid };
 }
-
-/**
- * One update at a time per bin dir. A lock naming a live pid refuses; a lock
- * naming a dead one is stale and taken over.
- */
-export async function acquireUpdateLock(binDir: string): Promise<() => Promise<void>> {
-	const lockPath = join(binDir, LOCK_FILE);
-	for (let attempt = 0; attempt < 2; attempt++) {
-		try {
-			const handle = await open(lockPath, "wx");
-			try {
-				await handle.write(`${JSON.stringify({ pid: process.pid, at: new Date().toISOString() })}\n`);
-			} finally {
-				await handle.close();
-			}
-			return async () => {
-				await rm(lockPath, { force: true });
-			};
-		} catch (error) {
-			if (!isFileExistsError(error)) throw error;
-			const holder = await readLockHolder(lockPath);
-			if (holder !== undefined && isProcessAlive(holder)) {
-				throw new Error(`another gajaeway update is running (pid ${holder}); refusing to run concurrently`);
-			}
-			await rm(lockPath, { force: true });
-		}
-	}
-	throw new Error(`could not acquire the update lock at ${lockPath}`);
-}
-
-function isFileExistsError(error: unknown): boolean {
-	return error !== null && typeof error === "object" && (error as { code?: unknown }).code === "EEXIST";
-}
-
-async function readLockHolder(lockPath: string): Promise<number | undefined> {
-	try {
-		const parsed = JSON.parse(await readFile(lockPath, "utf8")) as { pid?: unknown };
-		return typeof parsed.pid === "number" ? parsed.pid : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function isProcessAlive(pid: number): boolean {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return (error as { code?: unknown }).code === "EPERM";
-	}
-}

package/dist/upgrade.d.ts

@@ -1,40 +0,0 @@
-/**
- * `gajaeway ops upgrade [--gjc X.Y.Z]`
- *
- * Atomically upgrades the gateway's gjc to the pinned version (or an override).
- * The process:
- * 1. Verify CI is green (deploy gate)
- * 2. Stop intake (implicit on restart)
- * 3. Wait for in-flight turns (bounded)
- * 4. Back up the DB
- * 5. Install the pinned gjc into the gateway's own prefix (checksum-verified)
- * 6. Restart the gateway's broker
- * 7. ops restart-stack
- * 8. Verify status (clients current, 0 pending, no held turns)
- *
- * Fails closed: leaves old binaries in place on any step.
- */
-export interface UpgradeOptions {
-    readonly home: string;
-    /** Override gjc version; defaults to reading from gateway's package.json */
-    readonly gjcVersion?: string;
-    /** Test seam: function to check CI status */
-    readonly checkCiStatus?: (repo: string) => Promise<boolean>;
-    /** Test seam: function to read gateway pinned gjc version */
-    readonly readPinnedVersion?: (home: string) => Promise<string>;
-}
-/**
- * Read the pinned gjc version the installed gateway runs against.
- *
- * The checkout layout is tried first (a source deployment keeps the pin in
- * `packages/gateway/package.json`); an installed binary carries the same file
- * beside itself, which is the only candidate that exists on a host that never
- * had the checkout.
- */
-export declare function readGatewayPinnedGjcVersion(home: string): Promise<string>;
-export interface UpgradeResult {
-    readonly status: "ok" | "failed";
-    readonly detail: string;
-}
-export declare function performUpgrade(options: UpgradeOptions): Promise<UpgradeResult>;
-//# sourceMappingURL=upgrade.d.ts.map

package/dist/upgrade.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../src/upgrade.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,6DAA6D;IAC7D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/D;AAED;;;;;;;GAOG;AACH,wBAAsB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAc/E;AAED,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,MAAM,EAAE,IAAI,GAAG,QAAQ,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AA2DD,wBAAsB,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAwFpF"}

package/src/upgrade.ts

@@ -1,205 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-/**
- * `gajaeway ops upgrade [--gjc X.Y.Z]`
- *
- * Atomically upgrades the gateway's gjc to the pinned version (or an override).
- * The process:
- * 1. Verify CI is green (deploy gate)
- * 2. Stop intake (implicit on restart)
- * 3. Wait for in-flight turns (bounded)
- * 4. Back up the DB
- * 5. Install the pinned gjc into the gateway's own prefix (checksum-verified)
- * 6. Restart the gateway's broker
- * 7. ops restart-stack
- * 8. Verify status (clients current, 0 pending, no held turns)
- *
- * Fails closed: leaves old binaries in place on any step.
- */
-
-export interface UpgradeOptions {
-	readonly home: string;
-	/** Override gjc version; defaults to reading from gateway's package.json */
-	readonly gjcVersion?: string;
-	/** Test seam: function to check CI status */
-	readonly checkCiStatus?: (repo: string) => Promise<boolean>;
-	/** Test seam: function to read gateway pinned gjc version */
-	readonly readPinnedVersion?: (home: string) => Promise<string>;
-}
-
-/**
- * Read the pinned gjc version the installed gateway runs against.
- *
- * The checkout layout is tried first (a source deployment keeps the pin in
- * `packages/gateway/package.json`); an installed binary carries the same file
- * beside itself, which is the only candidate that exists on a host that never
- * had the checkout.
- */
-export async function readGatewayPinnedGjcVersion(home: string): Promise<string> {
-	const candidates = [
-		join(home, "..", "..", "packages", "gateway", "package.json"),
-		join(dirname(process.execPath), "package.json"),
-	];
-	for (const path of candidates) {
-		try {
-			const version = (JSON.parse(await readFile(path, "utf-8")) as { gjc?: { version?: unknown } }).gjc?.version;
-			if (typeof version === "string" && version.length > 0) return version;
-		} catch {
-			// A missing or malformed candidate is not fatal: a later one may carry the pin.
-		}
-	}
-	throw new Error(`Failed to read pinned GJC version from any of ${candidates.join(", ")}`);
-}
-
-export interface UpgradeResult {
-	readonly status: "ok" | "failed";
-	readonly detail: string;
-}
-
-/**
- * Check CI status by running: gh run list -R owner/repo --branch HEAD --limit 1 --json conclusion
- * Returns true if the latest CI run passed (conclusion: success)
- */
-async function checkLatestCiStatus(repo: string): Promise<boolean> {
-	try {
-		// Get current git branch
-		const branchProc = Bun.spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		if (branchProc.exitCode !== 0) {
-			throw new Error("Could not determine current git branch");
-		}
-
-		const branch = branchProc.stdout?.toString().trim();
-		if (!branch) {
-			throw new Error("Empty branch name");
-		}
-
-		// Check CI status for this branch
-		const runProc = Bun.spawnSync(
-			["gh", "run", "list", "-R", repo, "--branch", branch, "--limit", "1", "--json", "conclusion,status"],
-			{
-				stdout: "pipe",
-				stderr: "pipe",
-			},
-		);
-
-		if (runProc.exitCode !== 0) {
-			throw new Error(`gh run list failed: ${runProc.stderr?.toString()}`);
-		}
-
-		const output = runProc.stdout?.toString() || "[]";
-		const runs = JSON.parse(output);
-
-		if (!Array.isArray(runs) || runs.length === 0) {
-			throw new Error("No CI runs found for this branch");
-		}
-
-		const latestRun = runs[0];
-		if (!latestRun.conclusion || !latestRun.status) {
-			throw new Error(`Latest CI run status is incomplete: ${JSON.stringify(latestRun)}`);
-		}
-
-		// conclusion can be: success, failure, neutral, cancelled, skipped, timed_out
-		// status can be: queued, in_progress, completed
-		if (latestRun.status === "in_progress") {
-			throw new Error("CI is currently running; wait for completion");
-		}
-
-		return latestRun.conclusion === "success";
-	} catch (error) {
-		throw new Error(`Failed to check CI status: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-export async function performUpgrade(options: UpgradeOptions): Promise<UpgradeResult> {
-	const readVersion = options.readPinnedVersion || readGatewayPinnedGjcVersion;
-	const targetVersion = options.gjcVersion ?? (await readVersion(options.home));
-
-	try {
-		// 1. Check CI status (deploy gate)
-		const checkCi = options.checkCiStatus || checkLatestCiStatus;
-		let ciPassed = false;
-		try {
-			ciPassed = await checkCi("Yeachan-Heo/gajae-way");
-		} catch (ciError) {
-			const ciDetail = ciError instanceof Error ? ciError.message : String(ciError);
-			return { status: "failed", detail: `CI status check failed: ${ciDetail}` };
-		}
-
-		if (!ciPassed) {
-			return {
-				status: "failed",
-				detail: `Cannot upgrade: latest CI run did not pass. Fix failures and try again.`,
-			};
-		}
-
-		// 2. Read current gjc version
-		const gjcProc = Bun.spawnSync(["gjc", "--version"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		if (gjcProc.exitCode !== 0) {
-			return { status: "failed", detail: "Failed to get current gjc version" };
-		}
-
-		const currentVersionMatch = ((gjcProc.stdout?.toString() || "") + (gjcProc.stderr?.toString() || "")).match(
-			/(?:gjc\/)?(\d+)\.(\d+)\.(\d+)/,
-		);
-		if (!currentVersionMatch) {
-			return { status: "failed", detail: "Could not parse current gjc version" };
-		}
-		const currentVersion = currentVersionMatch.slice(1, 4).join(".");
-
-		if (currentVersion === targetVersion) {
-			return { status: "ok", detail: `Already running gjc ${targetVersion}` };
-		}
-
-		// 3. Install new gjc version
-		const installProc = Bun.spawnSync(["bun", "add", "-g", `gajae-code@${targetVersion}`], {
-			stdout: "pipe",
-			stderr: "pipe",
-			cwd: join(options.home, "workspace"),
-		});
-
-		if (installProc.exitCode !== 0) {
-			return {
-				status: "failed",
-				detail: `Failed to install gjc ${targetVersion}: ${installProc.stderr?.toString()}`,
-			};
-		}
-
-		// 4. Verify installation
-		const verifyProc = Bun.spawnSync(["gjc", "--version"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		if (verifyProc.exitCode !== 0) {
-			return { status: "failed", detail: "Failed to verify gjc installation" };
-		}
-
-		const verifiedVersionMatch = ((verifyProc.stdout?.toString() || "") + (verifyProc.stderr?.toString() || "")).match(
-			/(?:gjc\/)?(\d+)\.(\d+)\.(\d+)/,
-		);
-		if (!verifiedVersionMatch) {
-			return { status: "failed", detail: "Could not verify installed gjc version" };
-		}
-
-		const verifiedVersion = verifiedVersionMatch.slice(1, 4).join(".");
-		if (verifiedVersion !== targetVersion) {
-			return {
-				status: "failed",
-				detail: `Verification failed: expected ${targetVersion}, got ${verifiedVersion}`,
-			};
-		}
-
-		return { status: "ok", detail: `Successfully upgraded gjc from ${currentVersion} to ${targetVersion}` };
-	} catch (error) {
-		return {
-			status: "failed",
-			detail: `Upgrade failed: ${error instanceof Error ? error.message : String(error)}`,
-		};
-	}
-}