@dreamlake/ml-dash 0.1.0 → 0.1.1

package/README.md

@@ -27,9 +27,11 @@ The command is still `ml-dash`. The package is scoped because the unscoped
 name is not claimable — npm refuses `ml-dash` as too similar to the existing
 `mldash`.
 
-*Not published yet:* the npm channel is built and tested on every release run,
-but no version has reached the registry. Until one does, use the installers
-above. `docs/RELEASE.md` tracks what is outstanding.
+*Current state:* `@dreamlake/ml-dash@0.1.0` is on the registry. On R2 the
+0.1.0 artifacts and both installers are published, but the `latest` and
+`stable` channel pointers have not been written yet — so the two install
+commands above need an explicit `--version 0.1.0` until a release run moves
+them. `docs/RELEASE.md` tracks what is outstanding.
 
 Both channels run the same code — the binaries are `src/index.ts` compiled
 ahead of time, the npm package is the same source compiled to `dist/`.
@@ -59,6 +61,46 @@ install path is already occupied by a file this installer did not write — a
 symlink, a pipx shim, anything without its receipt — it stops instead of
 overwriting; `--force` / `-Force` takes over deliberately.
 
+## Updating
+
+```sh
+ml-dash update           # update to the latest release
+ml-dash update --check   # report whether one exists; change nothing
+```
+
+`update` uses the channel this copy was installed from, and works it out from
+the running process rather than guessing: an npm install runs
+`npm install -g @dreamlake/ml-dash@<version>`, a standalone binary replaces
+itself. Run from a source checkout it refuses outright, so `npm run cli --
+update` in this repository cannot quietly rewrite the `ml-dash` on your PATH.
+
+For a standalone binary, an update is only written after it has been proven:
+
+- the version comes from the `latest` pointer in the same bucket the binary was
+  installed from — the URL is compiled in, not configurable by a user;
+- the download is checked against the sha256 **and** the byte count in that
+  release's `manifest.json`, and is cut off the moment it runs past the
+  declared length;
+- the downloaded binary is run once (`ml-dash version`) and has to report the
+  version that was asked for — the same gate `install.sh` applies, which is
+  what catches a correct build for the wrong libc;
+- only then is it renamed over the running binary, keeping its permissions, and
+  the install receipt is refreshed so `install.sh` still recognises the install.
+
+Any failure leaves the working binary exactly as it was and removes the
+download. `update` never downgrades: if the pointer moves backwards it stops
+and tells you to use `install.sh --version` if that is really what you want.
+
+It will refuse, rather than force, an install it does not own. A binary sitting
+in a Homebrew cellar, a Nix store, a pipx venv or a `node_modules` tree is left
+alone with a pointer to that tool's own upgrade command, and so is a directory
+it cannot write to.
+
+`--version <x.y.z>` installs an exact release. `--json` prints the report for
+scripts. On Windows the running `.exe` cannot be replaced while it is open, so
+the verified file is swapped in as the command exits; `ml-dash update` tells
+you that and your next `ml-dash` is the new one.
+
 ## Usage
 
 ```sh

package/dist/commands/update.js

@@ -0,0 +1,250 @@
+/**
+ * `ml-dash update` — update this install, in place, from wherever it came.
+ *
+ * Two channels ship ml-dash and they are updated in completely different ways,
+ * so the first thing this does is work out which one is running (see
+ * src/update/channel.ts) and refuse if the answer is "neither" — a source
+ * checkout must not quietly rewrite somebody's global install.
+ *
+ *   npm         ask registry.npmjs.org for dist-tags.latest, then run
+ *               `npm install -g @dreamlake/ml-dash@<exact>` and re-read what
+ *               npm actually left installed.
+ *   standalone  read the `latest` pointer and the release manifest from the
+ *               same bucket the binary was installed from, download this
+ *               platform's build, check its size and sha256 against the
+ *               manifest, run it once, and only then rename it over the
+ *               running binary.
+ *
+ * Failure at any point leaves the installed binary untouched and removes the
+ * download. Nothing is ever written next to the binary before its checksum has
+ * been verified.
+ */
+import { spawnSync } from "node:child_process";
+import { rm } from "node:fs/promises";
+import path from "node:path";
+import semver from "semver";
+import { bold, cyan, dim, green, red, yellow } from "../util/ansi.js";
+import { VERSION } from "../version.js";
+import { detectChannel, PACKAGE_NAME } from "../update/channel.js";
+import { detectPlatform, UnsupportedPlatformError } from "../update/platform.js";
+import { binaryUrl, downloadTo, entryFor, isStrictSemver, readChannelVersion, readManifest, resolveBaseUrl, UpdateSourceError, } from "../update/release.js";
+import { findNpm, installedGlobalVersion, latestPublishedVersion, resolveRegistry, runNpmInstall, versionExists, } from "../update/npm.js";
+import { checkReplaceable, ReplaceError, scheduleWindowsSwap, swapInPlace } from "../update/replace.js";
+export const spec = {
+    name: "update",
+    help: "Update ml-dash to the latest version",
+    description: "Check for a newer ml-dash and install it.\n\n" +
+        "The update uses whichever channel this copy was installed from: an npm\n" +
+        "install is updated with 'npm install -g', a standalone binary replaces\n" +
+        "itself with the build published for this platform. A standalone download\n" +
+        "is checked against the sha256 in the release manifest and run once before\n" +
+        "it replaces anything, so a bad download leaves the working binary in place.",
+    options: [
+        { flags: ["--check"], dest: "check", boolean: true, help: "Report whether an update exists; change nothing" },
+        { flags: ["--version"], dest: "version", metavar: "VERSION", help: "Install this exact version instead of the latest" },
+        { flags: ["--json"], dest: "json", boolean: true, help: "Output as JSON" },
+    ],
+};
+const emit = (report, json, human) => {
+    if (json)
+        console.log(JSON.stringify(report, null, 2));
+    else
+        for (const line of human)
+            console.log(line);
+    return 0;
+};
+const fail = (message, json) => {
+    if (json)
+        console.log(JSON.stringify({ error: message }, null, 2));
+    else
+        console.error(`${red("✗ Update failed:")} ${message}`);
+    return 1;
+};
+export async function run(args) {
+    const json = args.json === true;
+    const check = args.check === true;
+    const pinned = typeof args.version === "string" ? args.version.trim().replace(/^v/, "") : undefined;
+    if (pinned !== undefined && !isStrictSemver(pinned)) {
+        return fail(`'${String(args.version)}' is not a version — expected something like 0.1.1`, json);
+    }
+    const channel = detectChannel();
+    if (channel.kind === "source") {
+        return fail(`this is not an installed ml-dash — ${channel.reason}.\n` +
+            `  There is nothing here to replace, and updating the copy on your PATH from a\n` +
+            `  checkout would change an install this process does not own. To update that\n` +
+            `  copy, run 'ml-dash update' from it instead.`, json);
+    }
+    try {
+        return channel.kind === "npm"
+            ? await updateNpm(channel, { check, pinned, json })
+            : await updateStandalone(channel, { check, pinned, json });
+    }
+    catch (e) {
+        if (e instanceof UpdateSourceError || e instanceof ReplaceError || e instanceof UnsupportedPlatformError) {
+            return fail(e.message, json);
+        }
+        throw e;
+    }
+}
+/**
+ * Decide what `target` means relative to what is installed.
+ *
+ * A downgrade is refused rather than performed. `update` is the command people
+ * run to move forward, and it is also the command a script runs unattended;
+ * silently installing an older build because a pointer moved backwards is the
+ * one outcome nobody asks for. Installing an older version deliberately is
+ * what install.sh --version is for, and the message says so.
+ */
+function compareOrThrow(current, target) {
+    if (!semver.valid(current))
+        throw new UpdateSourceError(`this build reports version '${current}'`);
+    if (semver.eq(target, current))
+        return "same";
+    if (semver.lt(target, current)) {
+        throw new UpdateSourceError(`${target} is older than the installed ${current}, and update does not downgrade.\n` +
+            `  To install an older build deliberately:\n` +
+            `      curl -fsSL https://pub-42e1dcc7de574d4a92984865fdc95f10.r2.dev/install.sh | sh -s -- --version ${target}`);
+    }
+    return "newer";
+}
+// ── npm ──────────────────────────────────────────────────────────────────────
+async function updateNpm(channel, opts) {
+    const { url: registry, overridden } = resolveRegistry();
+    if (overridden)
+        console.error(yellow(`note: using registry ${registry} (ML_DASH_UPDATE_REGISTRY)`));
+    const target = opts.pinned ?? (await latestPublishedVersion(registry));
+    if (opts.pinned && !(await versionExists(registry, opts.pinned))) {
+        throw new UpdateSourceError(`${PACKAGE_NAME}@${opts.pinned} is not published on ${registry}`);
+    }
+    const relation = compareOrThrow(VERSION, target);
+    const base = {
+        channel: "npm",
+        current: VERSION,
+        target,
+        update_available: relation === "newer",
+        action: relation === "same" ? "up-to-date" : "available",
+    };
+    if (relation === "same") {
+        return emit(base, opts.json, [`${green("✓")} ml-dash ${VERSION} is the latest version on npm.`]);
+    }
+    if (opts.check) {
+        return emit(base, opts.json, [
+            `${yellow("↑")} ml-dash ${cyan(target)} is available — you have ${VERSION}.`,
+            `  Install it with: ${bold("ml-dash update")}`,
+        ]);
+    }
+    const npm = findNpm();
+    if (!opts.json)
+        console.log(`Updating ml-dash ${VERSION} → ${cyan(target)} via npm`);
+    // Under --json this process's stdout carries one document and nothing else,
+    // so npm's own output is moved to stderr rather than interleaved into it.
+    const code = await runNpmInstall(npm, target, opts.json ? "stderr" : "inherit");
+    if (code !== 0) {
+        throw new UpdateSourceError(`npm install exited ${code}. Nothing here changed the install; npm's own output above says why.\n` +
+            `  A global install often needs elevated permissions — see 'npm config get prefix'.`);
+    }
+    // npm exiting 0 is not the same as the right version being installed: a
+    // global prefix this process cannot see, or an install that resolved a
+    // different tree, would both exit 0 and leave the old binary on PATH.
+    const now = installedGlobalVersion(npm, channel.packageDir);
+    if (now !== target) {
+        throw new UpdateSourceError(`npm reported success, but the globally installed version is ${now ?? "unreadable"}, not ${target}.\n` +
+            `  Check which ml-dash is first on your PATH: 'npm ls -g ${PACKAGE_NAME}' and 'which ml-dash'.`);
+    }
+    return emit({ ...base, action: "updated" }, opts.json, [
+        "",
+        `${green("✓ Updated to ml-dash " + target)}`,
+        dim(`  npm reports ${PACKAGE_NAME}@${now} installed globally.`),
+    ]);
+}
+// ── standalone ───────────────────────────────────────────────────────────────
+async function updateStandalone(channel, opts) {
+    const { url: baseUrl, overridden } = resolveBaseUrl();
+    if (overridden)
+        console.error(yellow(`note: updating from ${baseUrl} (ML_DASH_UPDATE_BASE_URL)`));
+    const platform = detectPlatform();
+    const target = opts.pinned ?? (await readChannelVersion(baseUrl, "latest"));
+    const relation = compareOrThrow(VERSION, target);
+    const base = {
+        channel: "standalone",
+        current: VERSION,
+        target,
+        update_available: relation === "newer",
+        action: relation === "same" ? "up-to-date" : "available",
+    };
+    if (relation === "same") {
+        return emit(base, opts.json, [`${green("✓")} ml-dash ${VERSION} is the latest ${platform} release.`]);
+    }
+    if (opts.check) {
+        return emit(base, opts.json, [
+            `${yellow("↑")} ml-dash ${cyan(target)} is available for ${platform} — you have ${VERSION}.`,
+            `  Install it with: ${bold("ml-dash update")}`,
+        ]);
+    }
+    const manifest = await readManifest(baseUrl, target);
+    const entry = entryFor(manifest, platform);
+    const executable = channel.executable;
+    await checkReplaceable(executable);
+    const source = binaryUrl(baseUrl, target, platform, entry.binary);
+    // Staged in the install directory so the last step is a rename within one
+    // filesystem, and named after this pid so two concurrent updates cannot
+    // write the same file.
+    const staged = path.join(path.dirname(executable), `.ml-dash.update.${process.pid}.tmp`);
+    let handedOff = false;
+    try {
+        if (!opts.json)
+            console.log(`Updating ml-dash ${VERSION} → ${cyan(target)} (${platform})`);
+        const sha = await downloadTo(source, staged, entry.size);
+        if (sha !== entry.checksum) {
+            throw new UpdateSourceError(`checksum mismatch — the download is not the published ${target} build.\n` +
+                `  expected ${entry.checksum}\n` +
+                `  got      ${sha}\n` +
+                `  Nothing was installed; ${VERSION} is still in place.`);
+        }
+        if (!opts.json)
+            console.log(`  ${green("sha256 ok")}`);
+        smokeTest(staged, target);
+        if (process.platform === "win32") {
+            // Windows keeps an image section open on a running .exe, so the rename
+            // has to happen after this process is gone.
+            await scheduleWindowsSwap({ target: executable, staged, version: target, platform, sha256: sha, source });
+            handedOff = true;
+            return emit({ ...base, action: "scheduled", note: "applied when this command exits" }, opts.json, [
+                "",
+                `${green("✓ ml-dash " + target + " is verified and ready.")}`,
+                `  It replaces the running binary as this command exits — your next ${bold("ml-dash")} is ${target}.`,
+            ]);
+        }
+        await swapInPlace({ target: executable, staged, version: target, platform, sha256: sha, source });
+        handedOff = true;
+        return emit({ ...base, action: "updated" }, opts.json, [
+            "",
+            `${green("✓ Updated to ml-dash " + target)}`,
+            dim(`  ${executable}`),
+        ]);
+    }
+    finally {
+        // On every failure, and on Windows never: the helper still needs the file.
+        if (!handedOff)
+            await rm(staged, { force: true });
+    }
+}
+/**
+ * Run the downloaded binary before trusting it, the same gate install.sh
+ * applies. A correctly hashed build for the wrong libc is a real outcome —
+ * Bun's musl binaries need libstdc++, which Alpine does not ship — and it
+ * would otherwise surface as a broken ml-dash at the user's next command
+ * rather than here, with the working binary still in place.
+ */
+function smokeTest(staged, expected) {
+    const r = spawnSync(staged, ["version"], { encoding: "utf8", shell: false, timeout: 60_000 });
+    const output = `${r.stdout ?? ""}${r.stderr ?? ""}`.trim();
+    if (r.status !== 0) {
+        throw new UpdateSourceError(`the downloaded ${expected} binary does not run on this system:\n` +
+            `${output.split("\n").map((l) => `    ${l}`).join("\n")}\n` +
+            `  Nothing was installed.`);
+    }
+    if (!output.includes(expected)) {
+        throw new UpdateSourceError(`the downloaded binary reports '${output}' rather than ${expected} — refusing to install it.`);
+    }
+}

package/dist/index.js

@@ -18,6 +18,7 @@ const loaders = {
     list: () => import("./commands/list.js"),
     upload: () => import("./commands/upload.js"),
     download: () => import("./commands/download.js"),
+    update: () => import("./commands/update.js"),
 };
 export async function main(argv) {
     const [command, ...rest] = argv;

package/dist/update/channel.js

@@ -0,0 +1,85 @@
+/**
+ * Which of the two shipping channels is this process?
+ *
+ * `ml-dash update` must never guess. Updating the npm channel runs
+ * `npm install -g`; updating the standalone channel overwrites a file on disk.
+ * Doing either from a source checkout would mean a developer running
+ * `npm run cli -- update` silently mutates their global install, so a checkout
+ * is a third, explicit answer: refuse.
+ *
+ * The discriminator is exact rather than heuristic:
+ *
+ *   standalone  `bun build --compile` maps the bundle at `/$bunfs/root/...`,
+ *               so `import.meta.url` is under that virtual root while
+ *               `process.execPath` is the real single-file binary. Bun running
+ *               loose source reports a real path for both, so the two cases
+ *               cannot be confused. (Verified against bun 1.3.14 — the version
+ *               scripts/build-release.ts pins.)
+ *   npm         a Node process whose own module resolves inside a
+ *               `node_modules` tree rooted at this package. A checkout has the
+ *               same package.json and no such ancestor.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Kept equal to package.json's `name` by a test — the two must not drift. */
+export const PACKAGE_NAME = "@dreamlake/ml-dash";
+const BUNFS = "/$bunfs/";
+/** True when this module was loaded out of a `bun build --compile` bundle. */
+export function isCompiledBinary(moduleUrl = import.meta.url) {
+    return process.versions.bun !== undefined && moduleUrl.includes(BUNFS);
+}
+/**
+ * The package root above `from`, if it is this package installed under a
+ * `node_modules` tree. Returns undefined for a checkout, for a different
+ * package, and for an unreadable or malformed package.json.
+ */
+function npmPackageDir(from) {
+    let dir = from;
+    for (let depth = 0; depth < 10; depth++) {
+        const manifest = path.join(dir, "package.json");
+        let name;
+        try {
+            name = JSON.parse(readFileSync(manifest, "utf8")).name;
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return undefined;
+            dir = parent;
+            continue;
+        }
+        if (name !== PACKAGE_NAME)
+            return undefined;
+        // A checkout has this package.json too. Only an installed copy sits inside
+        // a node_modules tree, and that — not the file's contents — is what makes
+        // `npm install -g` the right thing to run.
+        return dir.split(path.sep).includes("node_modules") ? dir : undefined;
+    }
+    return undefined;
+}
+export function detectChannel(moduleUrl = import.meta.url) {
+    if (isCompiledBinary(moduleUrl)) {
+        return { kind: "standalone", executable: process.execPath };
+    }
+    if (moduleUrl.includes(BUNFS)) {
+        // Bun-mapped but not a compiled binary: nothing here knows what to update.
+        return { kind: "source", reason: "running from a bundled source tree" };
+    }
+    let here;
+    try {
+        here = path.dirname(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return { kind: "source", reason: "this build has no resolvable install path" };
+    }
+    const packageDir = npmPackageDir(here);
+    if (packageDir)
+        return { kind: "npm", packageDir };
+    return {
+        kind: "source",
+        reason: process.versions.bun
+            ? "running from a source checkout under bun"
+            : "running from a source checkout, not an installed package",
+    };
+}

package/dist/update/npm.js

@@ -0,0 +1,214 @@
+/**
+ * The npm channel: ask the registry, then let npm do the install.
+ *
+ * Nothing here unpacks a tarball or writes into node_modules. `npm install -g`
+ * is the only supported way to change an npm install — it owns the global
+ * prefix, the bin shims and the lockfile-free global tree — so this module's
+ * whole job is to find the right npm, hand it an exact version, and check
+ * afterwards that the version it left behind is the one that was asked for.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { PACKAGE_NAME } from "./channel.js";
+import { UpdateSourceError, isStrictSemver, readBounded, requireSafeOrigin } from "./release.js";
+export const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const REGISTRY_TIMEOUT_MS = 20_000;
+/** The abbreviated packument is a few KB; the full one can be megabytes. */
+const PACKUMENT_MAX_BYTES = 4 * 1024 * 1024;
+/** Same narrow rule as the standalone channel's base URL — see release.ts. */
+export function resolveRegistry(env = process.env) {
+    const raw = env.ML_DASH_UPDATE_REGISTRY?.trim();
+    if (!raw)
+        return { url: DEFAULT_REGISTRY, overridden: false };
+    return { url: requireSafeOrigin(raw, "ML_DASH_UPDATE_REGISTRY").replace(/\/+$/, ""), overridden: true };
+}
+/**
+ * `dist-tags.latest` for the package, read over plain HTTP rather than through
+ * `npm view`: `npm view` exits non-zero for "no such package" and for "the
+ * registry is unreachable" alike, and scripts/publish-release.sh already
+ * refuses to conflate those two for exactly this reason.
+ */
+export async function latestPublishedVersion(registry) {
+    const url = `${registry}/${encodeURIComponent(PACKAGE_NAME)}`;
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: { accept: "application/vnd.npm.install-v1+json" },
+            signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS),
+            redirect: "follow",
+        });
+    }
+    catch (e) {
+        throw new UpdateSourceError(`cannot reach the npm registry at ${url}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    requireSafeOrigin(res.url || url, "the registry that answered");
+    if (res.status === 404) {
+        throw new UpdateSourceError(`${PACKAGE_NAME} is not published on ${registry}`);
+    }
+    if (!res.ok)
+        throw new UpdateSourceError(`${url} returned HTTP ${res.status}`);
+    const text = await readBounded(res, PACKUMENT_MAX_BYTES, `the registry document at ${url}`);
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        throw new UpdateSourceError(`the registry document at ${url} is not JSON`);
+    }
+    const latest = doc["dist-tags"]?.latest;
+    if (typeof latest !== "string" || !isStrictSemver(latest)) {
+        throw new UpdateSourceError(`${registry} reports no usable 'latest' version for ${PACKAGE_NAME}`);
+    }
+    return latest;
+}
+/** Whether the registry actually has this exact version, before npm is run. */
+export async function versionExists(registry, version) {
+    const url = `${registry}/${encodeURIComponent(PACKAGE_NAME)}/${encodeURIComponent(version)}`;
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS), redirect: "follow" });
+        if (res.status === 404)
+            return false;
+        if (!res.ok)
+            throw new UpdateSourceError(`${url} returned HTTP ${res.status}`);
+        return true;
+    }
+    catch (e) {
+        if (e instanceof UpdateSourceError)
+            throw e;
+        throw new UpdateSourceError(`cannot reach ${url}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function which(name) {
+    const sep = process.platform === "win32" ? ";" : ":";
+    for (const dir of (process.env.PATH ?? "").split(sep)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, name);
+        try {
+            accessSync(candidate, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Not here; keep looking.
+        }
+    }
+    return undefined;
+}
+/**
+ * How to run npm without a shell.
+ *
+ * Preferring npm's own `npm-cli.js` over the `npm` wrapper is what makes that
+ * possible on Windows: since the 2024 fix for CVE-2024-27980, Node refuses to
+ * spawn a `.cmd` without `shell: true`, and turning the shell on would mean
+ * the package name and version were parsed by cmd.exe. Running the script with
+ * this process's own Node interpreter sidesteps the wrapper entirely and is
+ * the identical code path on every platform.
+ */
+export function findNpm() {
+    const names = process.platform === "win32" ? ["npm.cmd", "npm.exe", "npm"] : ["npm"];
+    for (const name of names) {
+        const found = which(name);
+        if (!found)
+            continue;
+        // On Unix the `npm` on PATH is usually a symlink straight to npm-cli.js.
+        let resolved = found;
+        try {
+            resolved = realpathSync(found);
+        }
+        catch {
+            // Keep the unresolved path.
+        }
+        if (resolved.endsWith(".js"))
+            return { command: process.execPath, prefix: [resolved] };
+        // Otherwise look for the CLI script beside the wrapper, which is where
+        // every npm layout (Windows, nvm, Homebrew, Volta) puts it.
+        for (const relative of [
+            ["node_modules", "npm", "bin", "npm-cli.js"],
+            ["..", "lib", "node_modules", "npm", "bin", "npm-cli.js"],
+        ]) {
+            const cli = path.join(path.dirname(resolved), ...relative);
+            if (existsSync(cli))
+                return { command: process.execPath, prefix: [cli] };
+        }
+        // A wrapper we cannot see through. Safe to spawn directly everywhere
+        // except Windows, where Node will refuse a .cmd without a shell — and a
+        // shell is not something this command is willing to introduce.
+        if (process.platform === "win32" && /\.(cmd|bat)$/i.test(resolved))
+            continue;
+        return { command: resolved, prefix: [] };
+    }
+    throw new UpdateSourceError(`no npm executable was found on PATH, so this npm install cannot be updated from here.\n` +
+        `  Update it directly with:  npm install -g ${PACKAGE_NAME}@latest`);
+}
+export const installArgs = (version) => [
+    "install",
+    "--global",
+    `${PACKAGE_NAME}@${version}`,
+];
+/**
+ * Run `npm install -g <pkg>@<exact>` and return its exit code.
+ *
+ * Arguments go across as an array with `shell: false`, so the version string
+ * is an argument rather than something a shell re-parses. npm's stderr is
+ * always inherited — a failing install has to be able to say why — and only
+ * its stdout is diverted, onto this process's stderr rather than discarded,
+ * so `--json` loses none of the diagnosis it would otherwise print.
+ */
+export function runNpmInstall(npm, version, output = "inherit") {
+    if (!isStrictSemver(version)) {
+        // Belt and braces: nothing should reach here with an unvalidated version.
+        throw new UpdateSourceError(`refusing to install '${version}': not a version`);
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(npm.command, [...npm.prefix, ...installArgs(version)], {
+            stdio: npmStdio(output),
+            shell: false,
+        });
+        // "pipe" only ever means "send it to stderr instead": nothing is dropped.
+        child.stdout?.pipe(process.stderr);
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+/** stdin, stdout, stderr — separated out so the contract can be asserted. */
+export const npmStdio = (output) => [
+    "inherit",
+    output === "stderr" ? "pipe" : "inherit",
+    "inherit",
+];
+/**
+ * What is globally installed now, asked of npm rather than inferred.
+ *
+ * The running copy's own package.json is the fallback and not the primary
+ * answer: `npm install -g` writes to npm's global prefix, which is not
+ * necessarily the tree this process was loaded from.
+ */
+export function installedGlobalVersion(npm, packageDir) {
+    const listed = npmLsVersion(npm);
+    if (listed)
+        return listed;
+    try {
+        return JSON.parse(readFileSync(path.join(packageDir, "package.json"), "utf8"))
+            .version;
+    }
+    catch {
+        return undefined;
+    }
+}
+function npmLsVersion(npm) {
+    const r = spawnSync(npm.command, [...npm.prefix, "ls", "--global", "--depth", "0", "--json", PACKAGE_NAME], {
+        encoding: "utf8",
+        shell: false,
+        timeout: 60_000,
+    });
+    if (!r.stdout)
+        return undefined;
+    try {
+        const doc = JSON.parse(r.stdout);
+        return doc.dependencies?.[PACKAGE_NAME]?.version;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/update/platform.js

@@ -0,0 +1,68 @@
+/**
+ * The platform key a release manifest is indexed by.
+ *
+ * These are the same eight keys `scripts/build-release.ts` builds and the same
+ * rules `install.sh` and `install.ps1` apply when they pick one — including the
+ * musl suffix, because a glibc binary does not start on Alpine at all. A
+ * divergence here would not fail loudly: it would download a real, correctly
+ * hashed binary for the wrong libc and only break at the next run.
+ */
+import { existsSync, readdirSync } from "node:fs";
+/** Every key `scripts/build-release.ts` emits. Used to validate a manifest. */
+export const PLATFORM_KEYS = [
+    "darwin-arm64",
+    "darwin-x64",
+    "linux-x64",
+    "linux-arm64",
+    "linux-x64-musl",
+    "linux-arm64-musl",
+    "windows-x64",
+    "windows-arm64",
+];
+export class UnsupportedPlatformError extends Error {
+}
+/**
+ * Probed rather than assumed, matching install.sh: `ldd --version | grep musl`
+ * is the shell's version of this, and the loader's own file name is the same
+ * evidence without a subprocess. `/etc/alpine-release` is a second signal for
+ * the case where /lib is not readable.
+ */
+function isMusl() {
+    try {
+        if (readdirSync("/lib").some((f) => f.startsWith("ld-musl-")))
+            return true;
+    }
+    catch {
+        // /lib unreadable or absent; fall through to the distro marker.
+    }
+    return existsSync("/etc/alpine-release");
+}
+export function detectPlatform(platform = process.platform, arch = process.arch, musl = isMusl) {
+    let os;
+    switch (platform) {
+        case "darwin":
+            os = "darwin";
+            break;
+        case "linux":
+            os = "linux";
+            break;
+        case "win32":
+            os = "windows";
+            break;
+        default:
+            throw new UnsupportedPlatformError(`ml-dash has no build for '${platform}'. Supported: macOS, Linux and Windows.`);
+    }
+    let cpu;
+    switch (arch) {
+        case "x64":
+            cpu = "x64";
+            break;
+        case "arm64":
+            cpu = "arm64";
+            break;
+        default:
+            throw new UnsupportedPlatformError(`ml-dash has no build for '${arch}'. Supported architectures: x64 and arm64.`);
+    }
+    const key = os === "linux" && musl() ? `linux-${cpu}-musl` : `${os}-${cpu}`;
+    return key;
+}

package/dist/update/release.js

@@ -0,0 +1,241 @@
+/**
+ * Reading the standalone channel: the pointer, the manifest, and the bytes.
+ *
+ * This is the download half of install.sh expressed in TypeScript, and it
+ * makes the same promises: the origin is fixed at build time, the version is
+ * a pointer object published by scripts/publish-release.sh, and nothing is
+ * written anywhere until the downloaded bytes match the sha256 and the size
+ * the manifest records for this exact platform.
+ */
+import { createHash } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { open } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { PLATFORM_KEYS } from "./platform.js";
+/**
+ * The bucket the releases are actually served from — the same constant
+ * scripts/build-release.ts bakes into the installers, checked against it by
+ * that script so the two cannot drift. A binary must not learn where to fetch
+ * its own replacement from anywhere but its own build.
+ */
+export const DEFAULT_PUBLIC_URL = "https://pub-42e1dcc7de574d4a92984865fdc95f10.r2.dev";
+export const RELEASE_PREFIX = "ml-dash-cli/releases";
+/** Small documents. A pointer is a version string; a manifest is a few KB. */
+const POINTER_MAX_BYTES = 256;
+const MANIFEST_MAX_BYTES = 1024 * 1024;
+const METADATA_TIMEOUT_MS = 20_000;
+/**
+ * Binaries are 60–100 MB today. The cap is not the real check — the manifest's
+ * own `size` is, and it is enforced byte by byte below — it is the bound that
+ * applies before any manifest is trusted at all.
+ */
+export const MAX_DOWNLOAD_BYTES = 512 * 1024 * 1024;
+const DOWNLOAD_TIMEOUT_MS = 15 * 60_000;
+export class UpdateSourceError extends Error {
+}
+/**
+ * Where to fetch from.
+ *
+ * `ML_DASH_UPDATE_BASE_URL` mirrors the `--base-url` / `ML_DASH_BASE_URL`
+ * override install.sh and install.ps1 have always documented, so a staging
+ * bucket can be tested end to end. It is deliberately narrow: HTTPS only,
+ * except for a loopback host, which is how the test fixture injects a local
+ * server without opening a hole anywhere a network attacker sits. A caller
+ * that overrides it is told so on stderr — an update that came from somewhere
+ * other than the official origin must never be silent.
+ */
+export function resolveBaseUrl(env = process.env) {
+    const raw = env.ML_DASH_UPDATE_BASE_URL?.trim();
+    if (!raw)
+        return { url: DEFAULT_PUBLIC_URL, overridden: false };
+    return { url: requireSafeOrigin(raw, "ML_DASH_UPDATE_BASE_URL").replace(/\/+$/, ""), overridden: true };
+}
+const isLoopback = (hostname) => hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+/** HTTPS, or plain HTTP to a loopback address and nothing else. */
+export function requireSafeOrigin(value, what) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new UpdateSourceError(`${what} is not a URL: ${value}`);
+    }
+    if (parsed.protocol === "https:")
+        return value;
+    if (parsed.protocol === "http:" && isLoopback(parsed.hostname))
+        return value;
+    throw new UpdateSourceError(`${what} must be an https:// URL (got ${parsed.protocol}//${parsed.hostname}). ` +
+        `Plain http is accepted only for a loopback address.`);
+}
+async function getText(url, limit, what) {
+    let res;
+    try {
+        res = await fetch(url, { signal: AbortSignal.timeout(METADATA_TIMEOUT_MS), redirect: "follow" });
+    }
+    catch (e) {
+        throw new UpdateSourceError(`cannot reach ${url} to read ${what}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // A redirect can leave the origin rule behind, so the URL that actually
+    // answered is checked, not just the one that was asked.
+    requireSafeOrigin(res.url || url, `the server that answered for ${what}`);
+    if (!res.ok) {
+        throw new UpdateSourceError(`${url} returned HTTP ${res.status} for ${what}`);
+    }
+    return readBounded(res, limit, `${what} at ${url}`);
+}
+/**
+ * Read a response body, giving up the moment it passes `limit`.
+ *
+ * `await res.text()` would buffer the whole thing first and only then let the
+ * limit be checked, which makes the limit useless against the case it exists
+ * for: a source that answers a 300-byte pointer request with an endless body.
+ * The declared Content-Length is rejected first when there is one, and the
+ * stream is counted either way, because Content-Length is a claim.
+ */
+export async function readBounded(res, limit, what) {
+    const tooBig = () => new UpdateSourceError(`${what} is larger than ${limit} bytes — refusing to read it`);
+    const declared = Number(res.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > limit)
+        throw tooBig();
+    if (!res.body)
+        return "";
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let out = "";
+    let seen = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            seen += value.byteLength;
+            if (seen > limit)
+                throw tooBig();
+            out += decoder.decode(value, { stream: true });
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+    }
+    return out + decoder.decode();
+}
+/** Strict semver, the same shape .github/workflows/release.yml accepts. */
+const SEMVER = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/;
+export const isStrictSemver = (v) => SEMVER.test(v);
+/** The version a channel pointer names, e.g. `.../releases/latest`. */
+export async function readChannelVersion(baseUrl, channel) {
+    const url = `${baseUrl}/${RELEASE_PREFIX}/${encodeURIComponent(channel)}`;
+    const version = (await getText(url, POINTER_MAX_BYTES, `the '${channel}' channel`)).trim();
+    if (!isStrictSemver(version)) {
+        throw new UpdateSourceError(`the '${channel}' channel at ${url} reads '${version.slice(0, 64)}', which is not a version`);
+    }
+    return version;
+}
+/**
+ * A file name and nothing else. The manifest decides what to write next to the
+ * running binary, so `../`, an absolute path and a nested path are all refused
+ * before the name is ever joined onto a directory.
+ */
+const isPlainFilename = (name) => /^[A-Za-z0-9._-]+$/.test(name) && name !== "." && name !== "..";
+export async function readManifest(baseUrl, version) {
+    if (!isStrictSemver(version))
+        throw new UpdateSourceError(`'${version}' is not a version`);
+    const url = `${baseUrl}/${RELEASE_PREFIX}/${version}/manifest.json`;
+    const text = await getText(url, MANIFEST_MAX_BYTES, `the manifest for ${version}`);
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new UpdateSourceError(`the manifest at ${url} is not JSON`);
+    }
+    const m = parsed;
+    if (m.version !== version) {
+        throw new UpdateSourceError(`the manifest at ${url} declares version ${String(m.version)}, not ${version}`);
+    }
+    if (!m.platforms || typeof m.platforms !== "object") {
+        throw new UpdateSourceError(`the manifest at ${url} lists no platforms`);
+    }
+    const platforms = {};
+    for (const [key, entry] of Object.entries(m.platforms)) {
+        if (!PLATFORM_KEYS.includes(key))
+            continue;
+        const { binary, checksum, size } = entry ?? {};
+        if (typeof binary !== "string" || !isPlainFilename(binary)) {
+            throw new UpdateSourceError(`the manifest at ${url} gives ${key} an unusable file name`);
+        }
+        if (typeof checksum !== "string" || !/^[0-9a-f]{64}$/.test(checksum)) {
+            throw new UpdateSourceError(`the manifest at ${url} gives ${key} no sha256`);
+        }
+        if (typeof size !== "number" || !Number.isInteger(size) || size <= 0 || size > MAX_DOWNLOAD_BYTES) {
+            throw new UpdateSourceError(`the manifest at ${url} gives ${key} an unusable size (${String(size)})`);
+        }
+        platforms[key] = { binary, checksum, size };
+    }
+    return { version, platforms };
+}
+export function entryFor(manifest, platform) {
+    const entry = manifest.platforms[platform];
+    if (!entry) {
+        throw new UpdateSourceError(`release ${manifest.version} has no build for ${platform} — it publishes: ` +
+            `${Object.keys(manifest.platforms).join(", ") || "nothing"}`);
+    }
+    return entry;
+}
+export const binaryUrl = (baseUrl, version, platform, binary) => `${baseUrl}/${RELEASE_PREFIX}/${version}/${platform}/${binary}`;
+/**
+ * Stream a release binary to `dest`, refusing to write more bytes than the
+ * manifest says exist, and return the sha256 of what actually landed.
+ *
+ * The length is enforced while streaming rather than checked afterwards so a
+ * server that answers with an endless body fills no disk.
+ */
+export async function downloadTo(url, dest, expectedSize) {
+    requireSafeOrigin(url, "the download URL");
+    let res;
+    try {
+        res = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS), redirect: "follow" });
+    }
+    catch (e) {
+        throw new UpdateSourceError(`download failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    requireSafeOrigin(res.url || url, "the server that answered the download");
+    if (!res.ok)
+        throw new UpdateSourceError(`${url} returned HTTP ${res.status}`);
+    if (!res.body)
+        throw new UpdateSourceError(`${url} returned no body`);
+    const hash = createHash("sha256");
+    let seen = 0;
+    const body = Readable.fromWeb(res.body);
+    // A path-based stream, deliberately, rather than one wrapped around a
+    // FileHandle: when the transform below aborts an over-long download,
+    // pipeline() destroys the sink, and a stream that shares an fd with a
+    // FileHandle then leaves that handle closed underneath it. Closing it again
+    // throws EBADF from the cleanup path and replaces the real error — which is
+    // exactly the diagnosis a failed update must not lose. One owner for the fd
+    // removes the problem rather than working around it.
+    await pipeline(body, async function* (source) {
+        for await (const chunk of source) {
+            seen += chunk.length;
+            if (seen > expectedSize) {
+                throw new UpdateSourceError(`download is longer than the ${expectedSize} bytes the manifest declares — stopped`);
+            }
+            hash.update(chunk);
+            yield chunk;
+        }
+    }, createWriteStream(dest, { flags: "w", mode: 0o700 }));
+    // fsync before the caller renames: rename is atomic for the directory entry
+    // only, so an unflushed replacement is a truncated binary after a crash.
+    const handle = await open(dest, "r+");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    if (seen !== expectedSize) {
+        throw new UpdateSourceError(`download is ${seen} bytes, the manifest declares ${expectedSize}`);
+    }
+    return hash.digest("hex");
+}

package/dist/update/replace.js

@@ -0,0 +1,182 @@
+/**
+ * Putting the verified bytes where the old binary was.
+ *
+ * The rule throughout: a failure at any point leaves the currently installed
+ * binary exactly as it was, and leaves no temporary file behind. The staged
+ * file is therefore created inside the install directory — so the final step
+ * is a rename within one filesystem rather than a copy across two — and the
+ * caller unlinks it on every error path.
+ */
+import { spawn } from "node:child_process";
+import { constants, existsSync } from "node:fs";
+import { access, chmod, lstat, rename, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+export class ReplaceError extends Error {
+}
+/** The install receipt install.sh and install.ps1 write, in their format. */
+export const RECEIPT_NAME = ".ml-dash.receipt";
+export const receiptContents = (version, platform, sha256, source) => `channel=r2\nversion=${version}\nplatform=${platform}\nsha256=${sha256}\nsource=${source}\n`;
+/**
+ * Directories that belong to another package manager.
+ *
+ * This is the check that actually protects a symlinked install, and it exists
+ * because the obvious one does not: `process.execPath` is already
+ * symlink-resolved by the OS (verified on this host — invoking a compiled
+ * binary through a symlink reports the link's *target*). So when
+ * `~/.local/bin/ml-dash` points into a Homebrew cellar or a pipx venv, the
+ * path this command is handed is the store's real file, and the lstat check
+ * below never sees a link at all. Recognising the store by its path is what is
+ * left, and it is the case worth catching: replacing a file another tool
+ * believes it owns leaves that tool's metadata describing bytes that are no
+ * longer there.
+ */
+const MANAGED_STORES = [
+    { pattern: /(^|\/)\.?nix\/store\//, manager: "Nix", fix: "nix profile upgrade" },
+    { pattern: /(^|\/)(Cellar|linuxbrew|homebrew)\//, manager: "Homebrew", fix: "brew upgrade ml-dash" },
+    { pattern: /(^|\/)site-packages\//, manager: "pip", fix: "pip install --upgrade ml-dash" },
+    { pattern: /(^|\/)(pipx|\.venv|venv)\//, manager: "pipx or a virtualenv", fix: "pipx upgrade ml-dash" },
+    { pattern: /(^|\/)node_modules\//, manager: "npm", fix: "npm install -g @dreamlake/ml-dash@latest" },
+    { pattern: /(^|\/)\.cargo\/(registry|bin)\//, manager: "cargo", fix: "cargo install --force ml-dash" },
+];
+/**
+ * Refuse anything that is not a plain, writable, regular file we can swap, and
+ * anything that belongs to a package manager other than this one.
+ */
+export async function checkReplaceable(target) {
+    const store = MANAGED_STORES.find((s) => s.pattern.test(target));
+    if (store) {
+        throw new ReplaceError(`${target} is inside a directory ${store.manager} manages, so it is not this command's to replace.\n` +
+            `  Replacing it would leave ${store.manager} describing bytes that are no longer there.\n` +
+            `  Update it with:  ${store.fix}`);
+    }
+    let info;
+    try {
+        info = await lstat(target);
+    }
+    catch (e) {
+        throw new ReplaceError(`cannot inspect ${target}: ${e.message}`);
+    }
+    if (info.isSymbolicLink()) {
+        throw new ReplaceError(`${target} is a symlink, so it is managed by something else (a package manager, or a shim).\n` +
+            `  Update it with whatever installed it, or install a standalone copy with install.sh.`);
+    }
+    if (!info.isFile()) {
+        throw new ReplaceError(`${target} is not a regular file`);
+    }
+    const dir = path.dirname(target);
+    try {
+        await access(dir, constants.W_OK);
+    }
+    catch {
+        throw new ReplaceError(`cannot write to ${dir}.\n` +
+            `  ml-dash update replaces the binary in place, so that directory has to be writable.\n` +
+            `  Re-run with the permissions that own it, or reinstall into a directory you own:\n` +
+            `      curl -fsSL https://pub-42e1dcc7de574d4a92984865fdc95f10.r2.dev/install.sh | sh -s -- --install-dir ~/.local/bin`);
+    }
+}
+/** The mode of the binary being replaced, so an update does not widen or narrow it. */
+export async function currentMode(target) {
+    try {
+        return (await stat(target)).mode & 0o777;
+    }
+    catch {
+        return 0o755;
+    }
+}
+/**
+ * POSIX: rename(2) over the running binary.
+ *
+ * Replacing a running executable is fine here — the kernel keeps the old inode
+ * alive for the current process and the directory entry flips atomically — so
+ * the update takes effect for the next invocation with no helper and no window
+ * in which `ml-dash` is missing from PATH.
+ */
+export async function swapInPlace(swap) {
+    await chmod(swap.staged, await currentMode(swap.target));
+    await rename(swap.staged, swap.target);
+    await writeReceiptIfOwned(swap);
+}
+/**
+ * Only where the installer already left one. Writing a receipt that was never
+ * there would be this command claiming an install it did not make; not
+ * refreshing one that is there would leave install.sh convinced the binary had
+ * been tampered with, and refusing to run without --force.
+ */
+async function writeReceiptIfOwned(swap) {
+    const receipt = path.join(path.dirname(swap.target), RECEIPT_NAME);
+    if (!existsSync(receipt))
+        return;
+    try {
+        await writeFile(receipt, receiptContents(swap.version, swap.platform, swap.sha256, swap.source));
+    }
+    catch {
+        // The binary is already updated and correct; a stale receipt only costs a
+        // --force on some future install.sh run.
+    }
+}
+/** Single-quote a string for PowerShell, where '' is the escape for '. */
+const psQuote = (s) => `'${s.replace(/'/g, "''")}'`;
+/**
+ * The PowerShell that finishes a Windows update after this process is gone.
+ *
+ * Windows holds an open image section on a running .exe, so the rename in
+ * swapInPlace fails with a sharing violation rather than succeeding. The
+ * smallest correct answer is to wait for this exact PID to exit and then do
+ * the same move — no service, no scheduled task, nothing left installed. The
+ * script deletes the staged file if the move fails and deletes itself last, so
+ * neither it nor the download survives a failure.
+ */
+export function windowsHelperScript(swap, pid) {
+    const receipt = path.join(path.dirname(swap.target), RECEIPT_NAME);
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        // An already-exited PID makes Wait-Process throw; that is the success case.
+        `try { Wait-Process -Id ${pid} -Timeout 300 } catch { }`,
+        "try {",
+        `  Move-Item -LiteralPath ${psQuote(swap.staged)} -Destination ${psQuote(swap.target)} -Force`,
+        `  if (Test-Path -LiteralPath ${psQuote(receipt)}) {`,
+        `    @(${[
+            `'channel=r2'`,
+            psQuote(`version=${swap.version}`),
+            psQuote(`platform=${swap.platform}`),
+            psQuote(`sha256=${swap.sha256}`),
+            psQuote(`source=${swap.source}`),
+        ].join(", ")}) | Set-Content -LiteralPath ${psQuote(receipt)} -Encoding ASCII`,
+        "  }",
+        "} catch {",
+        `  Remove-Item -LiteralPath ${psQuote(swap.staged)} -Force -ErrorAction SilentlyContinue`,
+        "} finally {",
+        "  Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue",
+        "}",
+        "",
+    ].join("\n");
+}
+export const windowsHelperArgs = (helperPath) => [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    helperPath,
+];
+/**
+ * Write the helper and hand it off. Detached and unref'd so `ml-dash update`
+ * can exit normally — which is the thing the helper is waiting for.
+ */
+export async function scheduleWindowsSwap(swap, pid = process.pid) {
+    const helper = path.join(path.dirname(swap.target), `.ml-dash.update.${pid}.ps1`);
+    await writeFile(helper, windowsHelperScript(swap, pid), "utf8");
+    try {
+        const child = spawn("powershell.exe", windowsHelperArgs(helper), {
+            detached: true,
+            stdio: "ignore",
+            shell: false,
+            windowsHide: true,
+        });
+        child.unref();
+    }
+    catch (e) {
+        await rm(helper, { force: true });
+        throw new ReplaceError(`cannot start the updater: ${e.message}`);
+    }
+}

package/dist/version.js

@@ -1,3 +1,3 @@
 // Rewritten by scripts/build-release.ts at release time so a compiled binary
 // can never misreport itself. The npm channel reads the same constant.
-export const VERSION = "0.1.0";
+export const VERSION = "0.1.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreamlake/ml-dash",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "ml-dash \u2014 ML experiment tracking CLI. Authenticate, inspect projects and experiments, and move experiment data to and from an ML-Dash server.",
   "type": "module",
   "main": "dist/index.js",
@@ -34,15 +34,17 @@
     "build": "tsc",
     "cli": "tsx src/index.ts",
     "typecheck": "tsc --noEmit",
-    "test": "npm run build && node --import tsx --test test/*.test.ts",
+    "test": "npm run build && node --import tsx --test --test-timeout=180000 test/*.test.ts",
     "build:release": "bun run scripts/build-release.ts"
   },
   "dependencies": {
-    "qrcode": "^1.5.4"
+    "qrcode": "^1.5.4",
+    "semver": "^7.8.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",
     "@types/qrcode": "^1.5.5",
+    "@types/semver": "^7.8.0",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0"
   }