@rockboxd/cli 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# @rockboxd/cli
+
+Installs the [Rockbox Daemon](https://github.com/tsirysndr/rockboxd) command-line
+tools — the `rockbox` CLI and the `rockboxd` daemon — by downloading the latest
+prebuilt binaries from GitHub releases.
+
+## Install
+
+```sh
+npm install -g @rockboxd/cli
+```
+
+Then:
+
+```sh
+rockboxd            # start the daemon
+rockbox --help      # control it from the CLI
+```
+
+## How it works
+
+The `postinstall` script resolves the latest release of
+`tsirysndr/rockboxd`, downloads the tarball matching your platform, verifies
+its sha256 checksum against the published `.sha256` asset, and extracts the
+`rockbox` and `rockboxd` binaries into the package's `native/` directory. The
+`rockbox` / `rockboxd` commands are thin Node shims that exec those binaries.
+
+## Supported platforms
+
+| Platform | Architectures   |
+| -------- | --------------- |
+| macOS    | arm64, x86_64   |
+| Linux    | x86_64, aarch64 |
+| FreeBSD  | x86_64          |
+
+## Environment variables
+
+| Variable                    | Effect                                                           |
+| --------------------------- | ---------------------------------------------------------------- |
+| `ROCKBOX_VERSION`           | Pin a specific release tag (e.g. `2026.07.28`) instead of latest |
+| `GITHUB_TOKEN` / `GH_TOKEN` | Authenticate GitHub API requests (avoids rate limits in CI)      |
+
+## License
+
+GPL-2.0, same as Rockbox.

package/bin/rockbox.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const bin = path.join(__dirname, "..", "native", "rockbox");
+if (!fs.existsSync(bin)) {
+  console.error(
+    "@rockboxd/cli: rockbox binary not found. Reinstall the package " +
+      "(the postinstall step downloads it), or run `node install.js` " +
+      "inside the package directory."
+  );
+  process.exit(1);
+}
+
+const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  process.exit(code === null ? 1 : code);
+});
+child.on("error", (err) => {
+  console.error(`@rockboxd/cli: failed to launch rockbox: ${err.message}`);
+  process.exit(1);
+});

package/bin/rockboxd.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const bin = path.join(__dirname, "..", "native", "rockboxd");
+if (!fs.existsSync(bin)) {
+  console.error(
+    "@rockboxd/cli: rockboxd binary not found. Reinstall the package " +
+      "(the postinstall step downloads it), or run `node install.js` " +
+      "inside the package directory."
+  );
+  process.exit(1);
+}
+
+const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  process.exit(code === null ? 1 : code);
+});
+child.on("error", (err) => {
+  console.error(`@rockboxd/cli: failed to launch rockboxd: ${err.message}`);
+  process.exit(1);
+});

package/install.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * Postinstall: download the rockbox CLI binaries from GitHub releases.
+ *
+ * Resolves the latest release of tsirysndr/rockboxd (or the tag pinned via
+ * ROCKBOX_VERSION), picks the tarball matching the current platform, verifies
+ * its sha256 against the published .sha256 asset, and extracts the `rockbox`
+ * and `rockboxd` binaries into ./native.
+ */
+
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const https = require("https");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const REPO = "tsirysndr/rockboxd";
+const NATIVE_DIR = path.join(__dirname, "native");
+const BINARIES = ["rockbox", "rockboxd"];
+const MAX_REDIRECTS = 10;
+
+function platformSlug() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const table = {
+    "darwin-arm64": "aarch64-darwin",
+    "darwin-x64": "x86_64-darwin",
+    "linux-arm64": "aarch64-linux",
+    "linux-x64": "amd64-linux",
+    "freebsd-x64": "x86_64-freebsd",
+  };
+  const slug = table[`${platform}-${arch}`];
+  if (!slug) {
+    console.error(
+      `@rockboxd/cli: no prebuilt binaries for ${platform}-${arch}.\n` +
+        `See https://github.com/${REPO} for building from source.`
+    );
+    process.exit(1);
+  }
+  return slug;
+}
+
+function requestHeaders() {
+  const headers = {
+    "User-Agent": "@rockboxd/cli npm installer",
+    Accept: "application/octet-stream, application/json",
+  };
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return headers;
+}
+
+function fetch(url, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirects > MAX_REDIRECTS) {
+      reject(new Error(`too many redirects fetching ${url}`));
+      return;
+    }
+    https
+      .get(url, { headers: requestHeaders() }, (res) => {
+        if (
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          res.resume();
+          resolve(fetch(new URL(res.headers.location, url).href, redirects + 1));
+          return;
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          reject(new Error(`GET ${url} failed with HTTP ${res.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      })
+      .on("error", reject);
+  });
+}
+
+async function resolveVersion() {
+  const pinned = process.env.ROCKBOX_VERSION;
+  if (pinned) return pinned.replace(/^v/, "");
+  const body = await fetch(
+    `https://api.github.com/repos/${REPO}/releases/latest`
+  );
+  const release = JSON.parse(body.toString("utf8"));
+  if (!release.tag_name) {
+    throw new Error(`could not resolve latest release of ${REPO}`);
+  }
+  return release.tag_name;
+}
+
+async function verifyChecksum(tarball, checksumUrl, assetName) {
+  let expected;
+  try {
+    const body = await fetch(checksumUrl);
+    expected = body.toString("utf8").trim().split(/\s+/)[0].toLowerCase();
+  } catch (err) {
+    console.warn(
+      `@rockboxd/cli: checksum file unavailable (${err.message}), skipping verification`
+    );
+    return;
+  }
+  const actual = crypto.createHash("sha256").update(tarball).digest("hex");
+  if (actual !== expected) {
+    throw new Error(
+      `sha256 mismatch for ${assetName}: expected ${expected}, got ${actual}`
+    );
+  }
+}
+
+function extract(tarballPath) {
+  fs.mkdirSync(NATIVE_DIR, { recursive: true });
+  const result = spawnSync(
+    "tar",
+    ["-xzf", tarballPath, "-C", NATIVE_DIR, ...BINARIES],
+    { stdio: ["ignore", "inherit", "inherit"] }
+  );
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`tar exited with status ${result.status}`);
+  }
+  for (const name of BINARIES) {
+    const bin = path.join(NATIVE_DIR, name);
+    if (!fs.existsSync(bin)) {
+      throw new Error(`archive did not contain the ${name} binary`);
+    }
+    fs.chmodSync(bin, 0o755);
+  }
+}
+
+async function main() {
+  const slug = platformSlug();
+  const version = await resolveVersion();
+  const assetName = `rockbox_${version}_${slug}.tar.gz`;
+  const base = `https://github.com/${REPO}/releases/download/${version}`;
+
+  console.log(`@rockboxd/cli: downloading ${assetName} (${version})...`);
+  const tarball = await fetch(`${base}/${assetName}`);
+  await verifyChecksum(tarball, `${base}/${assetName}.sha256`, assetName);
+
+  const tmp = path.join(
+    os.tmpdir(),
+    `rockboxd-cli-${process.pid}-${assetName}`
+  );
+  fs.writeFileSync(tmp, tarball);
+  try {
+    extract(tmp);
+  } finally {
+    fs.rmSync(tmp, { force: true });
+  }
+  console.log(
+    `@rockboxd/cli: installed ${BINARIES.join(", ")} ${version} to ${NATIVE_DIR}`
+  );
+}
+
+main().catch((err) => {
+  console.error(`@rockboxd/cli: install failed: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@rockboxd/cli",
+  "version": "0.1.0",
+  "description": "Rockbox Daemon — installs the rockbox CLI and rockboxd daemon binaries from GitHub releases",
+  "license": "GPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tsirysndr/rockboxd.git"
+  },
+  "homepage": "https://github.com/tsirysndr/rockboxd",
+  "bugs": {
+    "url": "https://github.com/tsirysndr/rockboxd/issues"
+  },
+  "keywords": [
+    "rockbox",
+    "rockboxd",
+    "audio",
+    "music",
+    "player",
+    "daemon",
+    "cli"
+  ],
+  "bin": {
+    "rockbox": "bin/rockbox.js",
+    "rockboxd": "bin/rockboxd.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "files": [
+    "install.js",
+    "bin/rockbox.js",
+    "bin/rockboxd.js",
+    "README.md"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "freebsd"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}