@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/pm2.d.ts

@@ -8,9 +8,11 @@ export declare function formatControlUrl(host: string, port: number): string;
  * entry from scratch (delete + start) so config flags are always fresh; the
  * `force === false` path short-circuits when it's already online.
  */
-export declare function startDaemon({ force }: {
+export declare function startDaemon({ force, quiet }: {
     force: boolean;
+    quiet?: boolean;
 }): number;
+export declare function isPm2DaemonOnline(): boolean;
 /** Stop and remove the daemon from pm2's process list. */
 export declare function stopDaemon(): number;
 /** Print a one-line status; exit 0 only when online. */

package/dist/pm2.js

@@ -17,6 +17,7 @@ import { loadConfig } from "@rynx-ai/core";
 const require = createRequire(import.meta.url);
 /** pm2 app name — single resident daemon per machine. */
 const APP_NAME = "rynx";
+const PM2_COMMAND_TIMEOUT_MS = 5_000;
 /**
  * Build a dialable control-console URL from the daemon's bind host/port. Bind-all
  * addresses (`0.0.0.0`, `::`) aren't dialable, so show a loopback host instead.
@@ -57,17 +58,37 @@ function logsDir() {
     mkdirSync(dir, { recursive: true });
     return dir;
 }
+function nodeRuntimeEnv() {
+    if (!process.versions.electron) {
+        return process.env;
+    }
+    return { ...process.env, ELECTRON_RUN_AS_NODE: "1" };
+}
 /** Run a pm2 command inheriting stdio; returns its exit code. */
-function runPm2(args) {
+function runPm2(args, quiet = false) {
     const res = spawnSync(process.execPath, [pm2Bin(), ...args], {
-        stdio: "inherit",
-        env: process.env,
+        stdio: quiet ? "ignore" : "inherit",
+        env: nodeRuntimeEnv(),
+        timeout: PM2_COMMAND_TIMEOUT_MS,
+        killSignal: "SIGTERM",
     });
+    if (res.error) {
+        if (!quiet)
+            console.error(`pm2 command failed: ${pm2ErrorMessage(res.error)}`);
+        return 1;
+    }
     return res.status ?? 1;
 }
 /** Read the daemon's current pm2 record, or null if not registered. */
 function describe() {
-    const res = spawnSync(process.execPath, [pm2Bin(), "jlist"], { encoding: "utf8" });
+    const res = spawnSync(process.execPath, [pm2Bin(), "jlist"], {
+        encoding: "utf8",
+        env: nodeRuntimeEnv(),
+        timeout: PM2_COMMAND_TIMEOUT_MS,
+        killSignal: "SIGTERM",
+    });
+    if (res.error)
+        throw new Error(`pm2 query failed: ${pm2ErrorMessage(res.error)}`);
     if (res.status !== 0 || !res.stdout)
         return null;
     let list;
@@ -79,21 +100,39 @@ function describe() {
     }
     return list.find((proc) => proc.name === APP_NAME) ?? null;
 }
+function pm2ErrorMessage(error) {
+    return error.code === "ETIMEDOUT"
+        ? `timed out after ${PM2_COMMAND_TIMEOUT_MS}ms`
+        : error.message;
+}
 /**
  * Start (or, with `force`, reload) the resident daemon. We recreate the pm2
  * entry from scratch (delete + start) so config flags are always fresh; the
  * `force === false` path short-circuits when it's already online.
  */
-export function startDaemon({ force }) {
-    const existing = describe();
+export function startDaemon({ force, quiet = false }) {
+    let existing;
+    try {
+        existing = describe();
+    }
+    catch (error) {
+        if (!quiet)
+            console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
     if (!force && existing?.pm2_env?.status === "online") {
-        console.log(`rynx is already running (pid ${existing.pid ?? "?"}). Use \`rynx restart\` to reload.`);
-        console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
+        if (!quiet) {
+            console.log(`rynx is already running (pid ${existing.pid ?? "?"}). Use \`rynx restart\` to reload.`);
+            console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
+        }
         return 0;
     }
     const dir = logsDir();
-    if (existing)
-        runPm2(["delete", APP_NAME]);
+    if (existing) {
+        const removed = runPm2(["delete", APP_NAME], quiet);
+        if (removed !== 0)
+            return removed;
+    }
     const status = runPm2([
         "start",
         daemonEntryPath(),
@@ -112,13 +151,16 @@ export function startDaemon({ force }) {
         join(dir, "err.log"),
         "--merge-logs",
         "--time",
-    ]);
-    if (status === 0) {
+    ], quiet);
+    if (status === 0 && !quiet) {
         console.log(`rynx ${force ? "restarted" : "started"} (pm2 app "${APP_NAME}", logs: ${dir}).`);
         console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
     }
     return status;
 }
+export function isPm2DaemonOnline() {
+    return describe()?.pm2_env?.status === "online";
+}
 /** Stop and remove the daemon from pm2's process list. */
 export function stopDaemon() {
     if (!describe()) {
@@ -147,7 +189,7 @@ export function statusDaemon() {
 export function streamLogs() {
     const child = spawn(process.execPath, [pm2Bin(), "logs", APP_NAME, "--lines", "50"], {
         stdio: "inherit",
-        env: process.env,
+        env: nodeRuntimeEnv(),
     });
     child.on("exit", (code) => process.exit(code ?? 0));
 }

package/dist/provider-cli-service.d.ts

@@ -0,0 +1,46 @@
+import type { ProviderCliId, ProviderCliJob, ProviderCliOperation, ProviderCliStatusList } from "@rynx-ai/protocol/control";
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+interface ProviderCliServiceDeps {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    now?: () => Date;
+    run?: (executable: string, args: string[], options: {
+        timeoutMs: number;
+        env: NodeJS.ProcessEnv;
+    }) => Promise<CommandResult>;
+    resolveExecutable?: (binary: string, env: NodeJS.ProcessEnv, platform: NodeJS.Platform) => Promise<string | null>;
+    download?: (url: string, maximumBytes: number) => Promise<Uint8Array>;
+}
+export declare class ProviderCliService {
+    private readonly env;
+    private readonly platform;
+    private readonly now;
+    private readonly runCommand;
+    private readonly resolveCommand;
+    private readonly download;
+    private readonly latestCache;
+    private readonly jobs;
+    private readonly activeJobs;
+    constructor(deps?: ProviderCliServiceDeps);
+    listStatuses(): Promise<ProviderCliStatusList>;
+    startOperation(provider: ProviderCliId, operation: ProviderCliOperation): Promise<ProviderCliJob>;
+    getJob(id: string): ProviderCliJob | undefined;
+    private inspect;
+    private resolveProviderExecutable;
+    private authStatus;
+    private latestVersion;
+    private execute;
+    private install;
+    private update;
+    private installTraex;
+    private pruneJobs;
+}
+export declare class ProviderCliOperationError extends Error {
+    readonly code: "failed_precondition";
+    constructor(code: "failed_precondition", message: string);
+}
+export {};

package/dist/provider-cli-service.js

@@ -0,0 +1,510 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import { access, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { spawn } from "node:child_process";
+import { getRuntimeProfile } from "@rynx-ai/core";
+const STATUS_COMMAND_TIMEOUT_MS = 8_000;
+const OPERATION_TIMEOUT_MS = 10 * 60_000;
+const COMMAND_TERMINATION_GRACE_MS = 2_000;
+const OUTPUT_MAX_BYTES = 16 * 1024;
+const LATEST_CACHE_MS = 15 * 60_000;
+const TRAEX_INSTALLER_MAX_BYTES = 2 * 1024 * 1024;
+const TRAEX_INSTALLER_URL = "https://tosv-myabc.byted.org/obj/trae-common-2-asiasebd/traex/install/install_all_platforms.sh";
+const PROVIDER_PACKAGES = {
+    codex: "@openai/codex",
+    claude: "@anthropic-ai/claude-code",
+};
+const PROVIDER_CLI_IDS = ["codex", "claude", "traex"];
+export class ProviderCliService {
+    env;
+    platform;
+    now;
+    runCommand;
+    resolveCommand;
+    download;
+    latestCache = new Map();
+    jobs = new Map();
+    activeJobs = new Map();
+    constructor(deps = {}) {
+        this.env = { ...process.env, ...deps.env };
+        this.platform = deps.platform ?? process.platform;
+        this.now = deps.now ?? (() => new Date());
+        this.runCommand = deps.run ?? runCommand;
+        this.resolveCommand = deps.resolveExecutable ?? resolveExecutable;
+        this.download = deps.download ?? downloadBounded;
+    }
+    async listStatuses() {
+        const providerClis = await Promise.all(PROVIDER_CLI_IDS.map((id) => this.inspect(id)));
+        return { providerClis };
+    }
+    async startOperation(provider, operation) {
+        const activeId = this.activeJobs.get(provider);
+        if (activeId) {
+            const active = this.jobs.get(activeId);
+            if (active?.state === "running") {
+                if (active.operation === operation)
+                    return { ...active };
+                throw new ProviderCliOperationError("failed_precondition", `${provider} already has a ${active.operation} operation in progress`);
+            }
+        }
+        const status = await this.inspect(provider, operation === "update");
+        if (operation === "install" && status.availability === "installed") {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} is already installed`);
+        }
+        if (operation === "update" && status.availability !== "installed") {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} is not installed`);
+        }
+        if (operation === "install" && !status.canInstall) {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} cannot be installed automatically on this machine`);
+        }
+        if (operation === "update" && !status.canUpdate) {
+            throw new ProviderCliOperationError("failed_precondition", `${status.name} cannot be updated automatically on this machine`);
+        }
+        const job = {
+            id: randomUUID(),
+            provider,
+            operation,
+            state: "running",
+            stage: "starting",
+            startedAt: this.now().toISOString(),
+        };
+        this.jobs.set(job.id, job);
+        this.activeJobs.set(provider, job.id);
+        this.pruneJobs();
+        void this.execute(job.id, status).catch(() => undefined);
+        return { ...job };
+    }
+    getJob(id) {
+        const job = this.jobs.get(id);
+        return job ? { ...job } : undefined;
+    }
+    async inspect(provider, includeLatest = true) {
+        const profile = getRuntimeProfile(provider);
+        const checkedAt = this.now().toISOString();
+        const executablePath = await this.resolveProviderExecutable(provider);
+        const npmPath = provider === "traex"
+            ? null
+            : await this.resolveCommand("npm", this.env, this.platform);
+        const canInstall = provider === "traex"
+            ? this.platform !== "win32"
+            : npmPath !== null && this.platform !== "win32";
+        if (!executablePath) {
+            const latestVersion = includeLatest
+                ? await this.latestVersion(provider, undefined, npmPath)
+                : undefined;
+            return {
+                id: provider,
+                name: profile.displayName,
+                binary: profile.defaultBinary,
+                availability: "missing",
+                ...(latestVersion ? { latestVersion } : {}),
+                updateState: "unknown",
+                authState: "unknown",
+                canInstall,
+                canUpdate: false,
+                checkedAt,
+            };
+        }
+        let currentVersion;
+        let versionError;
+        try {
+            const result = await this.runCommand(executablePath, ["--version"], {
+                timeoutMs: STATUS_COMMAND_TIMEOUT_MS,
+                env: this.env,
+            });
+            if (result.exitCode !== 0)
+                throw new Error(commandFailure(result));
+            currentVersion = extractVersion(`${result.stdout}\n${result.stderr}`);
+            if (!currentVersion)
+                throw new Error("version output was not recognized");
+        }
+        catch (error) {
+            versionError = errorMessage(error);
+        }
+        const [auth, latestVersion] = await Promise.all([
+            currentVersion
+                ? this.authStatus(provider, executablePath)
+                : Promise.resolve({ state: "unknown" }),
+            includeLatest
+                ? this.latestVersion(provider, executablePath, npmPath)
+                : Promise.resolve(undefined),
+        ]);
+        const updateState = currentVersion && latestVersion
+            ? (compareVersions(currentVersion, latestVersion) < 0 ? "available" : "current")
+            : "unknown";
+        return {
+            id: provider,
+            name: profile.displayName,
+            binary: profile.defaultBinary,
+            executablePath,
+            availability: currentVersion ? "installed" : "broken",
+            ...(currentVersion ? { currentVersion } : {}),
+            ...(latestVersion ? { latestVersion } : {}),
+            updateState,
+            authState: auth.state,
+            ...(auth.mode ? { authMode: auth.mode } : {}),
+            canInstall: !currentVersion && canInstall,
+            canUpdate: Boolean(currentVersion) && this.platform !== "win32",
+            checkedAt,
+            ...(versionError ? { error: versionError } : {}),
+        };
+    }
+    async resolveProviderExecutable(provider) {
+        const candidates = provider === "traex" ? ["traex", "traecli"] : [provider];
+        for (const candidate of candidates) {
+            const resolved = await this.resolveCommand(candidate, this.env, this.platform);
+            if (resolved)
+                return resolved;
+        }
+        return null;
+    }
+    async authStatus(provider, executablePath) {
+        try {
+            const args = provider === "claude" ? ["auth", "status", "--json"] : ["login", "status"];
+            const result = await this.runCommand(executablePath, args, {
+                timeoutMs: STATUS_COMMAND_TIMEOUT_MS,
+                env: this.env,
+            });
+            const output = `${result.stdout}\n${result.stderr}`.trim();
+            if (provider === "claude") {
+                const parsed = JSON.parse(output);
+                if (parsed.loggedIn === true) {
+                    const mode = [parsed.authMethod, parsed.apiProvider]
+                        .filter((value) => typeof value === "string" && value.length > 0)
+                        .join(" · ");
+                    return { state: "ready", ...(mode ? { mode } : {}) };
+                }
+                if (parsed.loggedIn === false)
+                    return { state: "required" };
+                return { state: "unknown" };
+            }
+            if (result.exitCode === 0 && /logged in/i.test(output)) {
+                const match = /logged in(?: using| as)?\s+(.+)/i.exec(output);
+                return { state: "ready", ...(match?.[1]?.trim() ? { mode: match[1].trim() } : {}) };
+            }
+            if (/not logged in|logged out|login required/i.test(output))
+                return { state: "required" };
+            return { state: result.exitCode === 0 ? "unknown" : "required" };
+        }
+        catch {
+            return { state: "unknown" };
+        }
+    }
+    async latestVersion(provider, executablePath, npmPath) {
+        const now = this.now().getTime();
+        const cached = this.latestCache.get(provider);
+        if (cached && cached.expiresAt > now)
+            return cached.value;
+        let value;
+        try {
+            if (provider === "traex") {
+                if (!executablePath)
+                    return undefined;
+                const result = await this.runCommand(executablePath, ["update", "check"], {
+                    timeoutMs: STATUS_COMMAND_TIMEOUT_MS,
+                    env: this.env,
+                });
+                if (result.exitCode === 0) {
+                    value = /Latest TRAE CLI version:\s*([^\s]+)/i.exec(`${result.stdout}\n${result.stderr}`)?.[1];
+                }
+            }
+            else if (npmPath) {
+                const packageName = PROVIDER_PACKAGES[provider];
+                const result = await this.runCommand(npmPath, ["view", `${packageName}@latest`, "version", "--json"], { timeoutMs: STATUS_COMMAND_TIMEOUT_MS, env: this.env });
+                if (result.exitCode === 0)
+                    value = extractVersion(result.stdout);
+            }
+        }
+        catch {
+            value = undefined;
+        }
+        this.latestCache.set(provider, { value, expiresAt: now + LATEST_CACHE_MS });
+        return value;
+    }
+    async execute(jobId, previousStatus) {
+        const job = this.jobs.get(jobId);
+        if (!job)
+            return;
+        try {
+            job.stage = job.operation === "install" ? "installing" : "updating";
+            if (job.operation === "install") {
+                await this.install(job.provider);
+            }
+            else {
+                await this.update(job.provider, previousStatus.executablePath);
+            }
+            job.stage = "verifying";
+            this.latestCache.delete(job.provider);
+            const verified = await this.inspect(job.provider, false);
+            if (verified.availability !== "installed") {
+                throw new Error(verified.error ?? `${verified.name} was not found on the daemon PATH after the operation`);
+            }
+            if (job.operation === "update") {
+                const previousVersion = previousStatus.currentVersion;
+                const verifiedVersion = verified.currentVersion;
+                if (!previousVersion || !verifiedVersion || compareVersions(verifiedVersion, previousVersion) <= 0) {
+                    throw new Error(`${verified.name} reported success but its version did not change`);
+                }
+                if (previousStatus.latestVersion
+                    && compareVersions(verifiedVersion, previousStatus.latestVersion) < 0) {
+                    throw new Error(`${verified.name} updated to ${verifiedVersion}, below the expected ${previousStatus.latestVersion}`);
+                }
+            }
+            job.stage = "complete";
+            job.state = "succeeded";
+            job.finishedAt = this.now().toISOString();
+        }
+        catch (error) {
+            job.state = "failed";
+            job.finishedAt = this.now().toISOString();
+            job.error = boundError(errorMessage(error));
+        }
+        finally {
+            if (this.activeJobs.get(job.provider) === job.id)
+                this.activeJobs.delete(job.provider);
+        }
+    }
+    async install(provider) {
+        if (provider === "traex") {
+            await this.installTraex();
+            return;
+        }
+        const npmPath = await this.resolveCommand("npm", this.env, this.platform);
+        if (!npmPath)
+            throw new Error("npm is not available on PATH");
+        const result = await this.runCommand(npmPath, ["install", "--global", `${PROVIDER_PACKAGES[provider]}@latest`, "--no-audit", "--no-fund"], { timeoutMs: OPERATION_TIMEOUT_MS, env: this.env });
+        if (result.exitCode !== 0)
+            throw new Error(commandFailure(result));
+    }
+    async update(provider, executablePath) {
+        const result = await this.runCommand(executablePath, ["update"], {
+            timeoutMs: OPERATION_TIMEOUT_MS,
+            env: this.env,
+        });
+        if (result.exitCode !== 0)
+            throw new Error(commandFailure(result));
+    }
+    async installTraex() {
+        if (this.platform === "win32")
+            throw new Error("automatic Traex installation is not supported on Windows");
+        const script = await this.download(TRAEX_INSTALLER_URL, TRAEX_INSTALLER_MAX_BYTES);
+        const directory = await mkdtemp(join(tmpdir(), "rynx-traex-install-"));
+        const scriptPath = join(directory, "install.sh");
+        try {
+            await writeFile(scriptPath, script, { mode: 0o700 });
+            const shPath = await this.resolveCommand("sh", this.env, this.platform);
+            if (!shPath)
+                throw new Error("sh is not available on PATH");
+            const result = await this.runCommand(shPath, [scriptPath], {
+                timeoutMs: OPERATION_TIMEOUT_MS,
+                env: installerEnvironment(this.env, {
+                    TRAEX_INSTALL_ASSUME_YES: "1",
+                    TRAEX_INSTALL_MIGRATE_BREW: "0",
+                    TRAEX_INSTALL_REMOVE_BREW: "0",
+                    TRAEX_INSTALL_CHANNEL: "stable",
+                }),
+            });
+            if (result.exitCode !== 0)
+                throw new Error(commandFailure(result));
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+    pruneJobs() {
+        if (this.jobs.size <= 50)
+            return;
+        const finished = [...this.jobs.values()]
+            .filter((job) => job.state !== "running")
+            .sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+        for (const job of finished.slice(0, this.jobs.size - 50))
+            this.jobs.delete(job.id);
+    }
+}
+export class ProviderCliOperationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ProviderCliOperationError";
+    }
+}
+async function resolveExecutable(binary, env, platform) {
+    const pathValue = env.PATH ?? env.Path ?? env.path ?? "";
+    const extensions = platform === "win32"
+        ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")
+        : [""];
+    for (const directory of pathValue.split(delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = join(directory, platform === "win32" ? `${binary}${extension}` : binary);
+            try {
+                await access(candidate, fsConstants.X_OK);
+                return candidate;
+            }
+            catch {
+                // Continue through the daemon's effective PATH.
+            }
+        }
+    }
+    return null;
+}
+function runCommand(executable, args, options) {
+    return new Promise((resolve, reject) => {
+        const detached = process.platform !== "win32";
+        const child = spawn(executable, args, {
+            env: options.env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            detached,
+        });
+        let timedOut = false;
+        let settled = false;
+        let forceTimer;
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        const append = (current, chunk) => Buffer.concat([current, chunk]).subarray(0, OUTPUT_MAX_BYTES);
+        child.stdout.on("data", (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr.on("data", (chunk) => { stderr = append(stderr, chunk); });
+        const clearTimers = () => {
+            clearTimeout(timer);
+            if (forceTimer)
+                clearTimeout(forceTimer);
+        };
+        const rejectOnce = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            reject(error);
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            terminateCommand(child.pid, child, "SIGTERM", detached);
+            forceTimer = setTimeout(() => {
+                terminateCommand(child.pid, child, "SIGKILL", detached);
+                rejectOnce(new Error(`command timed out after ${options.timeoutMs}ms`));
+            }, COMMAND_TERMINATION_GRACE_MS);
+            forceTimer.unref();
+        }, options.timeoutMs);
+        timer.unref();
+        child.once("error", (error) => {
+            if (!timedOut)
+                rejectOnce(error);
+        });
+        child.once("close", (code) => {
+            if (settled || timedOut)
+                return;
+            settled = true;
+            clearTimers();
+            resolve({
+                exitCode: code ?? -1,
+                stdout: stdout.toString("utf8"),
+                stderr: stderr.toString("utf8"),
+            });
+        });
+    });
+}
+async function downloadBounded(url, maximumBytes) {
+    const requestedUrl = new URL(url);
+    if (requestedUrl.protocol !== "https:")
+        throw new Error("installer URL must use HTTPS");
+    const response = await fetch(url, { redirect: "follow" });
+    if (!response.ok)
+        throw new Error(`installer download failed with HTTP ${response.status}`);
+    const finalUrl = new URL(response.url || url);
+    if (finalUrl.protocol !== "https:" || finalUrl.origin !== requestedUrl.origin) {
+        throw new Error("installer download redirected outside the trusted origin");
+    }
+    const expectedMd5 = response.headers.get("content-md5");
+    if (!expectedMd5)
+        throw new Error("installer response did not include integrity metadata");
+    const declaredLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+    if (Number.isFinite(declaredLength) && declaredLength > maximumBytes) {
+        throw new Error("installer download exceeded the accepted size");
+    }
+    if (!response.body)
+        throw new Error("installer download returned an empty response");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        length += value.byteLength;
+        if (length > maximumBytes) {
+            await reader.cancel();
+            throw new Error("installer download exceeded the accepted size");
+        }
+        chunks.push(value);
+    }
+    if (length === 0)
+        throw new Error("installer download returned an empty response");
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    const actualMd5 = createHash("md5").update(bytes).digest("base64");
+    if (actualMd5 !== expectedMd5)
+        throw new Error("installer response failed its integrity check");
+    return bytes;
+}
+function terminateCommand(pid, child, signal, detached) {
+    try {
+        if (detached && pid)
+            process.kill(-pid, signal);
+        else
+            child.kill(signal);
+    }
+    catch {
+        // The process may have exited between the timeout and signal delivery.
+    }
+}
+function installerEnvironment(env, additions) {
+    const allowed = [
+        "PATH", "HOME", "USER", "SHELL", "TMPDIR",
+        "LANG", "LC_ALL",
+        "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME",
+        "HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY",
+        "http_proxy", "https_proxy", "no_proxy",
+        "SSL_CERT_FILE", "SSL_CERT_DIR",
+    ];
+    const result = { ...additions };
+    for (const key of allowed) {
+        if (env[key] !== undefined)
+            result[key] = env[key];
+    }
+    return result;
+}
+function extractVersion(output) {
+    return /\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/.exec(output)?.[0];
+}
+function compareVersions(left, right) {
+    const a = left.split(/[.+-]/).slice(0, 3).map((value) => Number.parseInt(value, 10));
+    const b = right.split(/[.+-]/).slice(0, 3).map((value) => Number.parseInt(value, 10));
+    for (let index = 0; index < 3; index += 1) {
+        const delta = (a[index] ?? 0) - (b[index] ?? 0);
+        if (delta !== 0)
+            return delta;
+    }
+    const leftPrerelease = left.includes("-");
+    const rightPrerelease = right.includes("-");
+    if (leftPrerelease !== rightPrerelease)
+        return leftPrerelease ? -1 : 1;
+    return left.localeCompare(right);
+}
+function commandFailure(result) {
+    return boundError(result.stderr.trim() || result.stdout.trim() || `command exited ${result.exitCode}`);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function boundError(message) {
+    return message.replace(/[\u0000-\u001f\u007f]+/g, " ").trim().slice(0, 1024) || "operation failed";
+}