@xopcai/xopc 0.0.89 → 0.0.91

package/dist/src/infra/update-runner.js

@@ -1,192 +1,623 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { join } from "node:path";
-import { access, readdir, unlink } from "node:fs/promises";
-import { spawn } from "node:child_process";
+import { runPostUpdateExtensionSync } from "../extensions/update.js";
+import "./update-channels.js";
+import { compareSemver, resolveNpmChannelTag } from "./update-check.js";
+import { readPackageName, readPackageVersion } from "./package-json.js";
+import { createDefaultCommandRunner, runCommandWithTimeout } from "./run-command.js";
+import { XOPC_PACKAGE_NAME, cleanupGlobalRenameDirs, createGlobalInstallEnv, detectGlobalInstallManagerForRoot, resolveGlobalInstallSpec, resolveGlobalInstallTarget } from "./update-global.js";
+import { runGlobalPackageUpdateSteps } from "./package-update-steps.js";
+import { resolveStableNodePath } from "./stable-node-path.js";
+import { trimLogTail } from "./update-log.js";
+import { maybeRestartGatewayAfterUpdate } from "./update-restart.js";
+import path from "node:path";
+import fs from "node:fs/promises";
 //#region src/infra/update-runner.ts
-init_logger();
-const log = createLogger("UpdateRunner");
-const AUTO_UPDATE_TIMEOUT_MS = 2700 * 1e3;
-function createLineEmitter(onProgress) {
-	let bufOut = "";
-	let bufErr = "";
-	const flush = (buf, source) => {
-		const parts = buf.split("\n");
-		const rest = parts.pop() ?? "";
-		for (const line of parts) if (line.length) onProgress?.(line, source);
-		return rest;
+const DEFAULT_TIMEOUT_MS = 2700 * 1e3;
+const MAX_LOG_CHARS = 8e3;
+const CORE_PACKAGE_NAMES = new Set([XOPC_PACKAGE_NAME]);
+function normalizeDir(value) {
+	if (!value) return null;
+	const trimmed = value.trim();
+	return trimmed ? path.resolve(trimmed) : null;
+}
+function resolveNodeModulesBinPackageRoot(argv1) {
+	const normalized = path.resolve(argv1);
+	const parts = normalized.split(path.sep);
+	const binIndex = parts.lastIndexOf(".bin");
+	if (binIndex <= 0 || parts[binIndex - 1] !== "node_modules") return null;
+	return path.join(parts.slice(0, binIndex).join(path.sep), path.basename(normalized));
+}
+function buildStartDirs(opts) {
+	const dirs = [];
+	const cwd = normalizeDir(opts.cwd);
+	if (cwd) dirs.push(cwd);
+	const argv1 = normalizeDir(opts.argv1);
+	if (argv1) {
+		dirs.push(path.dirname(argv1));
+		const packageRoot = resolveNodeModulesBinPackageRoot(argv1);
+		if (packageRoot) dirs.push(packageRoot);
+	}
+	const proc = normalizeDir(process.cwd());
+	if (proc) dirs.push(proc);
+	return Array.from(new Set(dirs));
+}
+async function resolveComparablePath(target) {
+	return fs.realpath(target).catch(() => path.resolve(target));
+}
+async function pathsReferToSameLocation(left, right) {
+	return await resolveComparablePath(left) === await resolveComparablePath(right);
+}
+async function looksLikeGitCheckout(root) {
+	try {
+		await fs.access(path.join(root, ".git"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function resolveGitRoot(runCommand, candidates, timeoutMs) {
+	for (const dir of candidates) {
+		const res = await runCommand([
+			"git",
+			"-C",
+			dir,
+			"rev-parse",
+			"--show-toplevel"
+		], { timeoutMs }).catch(() => null);
+		if (!res || res.code !== 0) continue;
+		const root = res.stdout.trim();
+		if (root) return root;
+	}
+	return null;
+}
+async function findPackageRoot(candidates) {
+	for (const dir of candidates) {
+		let current = dir;
+		for (let i = 0; i < 12; i += 1) {
+			const pkgPath = path.join(current, "package.json");
+			try {
+				const raw = await fs.readFile(pkgPath, "utf-8");
+				const name = JSON.parse(raw)?.name?.trim();
+				if (name && CORE_PACKAGE_NAMES.has(name)) return current;
+			} catch {}
+			const parent = path.dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+	return null;
+}
+function mergeCommandEnvironments(baseEnv, overrideEnv) {
+	if (!baseEnv) return overrideEnv;
+	if (!overrideEnv) return baseEnv;
+	return {
+		...baseEnv,
+		...overrideEnv
 	};
+}
+async function buildUpdateCommandRunner() {
+	const defaultCommandEnv = await createGlobalInstallEnv();
 	return {
-		pushStdout(chunk) {
-			bufOut += chunk;
-			bufOut = flush(bufOut, "stdout");
-		},
-		pushStderr(chunk) {
-			bufErr += chunk;
-			bufErr = flush(bufErr, "stderr");
-		},
-		flushEnd() {
-			if (bufOut.length) onProgress?.(bufOut, "stdout");
-			if (bufErr.length) onProgress?.(bufErr, "stderr");
+		defaultCommandEnv,
+		runCommand: async (argv, options) => {
+			const res = await runCommandWithTimeout(argv, {
+				...options,
+				env: mergeCommandEnvironments(defaultCommandEnv, options.env)
+			});
+			return {
+				stdout: res.stdout,
+				stderr: res.stderr,
+				code: res.code
+			};
 		}
 	};
 }
-async function spawnUpdateCommand(params) {
-	const timeoutMs = params.timeoutMs ?? AUTO_UPDATE_TIMEOUT_MS;
-	const argv = await resolveUpdateCommandArgv([
-		"update",
-		"--yes",
-		"--channel",
-		params.channel,
-		"--json"
-	], params.root ?? null);
-	return new Promise((resolve) => {
-		const child = spawn(argv[0], argv.slice(1), {
-			env: {
-				...process.env,
-				XOPC_AUTO_UPDATE: "1"
-			},
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			detached: false
+async function runStep(opts) {
+	const { runCommand, name, argv, cwd, timeoutMs, env, progress, stepIndex, totalSteps } = opts;
+	const command = argv.join(" ");
+	const stepInfo = {
+		name,
+		command,
+		index: stepIndex,
+		total: totalSteps
+	};
+	progress?.onStepStart?.(stepInfo);
+	const started = Date.now();
+	const result = await runCommand(argv, {
+		cwd,
+		timeoutMs,
+		env
+	});
+	const durationMs = Date.now() - started;
+	const stderrTail = trimLogTail(result.stderr, MAX_LOG_CHARS);
+	progress?.onStepComplete?.({
+		...stepInfo,
+		durationMs,
+		exitCode: result.code,
+		stderrTail
+	});
+	return {
+		name,
+		command,
+		cwd,
+		durationMs,
+		exitCode: result.code,
+		stdoutTail: trimLogTail(result.stdout, MAX_LOG_CHARS),
+		stderrTail
+	};
+}
+function toUpdateStepResult(step) {
+	return {
+		name: step.name,
+		command: step.command,
+		cwd: step.cwd,
+		durationMs: step.durationMs,
+		exitCode: step.exitCode,
+		stdoutTail: step.stdoutTail,
+		stderrTail: step.stderrTail
+	};
+}
+async function resolveUpdateInstallSurface(opts = {}) {
+	const { runCommand } = await buildUpdateCommandRunner();
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const candidates = buildStartDirs(opts);
+	const pkgRoot = await findPackageRoot(candidates);
+	let gitRoot = await resolveGitRoot(runCommand, candidates, timeoutMs);
+	if (gitRoot && pkgRoot && !await pathsReferToSameLocation(gitRoot, pkgRoot)) gitRoot = null;
+	if (gitRoot && !pkgRoot) return {
+		kind: "missing",
+		mode: "unknown",
+		root: gitRoot
+	};
+	if (gitRoot && pkgRoot && await pathsReferToSameLocation(gitRoot, pkgRoot)) return {
+		kind: "git",
+		mode: "git",
+		root: gitRoot,
+		packageRoot: pkgRoot
+	};
+	if (!pkgRoot) return {
+		kind: "missing",
+		mode: "unknown"
+	};
+	const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
+	if (globalManager) return {
+		kind: "global",
+		mode: globalManager,
+		root: pkgRoot,
+		packageRoot: pkgRoot
+	};
+	return {
+		kind: "package-root",
+		mode: "unknown",
+		root: pkgRoot,
+		packageRoot: pkgRoot
+	};
+}
+async function runGitUpdate(params) {
+	const startedAt = Date.now();
+	const steps = [];
+	const { gitRoot, runCommand, timeoutMs, progress, defaultCommandEnv } = params;
+	const totalSteps = 7;
+	let stepIndex = 0;
+	const step = (name, argv, cwd, env) => runStep({
+		runCommand,
+		name,
+		argv,
+		cwd,
+		timeoutMs,
+		env,
+		progress,
+		stepIndex: stepIndex++,
+		totalSteps
+	});
+	const beforeSha = (await runCommand([
+		"git",
+		"-C",
+		gitRoot,
+		"rev-parse",
+		"HEAD"
+	], {
+		cwd: gitRoot,
+		timeoutMs
+	})).stdout.trim() || null;
+	const beforeVersion = await readPackageVersion(gitRoot);
+	const statusCheck = await step("clean check", [
+		"git",
+		"-C",
+		gitRoot,
+		"status",
+		"--porcelain"
+	], gitRoot);
+	steps.push(statusCheck);
+	if (statusCheck.stdoutTail?.trim()) return {
+		status: "skipped",
+		mode: "git",
+		root: gitRoot,
+		reason: "dirty",
+		before: {
+			sha: beforeSha,
+			version: beforeVersion
+		},
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+	const fetchStep = await step("git fetch", [
+		"git",
+		"-C",
+		gitRoot,
+		"fetch",
+		"--all",
+		"--prune",
+		"--tags"
+	], gitRoot);
+	steps.push(fetchStep);
+	if (fetchStep.exitCode !== 0) return {
+		status: "error",
+		mode: "git",
+		root: gitRoot,
+		reason: "fetch-failed",
+		before: {
+			sha: beforeSha,
+			version: beforeVersion
+		},
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+	const upstreamStep = await step("upstream check", [
+		"git",
+		"-C",
+		gitRoot,
+		"rev-parse",
+		"--abbrev-ref",
+		"--symbolic-full-name",
+		"@{upstream}"
+	], gitRoot);
+	steps.push(upstreamStep);
+	if (upstreamStep.exitCode !== 0) return {
+		status: "skipped",
+		mode: "git",
+		root: gitRoot,
+		reason: "no-upstream",
+		before: {
+			sha: beforeSha,
+			version: beforeVersion
+		},
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+	const rebaseStep = await step("git rebase", [
+		"git",
+		"-C",
+		gitRoot,
+		"rebase",
+		"@{upstream}"
+	], gitRoot);
+	steps.push(rebaseStep);
+	if (rebaseStep.exitCode !== 0) return {
+		status: "error",
+		mode: "git",
+		root: gitRoot,
+		reason: "rebase-failed",
+		before: {
+			sha: beforeSha,
+			version: beforeVersion
+		},
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+	const depsStep = await step("deps install", ["pnpm", "install"], gitRoot, defaultCommandEnv);
+	steps.push(depsStep);
+	if (depsStep.exitCode !== 0) return {
+		status: "error",
+		mode: "git",
+		root: gitRoot,
+		reason: "deps-install-failed",
+		before: {
+			sha: beforeSha,
+			version: beforeVersion
+		},
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+	const buildStep = await step("build", [
+		"pnpm",
+		"run",
+		"build"
+	], gitRoot, defaultCommandEnv);
+	steps.push(buildStep);
+	if (buildStep.exitCode !== 0) return {
+		status: "error",
+		mode: "git",
+		root: gitRoot,
+		reason: "build-failed",
+		before: {
+			sha: beforeSha,
+			version: beforeVersion
+		},
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+	const doctorEntry = path.join(gitRoot, "dist/src/cli/bin.js");
+	if (await fs.stat(doctorEntry).then(() => true).catch(() => false)) {
+		const doctorStep = await step("xopc doctor", [
+			await resolveStableNodePath(process.execPath),
+			doctorEntry,
+			"doctor",
+			"--fix"
+		], gitRoot, {
+			...defaultCommandEnv,
+			XOPC_UPDATE_IN_PROGRESS: "1"
 		});
-		let stdout = "";
-		let stderr = "";
-		let stdoutTruncated = false;
-		let stderrTruncated = false;
-		const lineEmitter = createLineEmitter(params.onProgress);
-		const timeoutId = setTimeout(() => {
-			child.kill("SIGTERM");
-		}, timeoutMs);
-		const finish = (result) => {
-			clearTimeout(timeoutId);
-			lineEmitter.flushEnd();
-			resolve(result);
+		steps.push(doctorStep);
+		if (doctorStep.exitCode !== 0) return {
+			status: "error",
+			mode: "git",
+			root: gitRoot,
+			reason: "doctor-failed",
+			before: {
+				sha: beforeSha,
+				version: beforeVersion
+			},
+			steps,
+			durationMs: Date.now() - startedAt
 		};
-		child.stdout?.on("data", (chunk) => {
-			const text = chunk.toString();
-			stdout += text;
-			lineEmitter.pushStdout(text);
-			if (stdout.length > 64e3) {
-				if (!stdoutTruncated) {
-					log.warn("Update command stdout exceeded 64KB; truncating");
-					stdoutTruncated = true;
-				}
-				stdout = stdout.slice(-32e3);
-			}
-		});
-		child.stderr?.on("data", (chunk) => {
-			const text = chunk.toString();
-			stderr += text;
-			lineEmitter.pushStderr(text);
-			if (stderr.length > 64e3) {
-				if (!stderrTruncated) {
-					log.warn("Update command stderr exceeded 64KB; truncating");
-					stderrTruncated = true;
-				}
-				stderr = stderr.slice(-32e3);
-			}
-		});
-		child.on("error", (err) => {
-			log.error({ err }, `Update subprocess spawn error: ${err.message}`);
-			finish({
-				ok: false,
-				exitCode: null,
-				reason: err.message,
-				stdout,
-				stderr
-			});
-		});
-		child.on("exit", (code, signal) => {
-			if (signal === "SIGTERM" || code === 143) {
-				log.warn({
-					code,
-					signal
-				}, "Update subprocess timed out; attempting lock file cleanup");
-				cleanupNpmLockFiles(params.root).catch((cleanupErr) => {
-					log.warn({ err: cleanupErr }, "Failed to clean npm lock files after timeout");
-				});
-				finish({
-					ok: false,
-					exitCode: code,
-					reason: "timeout",
-					stdout,
-					stderr
-				});
-				return;
-			}
-			finish({
-				ok: code === 0,
-				exitCode: code,
-				reason: code === 0 ? void 0 : "non-zero-exit",
-				stdout,
-				stderr
+	}
+	const afterShaStep = await step("git rev-parse HEAD (after)", [
+		"git",
+		"-C",
+		gitRoot,
+		"rev-parse",
+		"HEAD"
+	], gitRoot);
+	steps.push(afterShaStep);
+	const afterVersion = await readPackageVersion(gitRoot);
+	return {
+		status: "ok",
+		mode: "git",
+		root: gitRoot,
+		before: {
+			sha: beforeSha,
+			version: beforeVersion
+		},
+		after: {
+			sha: afterShaStep.stdoutTail?.trim() ?? null,
+			version: afterVersion
+		},
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+}
+async function runGlobalUpdate(params) {
+	const startedAt = Date.now();
+	const beforeVersion = await readPackageVersion(params.pkgRoot);
+	const resolved = await resolveNpmChannelTag({
+		channel: params.channel,
+		timeoutMs: 1e4
+	});
+	if (!resolved.version) return {
+		status: "error",
+		mode: params.globalManager,
+		root: params.pkgRoot,
+		reason: "registry-unreachable",
+		before: { version: beforeVersion },
+		steps: [],
+		durationMs: Date.now() - startedAt
+	};
+	const comparison = compareSemver(beforeVersion ?? "0.0.0", resolved.version);
+	if (comparison !== null && comparison >= 0) return {
+		status: "skipped",
+		mode: params.globalManager,
+		root: params.pkgRoot,
+		reason: "up-to-date",
+		before: { version: beforeVersion },
+		after: { version: beforeVersion },
+		steps: [],
+		durationMs: Date.now() - startedAt
+	};
+	const installTarget = await resolveGlobalInstallTarget({
+		manager: params.globalManager,
+		runCommand: params.runCommand,
+		timeoutMs: params.timeoutMs,
+		pkgRoot: params.pkgRoot
+	});
+	const packageName = await readPackageName(params.pkgRoot) ?? "@xopcai/xopc";
+	if (installTarget.globalRoot) await cleanupGlobalRenameDirs({
+		globalRoot: installTarget.globalRoot,
+		packageName
+	});
+	const spec = resolveGlobalInstallSpec({
+		version: resolved.version,
+		env: params.defaultCommandEnv
+	});
+	let stepIndex = 0;
+	const packageUpdate = await runGlobalPackageUpdateSteps({
+		installTarget,
+		installSpec: spec,
+		packageName,
+		packageRoot: params.pkgRoot,
+		runCommand: params.runCommand,
+		timeoutMs: params.timeoutMs,
+		...params.defaultCommandEnv === void 0 ? {} : { env: params.defaultCommandEnv },
+		installCwd: params.pkgRoot,
+		runStep: async (stepParams) => {
+			const result = await runStep({
+				runCommand: params.runCommand,
+				name: stepParams.name,
+				argv: stepParams.argv,
+				cwd: stepParams.cwd ?? params.pkgRoot,
+				timeoutMs: stepParams.timeoutMs,
+				env: stepParams.env,
+				progress: params.progress,
+				stepIndex: stepIndex++,
+				totalSteps: 3
 			});
+			return {
+				name: result.name,
+				command: result.command,
+				cwd: result.cwd,
+				durationMs: result.durationMs,
+				exitCode: result.exitCode,
+				stdoutTail: result.stdoutTail,
+				stderrTail: result.stderrTail
+			};
+		}
+	});
+	const steps = packageUpdate.steps.map(toUpdateStepResult);
+	return {
+		status: packageUpdate.failedStep ? "error" : "ok",
+		mode: params.globalManager,
+		root: packageUpdate.verifiedPackageRoot ?? params.pkgRoot,
+		reason: packageUpdate.failedStep ? "global-install-failed" : void 0,
+		before: { version: beforeVersion },
+		after: { version: packageUpdate.afterVersion },
+		steps,
+		durationMs: Date.now() - startedAt
+	};
+}
+async function runGatewayUpdate(opts = {}) {
+	const startedAt = Date.now();
+	const { defaultCommandEnv, runCommand } = await buildUpdateCommandRunner();
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const channel = opts.channel ?? "stable";
+	const candidates = buildStartDirs(opts);
+	const pkgRoot = await findPackageRoot(candidates);
+	let gitRoot = await resolveGitRoot(runCommand, candidates, timeoutMs);
+	if (!gitRoot && pkgRoot) {
+		const cwdRoot = normalizeDir(opts.cwd);
+		if (cwdRoot && await pathsReferToSameLocation(cwdRoot, pkgRoot) && await looksLikeGitCheckout(cwdRoot)) gitRoot = await resolveComparablePath(cwdRoot);
+	}
+	if (gitRoot && pkgRoot && !await pathsReferToSameLocation(gitRoot, pkgRoot)) gitRoot = null;
+	if (gitRoot && pkgRoot && await pathsReferToSameLocation(gitRoot, pkgRoot)) return runGitUpdate({
+		gitRoot,
+		runCommand,
+		timeoutMs,
+		progress: opts.progress,
+		defaultCommandEnv
+	});
+	if (!pkgRoot) return {
+		status: "error",
+		mode: "unknown",
+		reason: "not-xopc-root",
+		steps: [],
+		durationMs: Date.now() - startedAt
+	};
+	const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
+	if (globalManager) return runGlobalUpdate({
+		pkgRoot,
+		globalManager,
+		channel,
+		runCommand,
+		timeoutMs,
+		defaultCommandEnv,
+		progress: opts.progress
+	});
+	return {
+		status: "skipped",
+		mode: "unknown",
+		root: pkgRoot,
+		reason: "not-global-install",
+		before: { version: await readPackageVersion(pkgRoot) },
+		steps: [],
+		durationMs: Date.now() - startedAt
+	};
+}
+async function runGatewayUpdateWithPostSteps(opts = {}) {
+	const channel = opts.channel ?? "stable";
+	const result = await runGatewayUpdate(opts);
+	if (result.status !== "ok") return result;
+	const postUpdate = {};
+	if (!opts.skipExtensionSync) {
+		const extensions = await runPostUpdateExtensionSync({
+			channel,
+			timeoutMs: opts.timeoutMs
 		});
+		postUpdate.extensions = extensions;
+		if (extensions.status === "error") return {
+			...result,
+			status: "error",
+			reason: "post-update-extensions",
+			postUpdate
+		};
+	}
+	postUpdate.restart = await maybeRestartGatewayAfterUpdate({
+		shouldRestart: opts.shouldRestart,
+		expectedVersion: result.after?.version ?? void 0,
+		triggerInProcessRestart: opts.triggerInProcessRestart
 	});
+	return {
+		...result,
+		postUpdate
+	};
+}
+function formatUpdateApiResult(result, channel) {
+	if (result.status === "skipped" && result.reason === "up-to-date") return {
+		status: "up-to-date",
+		currentVersion: result.before?.version ?? null,
+		latestVersion: result.before?.version ?? null,
+		channel,
+		mode: result.mode
+	};
+	if (result.status === "ok") return {
+		status: "ok",
+		previousVersion: result.before?.version ?? null,
+		installedVersion: result.after?.version ?? null,
+		channel,
+		mode: result.mode,
+		steps: result.steps.length,
+		postUpdate: result.postUpdate ?? void 0
+	};
+	const failed = result.steps.find((step) => step.exitCode !== 0);
+	return {
+		status: "error",
+		reason: result.reason ?? "update-failed",
+		mode: result.mode,
+		message: failed?.stderrTail ?? failed?.stdoutTail ?? result.reason,
+		stderrTail: failed?.stderrTail ?? void 0
+	};
 }
 async function runAutoUpdateCommand(params) {
-	return spawnUpdateCommand(params);
+	const result = await runGatewayUpdateWithPostSteps({
+		channel: params.channel,
+		cwd: params.root ?? void 0,
+		argv1: process.argv[1],
+		timeoutMs: params.timeoutMs,
+		triggerInProcessRestart: params.triggerInProcessRestart
+	});
+	const payload = formatUpdateApiResult(result, params.channel);
+	const stdout = JSON.stringify(payload);
+	return {
+		ok: result.status === "ok" || result.status === "skipped" && result.reason === "up-to-date",
+		exitCode: result.status === "error" ? 1 : 0,
+		reason: result.reason,
+		stdout,
+		stderr: result.steps.find((s) => s.exitCode !== 0)?.stderrTail ?? void 0,
+		result
+	};
 }
 async function runAutoUpdateCommandWithProgress(params) {
-	return spawnUpdateCommand(params);
-}
-async function cleanupNpmLockFiles(root) {
-	if (!root) return;
-	let entries;
-	try {
-		entries = await readdir(root);
-	} catch {
-		return;
-	}
-	for (const entry of entries) if (entry.startsWith(".package-lock")) try {
-		await unlink(join(root, entry));
-	} catch {}
-}
-/**
-* Resolve the argv array for spawning the update command.
-*
-* Priority:
-* 1. process.execPath + process.argv[1] (current runtime + entry point)
-* 2. process.execPath + known dist entry points in root
-* 3. Fallback to bare `xopc` (assumes global install)
-*/
-async function resolveUpdateCommandArgv(baseArgs, root) {
-	const execPath = process.execPath?.trim();
-	const argv1 = process.argv[1]?.trim();
-	if (execPath && argv1) return [
-		execPath,
-		argv1,
-		...baseArgs
-	];
-	if (execPath && root) {
-		const candidates = [join(root, "dist/src/cli/bin.js"), join(root, "dist/index.js")];
-		for (const candidate of candidates) try {
-			await access(candidate);
-			return [
-				execPath,
-				candidate,
-				...baseArgs
-			];
-		} catch {}
-	}
-	log.warn("Falling back to bare `xopc` command — version mismatch possible");
-	try {
-		const { execSync } = await import("node:child_process");
-		const whichResult = execSync(process.platform === "win32" ? "where xopc" : "which xopc", {
-			encoding: "utf-8",
-			timeout: 3e3
-		}).trim();
-		if (whichResult) log.info({ resolvedPath: whichResult.split(/\r?\n/)[0]?.trim() }, "Resolved xopc via PATH");
-	} catch {
-		log.warn("Could not resolve `xopc` in PATH; update command may fail");
-	}
-	return ["xopc", ...baseArgs];
+	const result = await runGatewayUpdateWithPostSteps({
+		channel: params.channel,
+		cwd: params.root ?? void 0,
+		argv1: process.argv[1],
+		timeoutMs: params.timeoutMs,
+		triggerInProcessRestart: params.triggerInProcessRestart,
+		progress: {
+			onStepStart: (step) => void params.onProgress?.(`[${step.index + 1}/${step.total}] ${step.name}`, "stdout"),
+			onStepComplete: (step) => {
+				if (step.exitCode !== 0 && step.stderrTail) params.onProgress?.(step.stderrTail, "stderr");
+			}
+		}
+	});
+	const payload = formatUpdateApiResult(result, params.channel);
+	return {
+		ok: result.status === "ok" || result.status === "skipped" && result.reason === "up-to-date",
+		exitCode: result.status === "error" ? 1 : 0,
+		reason: result.reason,
+		stdout: JSON.stringify(payload),
+		stderr: result.steps.find((s) => s.exitCode !== 0)?.stderrTail ?? void 0,
+		result
+	};
 }
 //#endregion
-export { runAutoUpdateCommand, runAutoUpdateCommandWithProgress };
+export { createDefaultCommandRunner, formatUpdateApiResult, resolveUpdateInstallSurface, runAutoUpdateCommand, runAutoUpdateCommandWithProgress, runGatewayUpdate, runGatewayUpdateWithPostSteps };
 
 //# sourceMappingURL=update-runner.js.map