@foundingbot/x 0.0.48 → 0.1.0

package/bin/foundingbot-x.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+// The `@foundingbot/x` npm package. Downloads this version's CLI archive from the
+// release into <home>/runtime/versions/<version> (the folder the install
+// scripts and `foundingbot-x update` use), verifies it against the release's SHA256SUMS,
+// then runs it. `dist/bin.mjs` re-enters here for background services
+// installed before 0.0.41, which start the npm package with Node and talk to
+// it over an IPC channel.
+import { spawn, spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const { version } = JSON.parse(
+  fs.readFileSync(path.join(import.meta.dirname, "../package.json"), "utf8"),
+);
+
+const SUPPORTED = ["darwin-arm64", "linux-arm64", "linux-x64", "win32-arm64", "win32-x64"];
+
+// Founding Bot X: people set FOUNDINGBOT_X_* variables. Our own processes, which
+// mark the environment, pass T3CODE_* ones (see foundingBotXEnvironment.ts).
+const setting = (name) =>
+  process.env.T3CODE_FOUNDINGBOT_X_ENV === "1"
+    ? process.env[`T3CODE_${name}`]
+    : process.env[`FOUNDINGBOT_X_${name}`];
+
+function t3Home() {
+  const raw = (setting("HOME") || "").trim();
+  if (raw === "") return path.join(os.homedir(), ".foundingbot-x");
+  if (raw === "~") return os.homedir();
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) return path.join(os.homedir(), raw.slice(2));
+  return path.resolve(raw);
+}
+
+async function get(url) {
+  const response = await fetch(url);
+  if (response.status === 404) {
+    throw new Error(
+      `${url} does not exist yet. If ${version} was just released, try again in a few minutes.`,
+    );
+  }
+  if (!response.ok) throw new Error(`GET ${url} returned HTTP ${response.status}`);
+  return response;
+}
+
+/** Downloads `url` to `file` and returns its sha256, showing progress on a terminal. */
+async function download(url, file) {
+  const response = await get(url);
+  const total = Number(response.headers.get("content-length")) || 0;
+  const hash = crypto.createHash("sha256");
+  const out = fs.openSync(file, "w");
+  const tty = process.stderr.isTTY;
+  let received = 0;
+  let shown = -1;
+  try {
+    for await (const chunk of response.body) {
+      hash.update(chunk);
+      fs.writeSync(out, chunk);
+      received += chunk.byteLength;
+      // Redraw once per percent (or per MB without a length), not per chunk.
+      const step = total ? Math.floor((received * 100) / total) : Math.floor(received / 1048576);
+      if (tty && step !== shown) {
+        shown = step;
+        const percent = total ? ` ${step}%` : "";
+        process.stderr.write(
+          `\r\x1b[2Kfoundingbot-x: downloading Founding Bot X ${version}${percent} (${(received / 1048576).toFixed(1)} MB)`,
+        );
+      }
+    }
+  } finally {
+    fs.closeSync(out);
+    if (tty) process.stderr.write("\r\x1b[2K");
+  }
+  return hash.digest("hex");
+}
+
+async function install(dir, key) {
+  const archive = `foundingbot-x-${version}-${key}.${process.platform === "win32" ? "zip" : "tar.gz"}`;
+  const base = (setting("RELEASE_BASE_URL") || "https://founding.bot/x/releases/download").replace(
+    /\/+$/,
+    "",
+  );
+  const sums = await (await get(`${base}/v${version}/SHA256SUMS`)).text();
+  const expected = /^([0-9a-f]{64})\s+\*?(.+)$/im;
+  const line = sums
+    .split(/\r?\n/)
+    .map((l) => expected.exec(l.trim()))
+    .find((m) => m && m[2] === archive);
+  if (!line) throw new Error(`${archive} is not listed in the release's SHA256SUMS`);
+
+  // Extract beside the final folder and rename it into place, so an
+  // interrupted download never leaves a half-installed version behind.
+  fs.mkdirSync(path.dirname(dir), { recursive: true });
+  const staging = fs.mkdtempSync(`${dir}.staging-`);
+  try {
+    const file = path.join(staging, archive);
+    if ((await download(`${base}/v${version}/${archive}`, file)) !== line[1].toLowerCase()) {
+      throw new Error(`checksum mismatch for ${archive}`);
+    }
+    // Windows' own tar.exe reads zip; a Git-for-Windows tar on PATH cannot.
+    const tar =
+      process.platform === "win32" ? `${process.env.SystemRoot}\\System32\\tar.exe` : "tar";
+    const extract = spawnSync(tar, ["-xf", file, "-C", staging, "--strip-components=1"], {
+      stdio: "inherit",
+    });
+    if (extract.status !== 0) throw new Error(`could not extract ${archive}`);
+    fs.rmSync(file);
+    fs.writeFileSync(path.join(staging, ".install-complete"), `${version}\n`);
+    publish(staging, dir);
+  } finally {
+    fs.rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+const isComplete = (dir) => {
+  try {
+    return fs.readFileSync(path.join(dir, ".install-complete"), "utf8").trim() === version;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Moves a finished staging folder to `dir`. Rename never replaces an existing
+ * folder, so a complete install another launcher (or `foundingbot-x update`) published
+ * first is kept, never deleted from under a running process. Only a folder
+ * without the completion marker, left by an interrupted older installer, is
+ * cleared before trying again.
+ */
+function publish(staging, dir) {
+  try {
+    fs.renameSync(staging, dir);
+  } catch (error) {
+    if (isComplete(dir)) return;
+    if (!fs.existsSync(dir)) throw error;
+    fs.rmSync(dir, { recursive: true, force: true });
+    fs.renameSync(staging, dir);
+  }
+}
+
+async function main() {
+  const key = `${process.platform}-${process.arch}`;
+  if (!SUPPORTED.includes(key)) {
+    throw new Error(
+      `no Founding Bot X CLI build is available for ${key} (supported: ${SUPPORTED.join(", ")}).\n` +
+        "The desktop app is at https://founding.bot/x/download",
+    );
+  }
+  const dir = path.join(t3Home(), "runtime", "versions", version);
+  if (!isComplete(dir)) await install(dir, key);
+
+  // A service launcher talks to its server over IPC; pass that channel and
+  // signals through. In a terminal, Ctrl-C already reaches the child directly,
+  // so forwarding SIGINT too would deliver it twice.
+  const ipc = process.send !== undefined;
+  const child = spawn(
+    path.join(dir, process.platform === "win32" ? "foundingbot-x.exe" : "foundingbot-x"),
+    process.argv.slice(2),
+    {
+      stdio: ipc ? ["inherit", "inherit", "inherit", "ipc"] : "inherit",
+      // The executable lives in the home folder, so this is how it knows npm launched it.
+      // Founding Bot X: under both names, since the executable reads one or the other.
+      env: {
+        ...process.env,
+        FOUNDINGBOT_X_NPM_LAUNCHER_PATH: import.meta.filename,
+        T3CODE_NPM_LAUNCHER_PATH: import.meta.filename,
+      },
+    },
+  );
+  if (ipc) {
+    process.on("message", (message) => child.connected && child.send(message));
+    child.on("message", (message) => process.connected && process.send(message));
+    process.on("disconnect", () => child.connected && child.disconnect());
+  }
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => (ipc || signal !== "SIGINT") && child.kill(signal));
+  }
+  child.on("error", (error) => fail(error));
+  child.on("exit", (code, signal) =>
+    process.exit(code ?? 128 + (os.constants.signals[signal] || 1)),
+  );
+}
+
+function fail(error) {
+  process.stderr.write(`foundingbot-x: ${error.message}\n`);
+  process.exit(1);
+}
+
+await main().catch(fail);

package/dist/bin.mjs

@@ -1,27 +1,2 @@
-import { spawn } from "node:child_process";
-import { constants } from "node:os";
-import { dirname, join } from "node:path";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const executableName = process.platform === "win32" ? "foundingbot-x.exe" : "foundingbot-x";
-const executable = join(dirname(require.resolve("@foundingbot/x-" + process.platform + "-" + process.arch + "/package.json")), executableName);
-const ipc = process.send !== undefined;
-const child = spawn(executable, process.argv.slice(2), {
-  stdio: ipc ? ["inherit", "inherit", "inherit", "ipc"] : "inherit",
-});
-const fail = (error) => {
-  if (!error) return;
-  process.stderr.write("foundingbot-x: " + error.message + "\n");
-  child.kill("SIGTERM");
-  process.exitCode = 1;
-};
-if (ipc) {
-  process.on("message", (message) => { if (child.connected) child.send(message, fail); });
-  child.on("message", (message) => { if (process.connected) process.send(message, fail); });
-  process.on("disconnect", () => { if (child.connected) child.disconnect(); });
-}
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-  process.on(signal, () => child.kill(signal));
-}
-child.on("error", (error) => { fail(error); process.exit(1); });
-child.on("exit", (code, signal) => process.exit(code ?? 128 + (constants.signals[signal] || 1)));
+// Background services installed before 0.0.41 start the npm package from this path.
+import "../bin/foundingbot-x.mjs";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@foundingbot/x",
-  "version": "0.0.48",
-  "description": "Founding Bot X CLI. Installs the self-contained executable for this platform.",
+  "version": "0.1.0",
+  "description": "Founding Bot X CLI. Downloads the self-contained executable for this platform from the release.",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -9,17 +9,13 @@
     "directory": "apps/server"
   },
   "bin": {
-    "foundingbot-x": "./bin/foundingbot-x.js"
+    "foundingbot-x": "./bin/foundingbot-x.mjs"
   },
   "files": [
     "bin",
     "dist"
   ],
-  "optionalDependencies": {
-    "@foundingbot/x-darwin-arm64": "0.0.48",
-    "@foundingbot/x-linux-arm64": "0.0.48",
-    "@foundingbot/x-linux-x64": "0.0.48",
-    "@foundingbot/x-win32-arm64": "0.0.48",
-    "@foundingbot/x-win32-x64": "0.0.48"
+  "engines": {
+    "node": ">=20.11"
   }
 }

package/bin/foundingbot-x.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-const { spawnSync } = require("node:child_process");
-const { constants } = require("node:os");
-const { dirname, join } = require("node:path");
-
-const SUPPORTED = ["darwin-arm64", "linux-arm64", "linux-x64", "win32-arm64", "win32-x64"];
-const key = process.platform + "-" + process.arch;
-
-let packageDir;
-try {
-  packageDir = dirname(require.resolve("@foundingbot/x-" + key + "/package.json"));
-} catch {
-  process.stderr.write(
-    [
-      "foundingbot-x: no Founding Bot X CLI build is available for this platform (" + key + ").",
-      "Supported platforms: " + SUPPORTED.join(", ") + ".",
-      "If yours is listed, reinstall @foundingbot/x so npm fetches its optional dependency.",
-      "The desktop app and release archives are at https://founding.bot",
-      "",
-    ].join("\n"),
-  );
-  process.exit(1);
-}
-
-const executable = join(packageDir, process.platform === "win32" ? "foundingbot-x.exe" : "foundingbot-x");
-const result = spawnSync(executable, process.argv.slice(2), { stdio: "inherit" });
-if (result.error) {
-  process.stderr.write("foundingbot-x: failed to start " + executable + ": " + result.error.message + "\n");
-  process.exit(1);
-}
-// A child killed by a signal has no status; report it the way a shell would.
-process.exit(result.status ?? 128 + (constants.signals[result.signal] || 1));