// Shared update command primitives for channel resolution, install roots, and subprocess steps.

import { spawnSync } from "node:child_process";

import fs from "node:fs/promises";

import os from "node:os";

const INVALID_TIMEOUT_ERROR = "--timeout must be a positive integer (seconds)";

const MAX_SAFE_TIMEOUT_SECONDS = Math.floor(Number.MAX_SAFE_INTEGER / 1000);

/** Parse a CLI timeout in seconds, exiting through the runtime on invalid input. */

export function parseTimeoutMsOrExit(timeout?: string): number | undefined | null {

if (timeout === undefined) {

return undefined;

export const DEFAULT_PACKAGE_NAME = "openclaw";

const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME]);

/** Normalize a CLI tag/version/spec into the npm target form accepted by update flows. */

export function normalizeTag(value?: string | null): string | null {

return normalizePackageTagInput(value, ["openclaw", DEFAULT_PACKAGE_NAME]);

}

export { readPackageName, readPackageVersion };

/** Resolve an npm dist-tag or explicit version into a concrete package version. */

export async function resolveTargetVersion(

tag: string,

timeoutMs?: number,

return res.version ?? null;

}

/** Return true when `root` is a local git checkout directory. */

export async function isGitCheckout(root: string): Promise<boolean> {

try {

await fs.stat(path.join(root, ".git"));

return Boolean(name && CORE_PACKAGE_NAMES.has(name));

}

/** Return true only for existing directories with no entries. */

export async function isEmptyDir(targetPath: string): Promise<boolean> {

try {

const entries = await fs.readdir(targetPath);

}

}

/** Resolve the checkout path used by source-based self-update. */

export function resolveGitInstallDir(): string {

const override = process.env.OPENCLAW_GIT_DIR?.trim();

if (override) {

return path.join(home, "openclaw");

}

/** Prefer the current Node executable, falling back to `node` when run through another shim. */

export function resolveNodeRunner(): string {

const base = normalizeLowercaseStringOrEmpty(path.basename(process.execPath));

if (base === "node" || base === "node.exe") {

return "node";

}

/** Locate the installed OpenClaw package root that should receive update operations. */

export async function resolveUpdateRoot(): Promise<string> {

return (

(await resolveOpenClawPackageRoot({

);

}

/** Run one update subprocess and report bounded stdout/stderr tails to progress listeners. */

export async function runUpdateStep(params: {

name: string;

argv: string[];

};

}

/** Ensure the configured source-update directory exists and points at an OpenClaw checkout. */

export async function ensureGitCheckout(params: {

dir: string;

timeoutMs: number;

return null;

}

/** Detect the package manager that owns a global/package OpenClaw install. */

export async function resolveGlobalManager(params: {

root: string;

installKind: "git" | "package" | "unknown";

const COMPLETION_CACHE_MANUAL_REFRESH_HINT =

"Shell tab-completion may be stale; refresh manually with: openclaw completion --write-state";

/** Best-effort refresh of shell completion state after a successful update. */

export async function tryWriteCompletionCache(root: string, jsonMode: boolean): Promise<void> {

const binPath = path.join(root, "openclaw.mjs");

if (!(await pathExists(binPath))) {

}

}

/** Adapter used by global-install detection helpers to execute bounded subprocess probes. */

export function createGlobalCommandRunner(): CommandRunner {

return async (argv, options) => {

const res = await runCommandWithTimeout(argv, options);