@runar-forge/cli 0.6.1

package/README.md

@@ -0,0 +1,38 @@
+# @runar-forge/cli
+
+Thin npm wrapper that downloads the `runar` Rust binary appropriate
+for your platform.
+
+## Install
+
+```bash
+npm install -g @runar-forge/cli
+```
+
+On install, `scripts/install.js` downloads the matching release asset
+from GitHub Releases, extracts it, and places `runar` (or `runar.exe`
+on Windows) under `bin/`. The `bin` entry in `package.json` then links
+`runar` into your global PATH.
+
+## Supported platforms
+
+- `linux-x64` → `runar-x86_64-unknown-linux-gnu`
+- `linux-arm64` → `runar-aarch64-unknown-linux-gnu`
+- `darwin-arm64` → `runar-aarch64-apple-darwin`
+- `win32-x64` → `runar-x86_64-pc-windows-msvc`
+
+For other platforms, build from source: see the workspace root README.
+
+## Configuration
+
+| Env var | Default | Purpose |
+|---|---|---|
+| `RUNAR_RELEASE_REPO` | `crlome/runar-forge` | GitHub `owner/repo` to fetch from |
+| `RUNAR_RELEASE_TAG` | `v<pkg.version>` | Release tag to fetch |
+| `RUNAR_RELEASE_BASE_URL` | computed from repo+tag | Full base URL override (mirrors / forks) |
+| `RUNAR_SKIP_DOWNLOAD` | unset | Set to `1` to skip postinstall (CI / sandboxes) |
+
+## Direct binary download
+
+If you prefer not to use npm, grab the binary from the GitHub Releases
+page and drop it on your PATH. The wrapper is pure convenience.

package/bin/runar.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * @package @runar-forge/cli
+ * @description Shim: execs the platform-native runar binary dropped
+ *              into this directory by scripts/install.js.
+ */
+'use strict'
+
+const { spawnSync } = require('node:child_process')
+const path = require('node:path')
+const fs = require('node:fs')
+
+const binName = process.platform === 'win32' ? 'runar.exe' : 'runar'
+const binPath = path.join(__dirname, binName)
+
+if (!fs.existsSync(binPath)) {
+  console.error(
+    `[runar] Binary not found at ${binPath}. `
+    + `Re-run \`npm install -g @runar-forge/cli\` or check postinstall output.`,
+  )
+  process.exit(127)
+}
+
+const result = spawnSync(binPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  windowsHide: true,
+})
+if (result.error) {
+  console.error(`[runar] ${result.error.message}`)
+  process.exit(1)
+}
+process.exit(result.status ?? 0)

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@runar-forge/cli",
+  "version": "0.6.1",
+  "description": "npm wrapper that downloads the runar Rust binary for your platform",
+  "bin": {
+    "runar": "bin/runar.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crlome/runar-forge.git"
+  },
+  "license": "MIT"
+}

package/scripts/install.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+/**
+ * @package @runar-forge/cli
+ * @description Postinstall: downloads the platform-appropriate `runar`
+ *              Rust binary from GitHub Releases and places it at
+ *              bin/runar (or runar.exe).
+ */
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const https = require('node:https')
+const zlib = require('node:zlib')
+const { pipeline } = require('node:stream/promises')
+const { spawnSync } = require('node:child_process')
+
+const pkg = require('../package.json')
+
+const DEFAULT_REPO = 'crlome/runar-forge'
+const REPO = process.env.RUNAR_RELEASE_REPO || DEFAULT_REPO
+const TAG = process.env.RUNAR_RELEASE_TAG || `v${pkg.version}`
+const BASE = process.env.RUNAR_RELEASE_BASE_URL
+  || `https://github.com/${REPO}/releases/download/${TAG}`
+
+const TARGETS = {
+  'linux-x64':    { asset: 'runar-x86_64-unknown-linux-gnu.tar.gz',  archive: 'tar.gz' },
+  'linux-arm64':  { asset: 'runar-aarch64-unknown-linux-gnu.tar.gz', archive: 'tar.gz' },
+  'darwin-arm64': { asset: 'runar-aarch64-apple-darwin.tar.gz',      archive: 'tar.gz' },
+  'darwin-x64':   { asset: 'runar-x86_64-apple-darwin.tar.gz',       archive: 'tar.gz' },
+  'win32-x64':    { asset: 'runar-x86_64-pc-windows-msvc.zip',       archive: 'zip'    },
+}
+
+function resolveTarget() {
+  const key = `${process.platform}-${process.arch}`
+  const target = TARGETS[key]
+  if (!target) {
+    throw new Error(
+      `Unsupported platform: ${key}. `
+      + `Supported: ${Object.keys(TARGETS).join(', ')}. `
+      + `Build from source: https://github.com/${REPO}`,
+    )
+  }
+  return target
+}
+
+function download(url, dest, redirects = 5) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          if (redirects <= 0) return reject(new Error('Too many redirects'))
+          res.resume()
+          return resolve(download(res.headers.location, dest, redirects - 1))
+        }
+        if (res.statusCode !== 200) {
+          res.resume()
+          return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`))
+        }
+        pipeline(res, fs.createWriteStream(dest)).then(resolve, reject)
+      })
+      .on('error', reject)
+  })
+}
+
+function extractTarGz(archivePath, destDir) {
+  const r = spawnSync('tar', ['-xzf', archivePath, '-C', destDir], { stdio: 'inherit' })
+  if (r.status !== 0) throw new Error(`tar exited with ${r.status}`)
+}
+
+function extractZip(archivePath, destDir) {
+  if (process.platform === 'win32') {
+    const r = spawnSync('powershell', [
+      '-NoProfile', '-Command',
+      `Expand-Archive -LiteralPath '${archivePath}' -DestinationPath '${destDir}' -Force`,
+    ], { stdio: 'inherit' })
+    if (r.status !== 0) throw new Error(`Expand-Archive exited with ${r.status}`)
+  } else {
+    const r = spawnSync('unzip', ['-o', archivePath, '-d', destDir], { stdio: 'inherit' })
+    if (r.status !== 0) throw new Error(`unzip exited with ${r.status}`)
+  }
+}
+
+async function main() {
+  if (process.env.RUNAR_SKIP_DOWNLOAD === '1') {
+    console.log('[runar] RUNAR_SKIP_DOWNLOAD=1, skipping binary download.')
+    return
+  }
+  const { asset, archive } = resolveTarget()
+  const url = `${BASE}/${asset}`
+  const binDir = path.join(__dirname, '..', 'bin')
+  fs.mkdirSync(binDir, { recursive: true })
+  const archivePath = path.join(binDir, asset)
+
+  console.log(`[runar] Downloading ${asset} from ${url}`)
+  try {
+    await download(url, archivePath)
+  } catch (err) {
+    console.error(`[runar] Download failed: ${err.message}`)
+    console.error(
+      '[runar] Override RUNAR_RELEASE_REPO, RUNAR_RELEASE_TAG, or '
+      + 'RUNAR_RELEASE_BASE_URL to fetch from a different location.',
+    )
+    process.exit(1)
+  }
+
+  try {
+    if (archive === 'tar.gz') extractTarGz(archivePath, binDir)
+    else extractZip(archivePath, binDir)
+  } catch (err) {
+    console.error(`[runar] Extract failed: ${err.message}`)
+    process.exit(1)
+  } finally {
+    try { fs.unlinkSync(archivePath) } catch (_) {}
+  }
+
+  const isWin = process.platform === 'win32'
+  const finalName = isWin ? 'runar.exe' : 'runar'
+  const finalPath = path.join(binDir, finalName)
+  if (!fs.existsSync(finalPath)) {
+    throw new Error(`Expected binary not found at ${finalPath} after extraction`)
+  }
+  if (!isWin) fs.chmodSync(finalPath, 0o755)
+  console.log(`[runar] Installed ${finalName} at ${finalPath}`)
+}
+
+main().catch((err) => {
+  console.error(`[runar] ${err.message}`)
+  process.exit(1)
+})