crabot 0.1.0 → 0.1.2

package/README.md

@@ -4,17 +4,30 @@ Local-first AI agent runtime with a gateway, operator console, and CLI.
 
 ## Requirements
 
-Crabot runs on the [Bun](https://bun.sh) runtime (>= 1.3.10). Bun must be
-installed and available on your `PATH`.
+`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.
+
+Supported platforms: Linux (x64, arm64), macOS (x64, arm64), Windows (x64).
 
 ## Install
 
 ```sh
+npm install -g crabot
+# or with bun
 bun install -g crabot
-# or run it once without installing
-bunx crabot update status
+# run once without installing
+npx crabot update status
 ```
 
+For an install that fetches nothing, download the standalone binary for your
+platform directly from the
+[GitHub releases](https://github.com/gotry-io/Crabot/releases) and put it on
+your `PATH`.
+
 ## Usage
 
 ```sh

package/bin/crabot.mjs

@@ -0,0 +1,57 @@
+#!/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.
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { ensureBinary } from "../scripts/install.mjs";
+
+let binaryPath;
+try {
+  binaryPath = await ensureBinary();
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exit(1);
+}
+
+// The downloaded binary lives at a version-pinned cache path that `npm update` orphans, so its own
+// process.execPath is not a stable launch target. Expose the stable command that re-launches crabot —
+// this launcher under Node, which re-resolves the matching binary on demand — so `crabot service
+// install` writes a service unit that survives upgrades. This launcher path is stable across upgrades
+// (npm replaces the package in place).
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+  env: {
+    ...process.env,
+    CRABOT_LAUNCH_VECTOR: JSON.stringify([process.execPath, fileURLToPath(import.meta.url)])
+  }
+});
+
+// Forward termination signals so `crabot serve` shuts the gateway down gracefully when a process
+// manager signals this wrapper. Unsupported signal names throw on registration; ignore those.
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT", "SIGBREAK"]) {
+  try {
+    process.on(signal, () => {
+      if (child.exitCode === null) {
+        child.kill(signal);
+      }
+    });
+  } catch {
+    // signal not available on this platform
+  }
+}
+
+child.on("error", (error) => {
+  process.stderr.write(`crabot: failed to launch ${binaryPath}: ${error.message}\n`);
+  process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    // Re-raise the same signal so this wrapper reports the child's termination cause.
+    process.removeAllListeners();
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 0);
+});

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "crabot",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Local-first AI agent runtime with a gateway, operator console, and CLI.",
   "type": "module",
   "bin": {
-    "crabot": "dist/main.js"
+    "crabot": "bin/crabot.mjs"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.mjs"
   },
   "files": [
-    "dist",
+    "bin",
+    "scripts",
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "bun": ">=1.3.10"
-  },
   "license": "MIT",
   "author": "Kyle",
   "homepage": "https://github.com/gotry-io/Crabot#readme",
@@ -29,7 +30,6 @@
     "agent",
     "ai",
     "automation",
-    "cli",
-    "bun"
+    "cli"
   ]
 }

package/scripts/install.mjs

@@ -0,0 +1,84 @@
+#!/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.
+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";
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const { version } = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+const repository = "gotry-io/Crabot";
+
+// process.platform-process.arch -> GitHub release asset name.
+const assets = {
+  "linux-x64": "crabot-linux-x64",
+  "linux-arm64": "crabot-linux-arm64",
+  "darwin-x64": "crabot-macos-x64",
+  "darwin-arm64": "crabot-macos-arm64",
+  "win32-x64": "crabot-windows-x64.exe"
+};
+
+function cachedBinaryPath() {
+  const base = process.platform === "win32"
+    ? process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local")
+    : process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
+  const name = process.platform === "win32" ? "crabot.exe" : "crabot";
+  return join(base, "crabot", `v${version}`, name);
+}
+
+async function fetchBuffer(url) {
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) {
+    throw new Error(`request failed (${response.status}) for ${url}`);
+  }
+
+  return Buffer.from(await response.arrayBuffer());
+}
+
+export async function ensureBinary() {
+  const target = cachedBinaryPath();
+  if (existsSync(target)) {
+    return target;
+  }
+
+  const key = `${process.platform}-${process.arch}`;
+  const asset = assets[key];
+  if (asset === undefined) {
+    throw new Error(`crabot: no prebuilt binary for ${key}. See https://github.com/${repository}/releases`);
+  }
+
+  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 expected = checksum.trim().split(/\s+/u)[0];
+  const actual = createHash("sha256").update(binary).digest("hex");
+  if (expected !== actual) {
+    throw new Error(`crabot: checksum mismatch for ${asset} (expected ${expected}, got ${actual})`);
+  }
+
+  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`;
+  writeFileSync(temporary, binary);
+  if (process.platform !== "win32") {
+    chmodSync(temporary, 0o755);
+  }
+  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`)
+  );
+}