crabot 0.1.2 → 0.1.4

package/README.md

@@ -5,14 +5,19 @@ Local-first AI agent runtime with a gateway, operator console, and CLI.
 ## Requirements
 
 `crabot` runs as a self-contained standalone binary with the runtime embedded —
-the program itself needs no Bun or Node install. On install, the package
-downloads the prebuilt binary matching your platform from the matching GitHub
-release and caches it; a small launcher hands off to it (the launcher runs under
-the Node that npm already provides). If the download is skipped at install time,
-it happens automatically on first run.
+the program itself needs no Bun or Node install. The package ships no install
+script; on the first `crabot` run a small launcher (running under the Node that
+npm already provides) downloads the prebuilt binary matching your platform from
+the matching GitHub release, verifies its checksum, unpacks it (the asset is
+zstd-compressed — ~16 MB to download vs ~63 MB on disk), and caches it for later
+runs. Unpacking uses `node:zlib`, so the launcher needs **Node ≥ 22.15**.
 
 Supported platforms: Linux (x64, arm64), macOS (x64, arm64), Windows (x64).
 
+If you are on an older Node, download the standalone binary for your platform
+directly from the [GitHub releases](https://github.com/gotry-io/Crabot/releases)
+(decompress the `.zst` asset) and put it on your `PATH` — it needs no Node.
+
 ## Install
 
 ```sh

package/bin/crabot.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Launcher for the `crabot` distribution. The real program is a standalone executable (the Bun
-// runtime is embedded) downloaded from the matching GitHub release by the postinstall hook, or
-// lazily here on first run if that was skipped. No Bun or Node runtime is required to run crabot.
+// runtime is embedded) downloaded from the matching GitHub release lazily here on first run (the
+// package ships no install script). No Bun or Node runtime is required to run crabot.
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { ensureBinary } from "../scripts/install.mjs";

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "crabot",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Local-first AI agent runtime with a gateway, operator console, and CLI.",
   "type": "module",
   "bin": {
     "crabot": "bin/crabot.mjs"
   },
-  "scripts": {
-    "postinstall": "node scripts/install.mjs"
+  "engines": {
+    "node": ">=22.15.0"
   },
   "files": [
     "bin",

package/scripts/install.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 // Downloads the crabot standalone binary for the host platform from the GitHub release that matches
-// this package's version, verifies its SHA-256, and caches it. Run by the postinstall hook and
-// lazily by the launcher if the binary is not present yet (e.g. install ran with --ignore-scripts).
-// The binary embeds the Bun runtime, so running crabot needs no Bun or Node install.
+// this package's version, verifies its SHA-256, decompresses it, and caches it. Invoked by the
+// launcher on first run when the binary is not cached yet; the package ships no install script, so
+// nothing runs at install time. The release asset is zstd-compressed (the binary is ~63 MB raw but
+// ~16 MB compressed), so the launcher's Node must provide node:zlib zstd (Node >= 22.15, per the
+// package `engines`). The binary itself embeds the Bun runtime, so running crabot needs no runtime.
 import { createHash } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import zlib from "node:zlib";
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 const { version } = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
@@ -39,6 +42,56 @@ async function fetchBuffer(url) {
   return Buffer.from(await response.arrayBuffer());
 }
 
+function formatDownloadProgress(received, total) {
+  const mb = (bytes) => (bytes / 1_048_576).toFixed(1);
+  return total > 0
+    ? `${Math.floor((received / total) * 100)}% (${mb(received)}/${mb(total)} MB)`
+    : `${mb(received)} MB`;
+}
+
+// Fetch a URL while reporting progress to stderr: one in-place updating line on a TTY, or milestone
+// lines (every 20%) when output is redirected. The binary is the only large download, so only it
+// streams; the size only grows, so the TTY line never leaves stale characters behind.
+async function downloadWithProgress(url, label) {
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) {
+    throw new Error(`request failed (${response.status}) for ${url}`);
+  }
+  if (response.body === null) {
+    return Buffer.from(await response.arrayBuffer());
+  }
+
+  const total = Number(response.headers.get("content-length")) || 0;
+  const isTty = process.stderr.isTTY === true;
+  const reader = response.body.getReader();
+  const chunks = [];
+  let received = 0;
+  let nextMilestone = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+
+    chunks.push(value);
+    received += value.length;
+    if (isTty) {
+      process.stderr.write(`\rcrabot: downloading ${label} ${formatDownloadProgress(received, total)}`);
+    } else if (total > 0 && (received / total) * 100 >= nextMilestone) {
+      process.stderr.write(`crabot: downloading ${label} ${formatDownloadProgress(received, total)}\n`);
+      nextMilestone += 20;
+    }
+  }
+
+  if (isTty) {
+    process.stderr.write("\n");
+  } else if (total === 0) {
+    process.stderr.write(`crabot: downloaded ${label} (${formatDownloadProgress(received, total)})\n`);
+  }
+
+  return Buffer.concat(chunks);
+}
+
 export async function ensureBinary() {
   const target = cachedBinaryPath();
   if (existsSync(target)) {
@@ -51,19 +104,30 @@ export async function ensureBinary() {
     throw new Error(`crabot: no prebuilt binary for ${key}. See https://github.com/${repository}/releases`);
   }
 
+  if (typeof zlib.zstdDecompressSync !== "function") {
+    throw new Error(
+      `crabot: the prebuilt binary is zstd-compressed and needs Node >= 22.15 to unpack (this is ` +
+      `${process.version}). Upgrade Node, or download the standalone binary for your platform from ` +
+      `https://github.com/${repository}/releases and put it on your PATH.`
+    );
+  }
+
   const base = `https://github.com/${repository}/releases/download/v${version}`;
-  process.stderr.write(`crabot: downloading ${asset} (v${version})...\n`);
-  const [binary, checksum] = await Promise.all([
-    fetchBuffer(`${base}/${asset}`),
-    fetchBuffer(`${base}/${asset}.sha256`).then((buffer) => buffer.toString("utf8"))
+  const [compressed, checksum] = await Promise.all([
+    downloadWithProgress(`${base}/${asset}.zst`, `${asset} (v${version})`),
+    fetchBuffer(`${base}/${asset}.zst.sha256`).then((buffer) => buffer.toString("utf8"))
   ]);
 
+  // Verify the bytes that crossed the network, then decompress (zstd's frame checksum transitively
+  // integrity-checks the result).
   const expected = checksum.trim().split(/\s+/u)[0];
-  const actual = createHash("sha256").update(binary).digest("hex");
+  const actual = createHash("sha256").update(compressed).digest("hex");
   if (expected !== actual) {
-    throw new Error(`crabot: checksum mismatch for ${asset} (expected ${expected}, got ${actual})`);
+    throw new Error(`crabot: checksum mismatch for ${asset}.zst (expected ${expected}, got ${actual})`);
   }
 
+  const binary = zlib.zstdDecompressSync(compressed);
+
   mkdirSync(dirname(target), { recursive: true });
   // Write to a sibling temp file then rename, so a concurrent install never sees a partial binary.
   const temporary = `${target}.${process.pid}.download`;
@@ -74,11 +138,3 @@ export async function ensureBinary() {
   renameSync(temporary, target);
   return target;
 }
-
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-  // postinstall: pre-warm the cache but never fail the install; the launcher retries on first run.
-  ensureBinary().then(
-    (path) => process.stdout.write(`crabot: ready at ${path}\n`),
-    (error) => process.stderr.write(`crabot: will download on first run (${error.message})\n`)
-  );
-}