@noimosai/platform-mcp 0.1.2 → 0.1.4

package/dist/cli/update-bootstrap.js

@@ -0,0 +1,437 @@
+import { spawn } from "node:child_process";
+import { constants as osConstants, homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { realpath, unlink } from "node:fs/promises";
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import { localProfilePath, profileDirectory, readLocalProfile, readPrivateJson, writePrivateJson } from "../client/local-profile.js";
+import { executable, managedCliChildEnv as childMarker, probeMcp } from "./local-agents.js";
+import { mcpWorkerEnv, superviseMcp } from "./mcp-supervisor.js";
+import { withProfileLock } from "./setup-lock.js";
+import { compareCliVersions, confirmCliRelease, confirmReleaseManifest, fetchCliRelease, ReleaseManifestError, releaseCooldownMs, validCliVersion, verifyCliTarball } from "./update-release.js";
+const targetSchema = z.object({ version: z.string().refine(validCliVersion), integrity: z.string().regex(/^sha512-[A-Za-z0-9+/]{86}==$/).optional(), verifiedProjectId: z.string().min(1).optional() }).strict();
+const pendingSchema = targetSchema.extend({ verifiedProjectId: z.string().min(1), source: z.enum(["auto", "manual"]) }).strict();
+const stateSchema = z.object({
+    managedBy: z.literal("relvo-cli"), protocol: z.literal(1), installationId: z.string().regex(/^[a-f0-9]{24}$/),
+    auto: z.boolean(), checkedAt: z.number().int().nonnegative(), active: targetSchema,
+    previous: targetSchema.optional(), pending: pendingSchema.optional(), pin: z.string().refine(validCliVersion).optional(),
+    quarantined: z.string().refine(validCliVersion).optional(),
+}).strict();
+const availableSchema = z.object({ version: z.string().refine(validCliVersion), announcedAt: z.number().int().nonnegative() }).strict();
+const day = 24 * 60 * 60 * 1000;
+const updateHelp = "Use relvo update [status|auto on|auto off|pin <exact-version>|rollback].";
+function launchArgs(version, args) {
+    return ["--yes", "--ignore-scripts", "--registry=https://registry.npmjs.org", "--@relvo:registry=https://registry.npmjs.org", `--package=@relvo/cli@${version}`, "relvo", ...args];
+}
+function ready(profile, now) {
+    return profile?.state === "ready" && !profile.pendingAck && Date.parse(profile.grant.expiresAt) > now;
+}
+async function readState(path, installationId) {
+    try {
+        const state = stateSchema.parse(await readPrivateJson(path));
+        if (state.installationId !== installationId)
+            throw new Error("Different installation");
+        return state;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw new Error("Relvo update state is unsafe or belongs to another installation. It was preserved.");
+    }
+}
+const availablePath = (statePath) => join(dirname(statePath), "update-available.json");
+async function readAvailable(path) {
+    try {
+        return availableSchema.parse(await readPrivateJson(path));
+    }
+    catch {
+        return null;
+    }
+}
+async function noteAvailable(path, state, profile, options, now, signal) {
+    try {
+        const release = await fetchCliRelease("latest", options.registryFetch, signal, { now, cooldownMs: 0 });
+        if (!release || compareCliVersions(release.version, state.active.version) <= 0 || release.version === state.quarantined)
+            return;
+        await confirmReleaseManifest(release, profile.consoleUrl, profile.local, options.manifestFetch, signal);
+        if ((await readAvailable(path))?.version !== release.version)
+            await writePrivateJson(path, { version: release.version, announcedAt: 0 });
+    }
+    catch { }
+}
+async function announceAvailable(path, active, quarantined, now, error) {
+    const available = await readAvailable(path);
+    if (!available || available.version === quarantined || compareCliVersions(available.version, active) <= 0 || now - available.announcedAt < day)
+        return;
+    error(`Relvo ${available.version} is available; this installation uses ${active}. To install it, run relvo update.`);
+    await writePrivateJson(path, { ...available, announcedAt: now }).catch(() => { });
+}
+export async function removeOwnedUpdateState(profilePath, installationId) {
+    const path = join(dirname(localProfilePath(dirname(dirname(dirname(profilePath))))), "updates.json");
+    try {
+        await profileDirectory(profilePath);
+        await profileDirectory(localProfilePath(dirname(dirname(dirname(profilePath)))));
+        const state = await readState(path, installationId);
+        if (!state)
+            return "missing";
+        await unlink(path);
+        await unlink(availablePath(path)).catch(() => { });
+        return "removed";
+    }
+    catch {
+        return "preserved";
+    }
+}
+function freshState(version, installationId) {
+    return { managedBy: "relvo-cli", protocol: 1, installationId, auto: true, checkedAt: 0, active: { version } };
+}
+function status(version, state, loggedIn, disabled) {
+    return { protocol: 1, bootstrapVersion: version, installation: loggedIn ? "ready" : "not-ready", autoUpdate: loggedIn && (state?.auto ?? true) && !disabled && !state?.pin,
+        activeVersion: state?.active.version ?? version, pendingVersion: state?.pending?.version ?? null, previousVersion: state?.previous?.version ?? null, pinnedVersion: state?.pin ?? null,
+        quarantinedVersion: state?.quarantined ?? null };
+}
+async function diagnose(target, profile, path, env, home, launcher, signal) {
+    const registration = { client: "codex", name: `relvo-${profile.installationId}`, command: launcher, args: launchArgs(target.version, ["mcp", "--profile", path]) };
+    await probeMcp(registration, { ...env, [childMarker]: "1" }, home, profile.grant.developerProjectId, signal);
+}
+async function delegate(launcher, version, args, env, home, error) {
+    return new Promise((resolve) => {
+        const child = spawn(launcher, launchArgs(version, args), { env: { ...env, HOME: home, [childMarker]: "1" }, stdio: "inherit" });
+        const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+        const forward = signals.map((signal) => { const listener = () => { child.kill(signal); }; process.on(signal, listener); return { signal, listener }; });
+        let settled = false;
+        const finish = (code) => { if (settled)
+            return; settled = true; for (const { signal, listener } of forward)
+            process.removeListener(signal, listener); resolve(code); };
+        child.once("error", () => { error("Relvo could not start the selected version. The command was not replayed; inspect its result before retrying."); finish(1); });
+        child.once("close", (code, signal) => finish(code ?? (signal ? 128 + (osConstants.signals[signal] ?? 0) : 1)));
+    });
+}
+async function selectedMcpVersion(profilePath, statePath, now) {
+    const profile = await readLocalProfile(profilePath);
+    if (!ready(profile, now))
+        return null;
+    const state = await readState(statePath, profile.installationId);
+    return state?.pending?.verifiedProjectId === profile.grant.developerProjectId ? state.pending.version : state?.active.version ?? null;
+}
+async function superviseManagedMcp(args, env, entry, options) {
+    const home = await realpath(options.home ?? homedir()), canonical = localProfilePath(home), statePath = join(dirname(canonical), "updates.json");
+    const { [childMarker]: _marker, ...plain } = env, shutdown = new AbortController();
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"], stop = () => { shutdown.abort(); };
+    for (const signal of signals)
+        process.once(signal, stop);
+    process.stdout.on("error", stop);
+    const start = (replacing) => {
+        const child = spawn(process.execPath, [entry, ...args], { env: { ...plain, HOME: home, [mcpWorkerEnv]: "1", ...(replacing ? {} : { [childMarker]: "1" }) }, stdio: ["pipe", "pipe", "inherit"] });
+        child.stdin.on("error", () => { });
+        return { stdin: child.stdin, stdout: child.stdout, kill: () => { child.kill(); }, exited: new Promise(settle => {
+                child.once("error", () => { settle(1); });
+                child.once("close", (code, signal) => { settle(code ?? (signal ? 128 + (osConstants.signals[signal] ?? 0) : 1)); });
+            }) };
+    };
+    try {
+        return await superviseMcp({ input: process.stdin, output: process.stdout, start, version: options.version, stop: shutdown.signal, target: () => selectedMcpVersion(canonical, statePath, (options.now ?? Date.now)()) });
+    }
+    finally {
+        for (const signal of signals)
+            process.removeListener(signal, stop);
+    }
+}
+export async function runManagedEntry(args, env, output, error, serve, options) {
+    const help = args.some((arg) => ["help", "--help", "-h"].includes(arg)), entry = options.backgroundEntryPoint;
+    const runCurrent = args[0] === "mcp" && !help && entry && env[mcpWorkerEnv] !== "1" && env.RELVO_AUTO_UPDATE !== "0" ? () => superviseManagedMcp(args, env, entry, options) : serve;
+    if (env[childMarker] === "1" || !args.length || help)
+        return runCurrent();
+    if (options.updateWorker && (args.length !== 1 || args[0] !== "--relvo-update-worker"))
+        return 1;
+    const explicit = args[0] === "update", disabled = env.RELVO_AUTO_UPDATE === "0", now = options.now ?? Date.now;
+    const mcp = args[0] === "mcp", shutdown = new AbortController();
+    const endSession = () => shutdown.abort();
+    const sessionSignal = options.sessionSignal ? AbortSignal.any([shutdown.signal, options.sessionSignal]) : shutdown.signal;
+    const updateSignal = mcp ? sessionSignal : options.updateWorker ? AbortSignal.timeout(60_000) : undefined;
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    let command;
+    let runRetained = runCurrent;
+    if (mcp) {
+        process.stdin.once("end", endSession);
+        process.stdin.once("close", endSession);
+        for (const signal of signals)
+            process.once(signal, endSession);
+    }
+    let selected;
+    try {
+        if (!validCliVersion(options.version))
+            throw new Error("The bundled Relvo version is invalid.");
+        const home = await realpath(options.home ?? homedir()), canonical = localProfilePath(home);
+        let profilePath = canonical;
+        if (args[0] === "mcp") {
+            const { values, tokens } = parseArgs({ args: args.slice(1), tokens: true, options: { profile: { type: "string" } } });
+            if (tokens.filter((token) => token.kind === "option").length !== 1 || !values.profile)
+                throw new Error("Exactly one managed profile must be selected.");
+            if (values.profile !== canonical)
+                throw new Error("Automatic updates require the canonical managed Relvo profile.");
+            profilePath = values.profile;
+        }
+        const maintenance = args[0] === "doctor" || args[0] === "logout";
+        const profile = await readLocalProfile(profilePath), usable = ready(profile, now());
+        const statePath = join(dirname(canonical), "updates.json");
+        const state = profile ? await readState(statePath, profile.installationId) : null;
+        const retained = state?.active;
+        if (!options.updateWorker && retained && retained.version !== options.version)
+            runRetained = async () => {
+                let launcher;
+                try {
+                    launcher = options.launcher ?? await executable("npx", env);
+                }
+                catch {
+                    error("Relvo could not locate the launcher for its selected version. The command was not replayed.");
+                    return 1;
+                }
+                return delegate(launcher, retained.version, args, env, home, error);
+            };
+        if (["--version", "-v"].includes(args[0]) && args.length === 1) {
+            output(state?.active.version ?? options.version);
+            return 0;
+        }
+        if (explicit && args[1] === "status" && args.length === 2) {
+            output(JSON.stringify(status(options.version, state, usable, disabled), null, 2));
+            return 0;
+        }
+        if (maintenance) {
+            if (state?.active.version && state.active.version !== options.version)
+                return delegate(options.launcher ?? await executable("npx", env), state.active.version, args, env, home, error);
+            return runCurrent();
+        }
+        if (!usable) {
+            if (options.updateWorker)
+                return 0;
+            if (explicit)
+                throw new Error("Run relvo setup to complete a current login before changing updates.");
+            if (state?.active.version && state.active.version !== options.version)
+                return delegate(options.launcher ?? await executable("npx", env), state.active.version, args, env, home, error);
+            return runCurrent();
+        }
+        if (explicit && !(args.length === 1 || args.length === 3 && args[1] === "auto" && ["on", "off"].includes(args[2]) || args.length === 3 && args[1] === "pin" && validCliVersion(args[2]) || args.length === 2 && args[1] === "rollback"))
+            throw new Error(updateHelp);
+        const backgroundEntryPoint = options.backgroundEntryPoint;
+        if (!explicit && !mcp && !options.updateWorker && backgroundEntryPoint && !disabled && (state?.auto ?? true) && !state?.pin && !state?.pending) {
+            if (now() - (state?.checkedAt ?? 0) >= day) {
+                try {
+                    await withProfileLock(canonical, async () => {
+                        const current = await readLocalProfile(canonical), saved = await readState(statePath, profile.installationId) ?? freshState(options.version, profile.installationId);
+                        if (!ready(current, now()) || current.installationId !== profile.installationId || !saved.auto || saved.pin || saved.pending || now() - saved.checkedAt < day)
+                            return;
+                        saved.checkedAt = now();
+                        await writePrivateJson(statePath, stateSchema.parse(saved));
+                        const child = spawn(process.execPath, [backgroundEntryPoint, "--relvo-update-worker"], { env: { ...env, HOME: home }, detached: true, stdio: "ignore" });
+                        child.once("error", () => { });
+                        child.unref();
+                    });
+                }
+                catch { }
+            }
+            await announceAvailable(availablePath(statePath), retained?.version ?? options.version, state?.quarantined, now(), error);
+            return runRetained();
+        }
+        await profileDirectory(canonical);
+        await withProfileLock(canonical, async () => {
+            const currentProfile = await readLocalProfile(profilePath);
+            if (!ready(currentProfile, now()) || currentProfile.installationId !== profile.installationId)
+                throw new Error("Relvo login changed before update verification. Rerun the command.");
+            const saved = await readState(statePath, profile.installationId) ?? freshState(options.version, profile.installationId);
+            if (options.updateWorker && (disabled || !saved.auto || saved.pin || saved.pending?.source === "manual"))
+                return;
+            const save = () => writePrivateJson(statePath, stateSchema.parse(saved));
+            const launcher = async () => options.launcher ?? executable("npx", env);
+            const stillPublished = async (target) => {
+                if (!target.integrity)
+                    return true;
+                try {
+                    return await confirmCliRelease({ version: target.version, integrity: target.integrity }, options.registryFetch, updateSignal);
+                }
+                catch {
+                    return undefined;
+                }
+            };
+            const startCommand = () => {
+                if (command)
+                    return;
+                if (selected && selected.version !== options.version) {
+                    command = launcher().then((path) => delegate(path, selected.version, args, env, home, error));
+                    if (mcp)
+                        void command.then(endSession, endSession);
+                }
+                else
+                    command = runCurrent();
+            };
+            if (explicit && args[1] === "auto") {
+                saved.auto = args[2] === "on";
+                if (saved.auto) {
+                    delete saved.pin;
+                    saved.checkedAt = 0;
+                }
+                else if (saved.pending?.source === "auto")
+                    delete saved.pending;
+                await save();
+                output(`Relvo automatic updates ${saved.auto ? "enabled" : "disabled"}. Changes apply on the next start.`);
+                return;
+            }
+            if (explicit && args[1] === "rollback") {
+                if (!saved.previous)
+                    throw new Error("No previously verified Relvo version is available.");
+                await diagnose(saved.previous, currentProfile, profilePath, env, home, await launcher());
+                saved.pending = { ...saved.previous, verifiedProjectId: currentProfile.grant.developerProjectId, source: "manual" };
+                saved.auto = false;
+                delete saved.pin;
+                await save();
+                output(`Relvo ${saved.pending.version} is staged for the next start. Automatic updates are disabled.`);
+                return;
+            }
+            if (!explicit && !disabled && saved.pending && (!mcp || saved.pending.verifiedProjectId === currentProfile.grant.developerProjectId)) {
+                const candidate = saved.pending, published = await stillPublished(candidate);
+                if (published === undefined)
+                    error("Relvo could not re-check the staged version with the npm registry. It stays staged and the current version is retained.");
+                else {
+                    try {
+                        if (!published)
+                            throw new Error("The registry no longer publishes the verified bytes.");
+                        if (!mcp)
+                            await diagnose(candidate, currentProfile, profilePath, env, home, await launcher(), updateSignal);
+                        const { source, ...target } = candidate;
+                        void source;
+                        saved.previous = saved.active;
+                        saved.active = target;
+                        delete saved.pending;
+                        delete saved.quarantined;
+                    }
+                    catch {
+                        saved.quarantined = candidate.version;
+                        delete saved.pending;
+                        saved.checkedAt = now();
+                        if (saved.pin === saved.quarantined)
+                            delete saved.pin;
+                        error("The staged Relvo version failed its read-only check. The previously verified version is retained.");
+                    }
+                    await save();
+                }
+            }
+            selected = saved.active;
+            if (mcp)
+                startCommand();
+            if (mcp && saved.pending && !disabled) {
+                const published = await stillPublished(saved.pending);
+                if (published === undefined)
+                    return;
+                try {
+                    if (!published)
+                        throw new Error("The registry no longer publishes the verified bytes.");
+                    await diagnose(saved.pending, currentProfile, profilePath, env, home, await launcher(), sessionSignal);
+                    sessionSignal.throwIfAborted();
+                    saved.pending.verifiedProjectId = currentProfile.grant.developerProjectId;
+                    await save();
+                }
+                catch {
+                    if (!sessionSignal.aborted) {
+                        saved.quarantined = saved.pending.version;
+                        delete saved.pending;
+                        saved.checkedAt = now();
+                        if (saved.pin === saved.quarantined)
+                            delete saved.pin;
+                        await save();
+                        error("Relvo's staged update could not be verified for the current project. The active version was retained.");
+                    }
+                }
+                return;
+            }
+            const pinned = explicit && args[1] === "pin" ? args[2] : undefined;
+            const check = explicit || options.updateWorker || !disabled && saved.auto && !saved.pin && now() - saved.checkedAt >= day;
+            if (!check && !disabled && !mcp && now() - saved.checkedAt >= day) {
+                saved.checkedAt = now();
+                await save();
+                try {
+                    const release = await fetchCliRelease("latest", options.registryFetch, undefined, { now: now(), cooldownMs: 0 });
+                    if (!release || compareCliVersions(release.version, saved.active.version) <= 0 || release.version === saved.quarantined)
+                        return;
+                    await confirmReleaseManifest(release, currentProfile.consoleUrl, currentProfile.local, options.manifestFetch);
+                    error(`Relvo ${release.version} is available; this installation uses ${saved.active.version}. To install it, run relvo update${saved.pin ? ` pin ${release.version}` : ""}.`);
+                }
+                catch { }
+                return;
+            }
+            if (!check)
+                return;
+            saved.checkedAt = now();
+            await save();
+            if (options.updateWorker)
+                await noteAvailable(availablePath(statePath), saved, currentProfile, options, now(), updateSignal);
+            try {
+                const release = await fetchCliRelease(pinned ?? "latest", options.registryFetch, updateSignal, { now: now(), cooldownMs: explicit ? 0 : releaseCooldownMs });
+                if (!release || !pinned && compareCliVersions(release.version, saved.active.version) <= 0) {
+                    if (explicit)
+                        output("Relvo is already using the newest release.");
+                    return;
+                }
+                await confirmReleaseManifest(release, currentProfile.consoleUrl, currentProfile.local, options.manifestFetch, updateSignal);
+                await verifyCliTarball(release, options.registryFetch, updateSignal);
+                await diagnose(release, currentProfile, profilePath, env, home, await launcher(), updateSignal);
+                if (mcp)
+                    sessionSignal.throwIfAborted();
+                if (options.updateWorker) {
+                    if (!await confirmCliRelease(release, options.registryFetch, updateSignal))
+                        throw new Error("The registry no longer publishes the verified bytes.");
+                    saved.previous = saved.active;
+                    saved.active = { ...release, verifiedProjectId: currentProfile.grant.developerProjectId };
+                    delete saved.pending;
+                }
+                else
+                    saved.pending = { ...release, verifiedProjectId: currentProfile.grant.developerProjectId, source: explicit ? "manual" : "auto" };
+                delete saved.quarantined;
+                if (pinned) {
+                    saved.pin = pinned;
+                    saved.auto = false;
+                }
+                await save();
+                const message = `Relvo ${release.version} passed its read-only check and is staged for the next start. The current command keeps its selected version.`;
+                (explicit ? output : error)(message);
+            }
+            catch (failure) {
+                const refusal = failure instanceof ReleaseManifestError ? failure.message : undefined;
+                if (explicit)
+                    throw new Error(`${refusal ?? "Relvo update could not be verified."} The active version and login were preserved${refusal ? "." : "; rerun relvo update later."}`);
+                if (!mcp || !sessionSignal.aborted)
+                    error(`${refusal ?? "Relvo update check failed."} The current version remains usable; the next automatic check is in 24 hours.`);
+            }
+        });
+        if (options.updateWorker)
+            return 0;
+        if (explicit)
+            return 0;
+        if (command)
+            return command;
+        if (!selected || selected.version === options.version)
+            return runCurrent();
+        return delegate(options.launcher ?? await executable("npx", env), selected.version, args, env, home, error);
+    }
+    catch (failure) {
+        if (options.updateWorker)
+            return 0;
+        if (command) {
+            error("Relvo update preparation stopped. The running session was retained.");
+            return command;
+        }
+        if (explicit) {
+            error(failure instanceof Error ? failure.message : "Relvo update failed without changing the login.");
+            return 1;
+        }
+        error("Relvo update management is unavailable. Retaining the selected version; local configuration was preserved.");
+        return runRetained();
+    }
+    finally {
+        if (mcp) {
+            process.stdin.removeListener("end", endSession);
+            process.stdin.removeListener("close", endSession);
+            for (const signal of signals)
+                process.removeListener(signal, endSession);
+        }
+    }
+}

package/dist/cli/update-release.js

@@ -0,0 +1,212 @@
+import { createHash } from "node:crypto";
+export const releaseCooldownMs = 72 * 60 * 60 * 1000;
+const releaseError = () => new Error("Unable to verify a compatible Relvo CLI release from the official npm registry.");
+const metadataLimit = 1024 * 1024;
+const tarballLimit = 16 * 1024 * 1024;
+const tarballUrl = (version) => `https://registry.npmjs.org/@relvo/cli/-/cli-${version}.tgz`;
+export function validCliVersion(value) {
+    return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value)
+        && value.split(".").every((part) => Number.isSafeInteger(Number(part)));
+}
+export function compareCliVersions(a, b) {
+    if (!validCliVersion(a) || !validCliVersion(b))
+        throw new Error("Invalid Relvo CLI version.");
+    const left = a.split(".").map(Number), right = b.split(".").map(Number);
+    for (let index = 0; index < 3; index++) {
+        if (left[index] !== right[index])
+            return left[index] < right[index] ? -1 : 1;
+    }
+    return 0;
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function compatibleNode(engine) {
+    if (typeof engine !== "string")
+        return false;
+    const match = /^>=(0|[1-9]\d*)(?:\.(0|[1-9]\d*)\.(0|[1-9]\d*))?$/.exec(engine);
+    if (!match)
+        return false;
+    const minimum = `${match[1]}.${match[2] ?? "0"}.${match[3] ?? "0"}`;
+    return validCliVersion(minimum) && compareCliVersions(process.versions.node, minimum) >= 0;
+}
+function releaseMetadata(value, selector) {
+    if (!record(value) || value.name !== "@relvo/cli" || typeof value.version !== "string"
+        || !validCliVersion(value.version) || (selector !== "latest" && selector !== value.version)
+        || value.relvoUpdateProtocol !== 1 || (value.deprecated !== undefined && value.deprecated !== "")
+        || !record(value.engines) || !compatibleNode(value.engines.node) || !record(value.dist))
+        throw releaseError();
+    const { integrity, tarball } = value.dist;
+    if (tarball !== tarballUrl(value.version)
+        || typeof integrity !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(integrity))
+        throw releaseError();
+    const digest = integrity.slice("sha512-".length), bytes = Buffer.from(digest, "base64");
+    if (bytes.length !== 64 || bytes.toString("base64") !== digest)
+        throw releaseError();
+    return { version: value.version, integrity };
+}
+async function readLimited(response, limit, signal, consume) {
+    if (!response.ok || !response.body) {
+        await response.body?.cancel().catch(() => { });
+        throw releaseError();
+    }
+    const length = response.headers.get("content-length");
+    if (length !== null && (!/^\d+$/.test(length) || Number(length) > limit)) {
+        await response.body.cancel();
+        throw releaseError();
+    }
+    const reader = response.body.getReader();
+    let total = 0;
+    try {
+        for (;;) {
+            signal.throwIfAborted();
+            const part = await reader.read();
+            if (part.done)
+                break;
+            total += part.value.byteLength;
+            if (total > limit)
+                throw releaseError();
+            consume(part.value);
+        }
+    }
+    catch {
+        await reader.cancel().catch(() => { });
+        throw releaseError();
+    }
+    finally {
+        reader.releaseLock();
+    }
+    signal.throwIfAborted();
+}
+const requestSignal = (signal, milliseconds) => signal ? AbortSignal.any([signal, AbortSignal.timeout(milliseconds)]) : AbortSignal.timeout(milliseconds);
+async function download(url, accept, transport, signal, limit, consume) {
+    signal.throwIfAborted();
+    const response = await transport(url, { method: "GET", headers: { accept }, redirect: "error", credentials: "omit", signal });
+    await readLimited(response, limit, signal, consume);
+}
+async function fetchPackument(transport, signal) {
+    const chunks = [];
+    await download("https://registry.npmjs.org/@relvo%2fcli", "application/json", transport, requestSignal(signal, 3000), metadataLimit, (chunk) => chunks.push(chunk));
+    const document = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (!record(document) || document.name !== "@relvo/cli" || !record(document.versions))
+        throw releaseError();
+    const tags = document["dist-tags"];
+    return { versions: document.versions, latest: record(tags) ? tags.latest : undefined, times: record(document.time) ? document.time : {} };
+}
+function exactRelease(document, selector) {
+    const value = document.versions[selector], refused = (detail) => new ReleaseManifestError(`${releaseError().message} ${selector} ${detail}`);
+    if (value === undefined)
+        throw refused("is not published.");
+    if (record(value) && value.deprecated)
+        throw refused("is deprecated. Choose another version.");
+    if (record(value) && record(value.engines) && !compatibleNode(value.engines.node))
+        throw refused(`does not support Node.js ${process.versions.node}.`);
+    return releaseMetadata(value, selector);
+}
+function selectRelease(document, selector, settled) {
+    if (selector !== "latest")
+        return exactRelease(document, selector);
+    const tag = document.latest;
+    if (typeof tag !== "string" || !validCliVersion(tag))
+        throw releaseError();
+    if (!settled)
+        return releaseMetadata(document.versions[tag], tag);
+    let best = null;
+    for (const [version, entry] of Object.entries(document.versions)) {
+        if (!validCliVersion(version) || compareCliVersions(version, tag) > 0)
+            continue;
+        const time = document.times[version], published = typeof time === "string" ? Date.parse(time) : Number.NaN;
+        if (!(published <= settled.now - settled.cooldownMs))
+            continue;
+        let release;
+        try {
+            release = releaseMetadata(entry, version);
+        }
+        catch {
+            continue;
+        }
+        if (!best || compareCliVersions(release.version, best.version) > 0)
+            best = release;
+    }
+    return best;
+}
+export async function verifyCliTarball(release, transport = fetch, signal) {
+    try {
+        const hash = createHash("sha512");
+        await download(tarballUrl(release.version), "application/octet-stream", transport, requestSignal(signal, 20000), tarballLimit, (chunk) => hash.update(chunk));
+        if (`sha512-${hash.digest("base64")}` !== release.integrity)
+            throw releaseError();
+    }
+    catch {
+        throw releaseError();
+    }
+}
+export async function fetchCliRelease(selector, transport = fetch, signal, settled) {
+    if (selector !== "latest" && !validCliVersion(selector))
+        throw releaseError();
+    try {
+        return selectRelease(await fetchPackument(transport, signal), selector, settled);
+    }
+    catch (error) {
+        throw error instanceof ReleaseManifestError ? error : releaseError();
+    }
+}
+export const releaseManifestPath = "/relvo/cli-releases.json";
+export class ReleaseManifestError extends Error {
+}
+const manifestRefusal = (detail) => new ReleaseManifestError(`${detail} It was not adopted.`);
+export function releaseManifestUrl(consoleUrl, local) {
+    let url;
+    try {
+        url = new URL(consoleUrl);
+    }
+    catch {
+        throw manifestRefusal("The Relvo console URL in the login is invalid.");
+    }
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.username || url.password || (url.protocol !== "https:" && !(local && loopback && url.protocol === "http:"))) {
+        throw manifestRefusal("The Relvo console URL in the login is not a trusted origin.");
+    }
+    return `${url.origin}${releaseManifestPath}`;
+}
+export function parseReleaseManifest(text) {
+    let document;
+    try {
+        document = JSON.parse(text);
+    }
+    catch {
+        throw manifestRefusal("The Relvo console's release manifest is not valid JSON.");
+    }
+    if (!record(document) || document.schema !== 1 || document.package !== "@relvo/cli" || !record(document.releases)) {
+        throw manifestRefusal("The Relvo console's release manifest has an unexpected shape.");
+    }
+    const releases = {};
+    for (const [version, integrity] of Object.entries(document.releases)) {
+        if (validCliVersion(version) && typeof integrity === "string" && /^sha512-[A-Za-z0-9+/]{86}==$/.test(integrity))
+            releases[version] = integrity;
+    }
+    return releases;
+}
+export async function confirmReleaseManifest(release, consoleUrl, local, transport = fetch, signal) {
+    const url = releaseManifestUrl(consoleUrl, local), chunks = [];
+    try {
+        await download(url, "application/json", transport, requestSignal(signal, 3000), metadataLimit, (chunk) => chunks.push(chunk));
+    }
+    catch {
+        throw manifestRefusal(`Relvo ${release.version} could not be checked against the Relvo console's release manifest.`);
+    }
+    const recorded = parseReleaseManifest(Buffer.concat(chunks).toString("utf8"))[release.version];
+    if (recorded === undefined)
+        throw manifestRefusal(`Relvo ${release.version} is on npm but is not listed in the Relvo console's release manifest.`);
+    if (recorded !== release.integrity)
+        throw manifestRefusal(`npm's tarball for Relvo ${release.version} differs from the Relvo console's release manifest.`);
+}
+export async function confirmCliRelease(release, transport = fetch, signal) {
+    try {
+        const current = releaseMetadata((await fetchPackument(transport, signal)).versions[release.version], release.version);
+        return current.integrity === release.integrity;
+    }
+    catch {
+        throw releaseError();
+    }
+}

package/dist/cli/version.js

@@ -0,0 +1 @@
+export const PLATFORM_CLI_VERSION = "0.1.18";