@runar-forge/cli 0.6.1 → 0.7.0

package/README.md

@@ -1,7 +1,6 @@
 # @runar-forge/cli
 
-Thin npm wrapper that downloads the `runar` Rust binary appropriate
-for your platform.
+Cross-platform launcher for the `runar` Rust binary.
 
 ## Install
 
@@ -9,30 +8,37 @@ for your platform.
 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.
+## No install scripts
 
-## Supported platforms
+This package has **no `postinstall` script** and performs **no network access
+at install time**. The native binary ships as ordinary, npm-integrity-checked
+package content via per-platform optional dependencies, so it installs cleanly
+even with `ignore-scripts=true`:
 
-- `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`
+```bash
+npm install -g @runar-forge/cli --ignore-scripts   # still works
+```
 
-For other platforms, build from source: see the workspace root README.
+npm installs only the optional dependency matching your `os` + `cpu`; the rest
+are skipped by npm's platform check. The `runar` launcher (plain JS, run only
+when you invoke it — never at install) resolves the binary from whichever
+platform package was installed and execs it.
+
+## Supported platforms
 
-## Configuration
+| Optional dependency           | Host           |
+|-------------------------------|----------------|
+| `@runar-forge/cli-linux-x64`  | linux / x64    |
+| `@runar-forge/cli-linux-arm64`| linux / arm64  |
+| `@runar-forge/cli-darwin-x64` | macOS / Intel  |
+| `@runar-forge/cli-darwin-arm64`| macOS / Apple Silicon |
+| `@runar-forge/cli-win32-x64`  | Windows / x64  |
 
-| 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) |
+For other platforms, build from source — see the workspace root README.
 
 ## 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.
+If you prefer not to use npm, grab the binary from the
+[GitHub Releases](https://github.com/crlome/runar-forge/releases) page and drop
+it on your PATH, or use `runar update` once installed. The wrapper is pure
+convenience.

package/bin/runar.js

@@ -1,24 +1,48 @@
 #!/usr/bin/env node
 /**
  * @package @runar-forge/cli
- * @description Shim: execs the platform-native runar binary dropped
- *              into this directory by scripts/install.js.
+ * @description Launcher: execs the runar binary shipped in the matching
+ *              per-platform optional dependency (@runar-forge/cli-<os>-<cpu>).
+ *              No install scripts, no install-time network — the binary is
+ *              ordinary, npm-integrity-checked package content, so this works
+ *              with `ignore-scripts=true`.
  */
 'use strict'
 
-const { spawnSync } = require('node:child_process')
 const path = require('node:path')
-const fs = require('node:fs')
+const { spawnSync } = require('node:child_process')
+
+const PLATFORM_PACKAGES = {
+  'linux-x64': '@runar-forge/cli-linux-x64',
+  'linux-arm64': '@runar-forge/cli-linux-arm64',
+  'darwin-x64': '@runar-forge/cli-darwin-x64',
+  'darwin-arm64': '@runar-forge/cli-darwin-arm64',
+  'win32-x64': '@runar-forge/cli-win32-x64',
+}
+
+const key = `${process.platform}-${process.arch}`
+const pkg = PLATFORM_PACKAGES[key]
+if (!pkg) {
+  console.error(
+    `[runar] Unsupported platform: ${key}. `
+    + 'Build from source: https://github.com/crlome/runar-forge',
+  )
+  process.exit(1)
+}
 
 const binName = process.platform === 'win32' ? 'runar.exe' : 'runar'
-const binPath = path.join(__dirname, binName)
 
-if (!fs.existsSync(binPath)) {
+let binPath
+try {
+  // Resolve the platform package via its package.json (robust against any
+  // `exports` map), then join the binary. Pure resolution — no network.
+  binPath = path.join(path.dirname(require.resolve(`${pkg}/package.json`)), binName)
+} catch {
   console.error(
-    `[runar] Binary not found at ${binPath}. `
-    + `Re-run \`npm install -g @runar-forge/cli\` or check postinstall output.`,
+    `[runar] Missing optional dependency ${pkg}. `
+    + `Reinstall without \`--omit=optional\` (and ensure ${key} is supported).`,
   )
-  process.exit(127)
+  process.exit(1)
 }
 
 const result = spawnSync(binPath, process.argv.slice(2), {

package/package.json

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

package/scripts/install.js

@@ -1,129 +0,0 @@
-#!/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)
-})