linkr-bee-cli 0.0.0-stage → 0.1.2

package/bin/bee-cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+'use strict'
+/**
+ * `npx linkr-bee-cli …` / the installed `bee-cli` shim.
+ *
+ * The arguments go straight to the real program, with the parent's stdio so a
+ * TUI or an interactive session behaves as if it had been run directly, and
+ * the exit status is the target program's own.
+ */
+
+const { spawn } = require('node:child_process')
+const { ensureBinary } = require('../lib/ensure')
+
+async function main() {
+  let binary
+  try {
+    binary = await ensureBinary()
+  } catch (error) {
+    process.stderr.write(`bee-cli: ${error.message}\n`)
+    process.exit(1)
+  }
+  const child = spawn(binary, process.argv.slice(2), { stdio: 'inherit' })
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT']) {
+    process.on(signal, () => {
+      try {
+        child.kill(signal)
+      } catch {
+        /* the child is already gone */
+      }
+    })
+  }
+  child.on('error', (error) => {
+    process.stderr.write(`bee-cli: cannot run ${binary}: ${error.message}\n`)
+    process.exit(1)
+  })
+  child.on('exit', (code, signal) => {
+    if (signal) process.kill(process.pid, signal)
+    else process.exit(code === null ? 1 : code)
+  })
+}
+
+main()

package/lib/download.js

@@ -0,0 +1,73 @@
+'use strict'
+/**
+ * Getting the release's bytes onto this machine: https, http, and `file:` for
+ * a mirror or a test. No dependencies and no shelling out to curl, so the same
+ * code runs on every platform Node supports.
+ */
+
+const fs = require('node:fs')
+const path = require('node:path')
+const http = require('node:http')
+const https = require('node:https')
+const { fileURLToPath } = require('node:url')
+
+const REDIRECTS = 5
+const TIMEOUT_MS = 60000
+
+/** Fetch `url` into `target`, following redirects and rejecting on HTTP errors. */
+function download(url, target, redirectsLeft = REDIRECTS) {
+  if (url.startsWith('file:')) {
+    const source = fileURLToPath(url)
+    return fs.promises.mkdir(path.dirname(target), { recursive: true }).then(() =>
+      fs.promises.copyFile(source, target),
+    )
+  }
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith('https:') ? https : http
+    const request = client.get(url, { timeout: TIMEOUT_MS, headers: { 'user-agent': 'bee-cli-npm' } }, (response) => {
+      const status = response.statusCode || 0
+      if (status >= 300 && status < 400 && response.headers.location) {
+        response.resume()
+        if (redirectsLeft <= 0) {
+          reject(new Error(`too many redirects for ${url}`))
+          return
+        }
+        const next = new URL(response.headers.location, url).toString()
+        download(next, target, redirectsLeft - 1).then(resolve, reject)
+        return
+      }
+      if (status !== 200) {
+        response.resume()
+        reject(new Error(`${url} answered HTTP ${status}`))
+        return
+      }
+      fs.promises
+        .mkdir(path.dirname(target), { recursive: true })
+        .then(() => {
+          const out = fs.createWriteStream(target, { mode: 0o755 })
+          out.on('error', reject)
+          response.on('error', reject)
+          response.pipe(out)
+          out.on('close', () => resolve(target))
+        })
+        .catch(reject)
+    })
+    request.on('timeout', () => request.destroy(new Error(`timed out after ${TIMEOUT_MS} ms: ${url}`)))
+    request.on('error', reject)
+  })
+}
+
+/** The text at `url`, or null when it is not there. */
+async function fetchText(url) {
+  try {
+    const tmp = path.join(require('node:os').tmpdir(), `bee-cli-${process.pid}-${Date.now()}.txt`)
+    await download(url, tmp)
+    const text = await fs.promises.readFile(tmp, 'utf8')
+    await fs.promises.rm(tmp, { force: true })
+    return text
+  } catch {
+    return null
+  }
+}
+
+module.exports = { download, fetchText }

package/lib/ensure.js

@@ -0,0 +1,90 @@
+'use strict'
+/**
+ * Make sure this machine has a runnable `bee-cli`, and answer its path.
+ *
+ * Order, first win:
+ *   1. `$BEE_CLI_BINARY`             an explicit path (CI, a checkout, a packager)
+ *   2. a cached download             `~/.cache/bee-cli/<version>/<target>/bee-cli`
+ *   3. the release asset             `bee-cli-<target>` beside the SHA256SUMS
+ */
+
+const fs = require('node:fs')
+const path = require('node:path')
+const {
+  assetName,
+  hostTarget,
+  detectLibc,
+  cachePath,
+  releaseBase,
+  checksumFor,
+  sha256File,
+} = require('./resolve')
+const { download, fetchText } = require('./download')
+
+const VERSION = require('../package.json').version
+
+const BUILD_HINT =
+  'no prebuilt bee-cli for this platform; build it from source: ' +
+  'git clone https://github.com/radxa/linkr-bee && cd linkr-bee/cliproxy-import/tools/linkr-tui && ' +
+  'cargo build --release --no-default-features --features cli, then set BEE_CLI_BINARY to that binary ' +
+  '(or BEE_CLI_TARGET to a release target name).'
+
+/** Whether a path is a file this process may execute. */
+function isExecutable(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK)
+    return fs.statSync(file).isFile()
+  } catch {
+    return false
+  }
+}
+
+/** The cached binary for this machine, if a previous run left one. */
+function cachedBinary(version = VERSION, env = process.env) {
+  const target = env.BEE_CLI_TARGET || hostTarget(process.platform, process.arch, detectLibc())
+  if (!target) return null
+  const file = cachePath(version, target, { env, platform: process.platform })
+  return isExecutable(file) ? file : null
+}
+
+/**
+ * Answer a runnable binary, downloading and verifying the release asset when
+ * there is no usable cache. Throws with a build hint when the platform has no
+ * published asset; a caller that can do without the binary should catch.
+ */
+async function ensureBinary({ version = process.env.BEE_CLI_VERSION || VERSION, env = process.env, quiet = false } = {}) {
+  if (env.BEE_CLI_BINARY) {
+    if (!isExecutable(env.BEE_CLI_BINARY)) throw new Error(`BEE_CLI_BINARY is not an executable file: ${env.BEE_CLI_BINARY}`)
+    return env.BEE_CLI_BINARY
+  }
+  const cached = cachedBinary(version, env)
+  if (cached) return cached
+
+  const target = env.BEE_CLI_TARGET || hostTarget(process.platform, process.arch, detectLibc())
+  if (!target) throw new Error(BUILD_HINT)
+
+  const asset = assetName(target, process.platform)
+  const base = releaseBase(version, env)
+  const destination = cachePath(version, target, { env, platform: process.platform })
+  if (!quiet) process.stderr.write(`bee-cli: fetching ${base}/${asset}\n`)
+
+  const tmp = `${destination}.${process.pid}.part`
+  try {
+    await download(`${base}/${asset}`, tmp)
+    const expected = env.BEE_CLI_SHA256 || checksumFor(await fetchText(`${base}/SHA256SUMS`), asset)
+    if (!expected) throw new Error(`the release has no SHA256SUMS entry for ${asset}; refusing an unverified binary`)
+    const actual = await sha256File(tmp)
+    if (actual !== expected.toLowerCase()) {
+      throw new Error(`checksum mismatch for ${asset}: expected ${expected}, got ${actual}`)
+    }
+    await fs.promises.chmod(tmp, 0o755)
+    await fs.promises.mkdir(path.dirname(destination), { recursive: true })
+    await fs.promises.rename(tmp, destination)
+    return destination
+  } catch (error) {
+    await fs.promises.rm(tmp, { force: true })
+    throw error
+  }
+}
+
+module.exports = { ensureBinary, cachedBinary, isExecutable, VERSION }

package/lib/install.js

@@ -0,0 +1,20 @@
+'use strict'
+/**
+ * Postinstall: warm the cache so the first `bee-cli` run does not wait for a
+ * download. Best effort by design — an offline install must not fail, because
+ * the binary is not needed until something actually talks to a board.
+ */
+
+const { ensureBinary } = require('./ensure')
+
+async function main() {
+  if (process.env.BEE_CLI_SKIP_DOWNLOAD === '1') return
+  try {
+    const binary = await ensureBinary({ quiet: true })
+    if (binary) process.stdout.write(`bee-cli: ${binary}\n`)
+  } catch (error) {
+    process.stderr.write(`bee-cli: will fetch the binary on first use (${error.message})\n`)
+  }
+}
+
+if (require.main === module) main()

package/lib/resolve.js

@@ -0,0 +1,106 @@
+'use strict'
+/**
+ * Where the real `bee-cli` binary lives for this machine, and how this package
+ * finds, verifies and caches it.
+ *
+ * The npm package carries no binaries of its own: the Rust program is built
+ * per platform by the project's release workflow, and this package downloads
+ * the one matching the host, checks it against the release's SHA256SUMS and
+ * keeps it in the user's cache. Everything here is a pure function so the
+ * rules can be tested without a network or a board.
+ */
+
+const os = require('node:os')
+const path = require('node:path')
+
+/** The program's own file name on this platform. */
+function executableName(platform = process.platform) {
+  return platform === 'win32' ? 'bee-cli.exe' : 'bee-cli'
+}
+
+/** The release asset for one Rust target, as the workflow names it. */
+function assetName(target, platform = process.platform) {
+  return `bee-cli-${target}${platform === 'win32' || target.includes('windows') ? '.exe' : ''}`
+}
+
+/**
+ * The Rust target this machine needs.
+ *
+ * Only targets the project actually publishes are named; anything else is
+ * refused here, with the build instructions, rather than by a 404 halfway
+ * through a download.
+ */
+function hostTarget(platform = process.platform, arch = process.arch, libc = 'gnu') {
+  const table = {
+    'darwin arm64': 'aarch64-apple-darwin',
+    'darwin x64': 'x86_64-apple-darwin',
+    'linux x64': libc === 'musl' ? null : 'x86_64-unknown-linux-gnu',
+    'linux arm64': libc === 'musl' ? null : 'aarch64-unknown-linux-gnu',
+    'linux arm': libc === 'musl' ? null : 'armv7-unknown-linux-gnueabihf',
+    'linux ia32': libc === 'musl' ? null : 'i686-unknown-linux-gnu',
+    'win32 x64': 'x86_64-pc-windows-msvc',
+    'win32 arm64': 'aarch64-pc-windows-msvc',
+    'win32 ia32': 'i686-pc-windows-gnu',
+  }
+  const key = `${platform} ${arch}`
+  if (!(key in table)) return null
+  return table[key]
+}
+
+/** Whether the running Node was built against musl (Alpine and friends). */
+function detectLibc(report = typeof process.report?.getReport === 'function' ? process.report.getReport() : null) {
+  if (!report) return 'gnu'
+  const glibc = report.header?.glibcVersionRuntime
+  return glibc ? 'gnu' : process.platform === 'linux' ? 'musl' : 'gnu'
+}
+
+/** Where a downloaded binary is kept: one directory per version and target. */
+function cachePath(version, target, { env = process.env, platform = process.platform } = {}) {
+  const root =
+    env.BEE_CLI_CACHE_DIR ||
+    (platform === 'win32'
+      ? path.join(env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'bee-cli')
+      : path.join(env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache'), 'bee-cli'))
+  // The file itself keeps the program's own name: it is what argv[0] shows a
+  // caller, and `bee-cli --version` should not read `bee-cli-x86_64-…`.
+  return path.join(root, version, target, executableName(platform))
+}
+
+/** The release the binary comes from, unless the caller named another one. */
+function releaseBase(version, env = process.env) {
+  if (env.BEE_CLI_BASE_URL) return env.BEE_CLI_BASE_URL.replace(/\/+$/, '')
+  const repo = env.BEE_CLI_REPO || 'radxa/linkr-bee'
+  return `https://github.com/${repo}/releases/download/linkr-tui-v${version}`
+}
+
+/**
+ * The checksum a release's SHA256SUMS gives for one asset.
+ *
+ * The file is coreutils' format: `<hex>  <name>` per line, and the name may
+ * carry a `*` marker for binaries. Absent or unreadable is `null`; the caller
+ * decides whether that is fatal, because a mirror may publish the disk image
+ * only.
+ */
+function checksumFor(sums, asset) {
+  if (typeof sums !== 'string') return null
+  for (const line of sums.split(/\r?\n/)) {
+    const match = /^([0-9a-f]{64})\s+\*?(.+)$/i.exec(line.trim())
+    if (match && match[2].trim() === asset) return match[1].toLowerCase()
+  }
+  return null
+}
+
+/** sha256 of a file, streamed: the binary is tens of megabytes. */
+async function sha256File(file) {
+  const { createHash } = require('node:crypto')
+  const { createReadStream } = require('node:fs')
+  return new Promise((resolve, reject) => {
+    const hash = createHash('sha256')
+    const stream = createReadStream(file)
+    stream.on('error', reject)
+    stream.on('data', (chunk) => hash.update(chunk))
+    stream.on('end', () => resolve(hash.digest('hex')))
+  })
+}
+
+module.exports = { executableName, assetName, hostTarget, detectLibc, cachePath, releaseBase, checksumFor, sha256File }

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "linkr-bee-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "Linkr Bee wireless serial bridge: the command-line client (bee-cli) for talking to a board's UART console over Bluetooth LE, LAN or loopback.",
+  "keywords": [
+    "bee-cli",
+    "linkr-bee",
+    "serial",
+    "uart",
+    "console",
+    "bluetooth",
+    "ble",
+    "embedded",
+    "dsh"
+  ],
+  "homepage": "https://github.com/radxa/linkr-bee/tree/main/tools/linkr-tui/npm",
+  "bugs": {
+    "url": "https://github.com/radxa/linkr-bee/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/radxa/linkr-bee.git",
+    "directory": "tools/linkr-tui/npm"
+  },
+  "license": "Apache-2.0",
+  "type": "commonjs",
+  "bin": {
+    "bee-cli": "./bin/bee-cli.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_LICENSES.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "postinstall": "node ./lib/install.js",
+    "test": "node --test ./test/*.test.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}