@sys9/run9-cli 0.2.4 → 0.2.6

package/README.md

@@ -10,11 +10,14 @@ npm install -g @sys9/run9-cli
 bun install -g @sys9/run9-cli
 ```
 
+The installed `run9` launcher is a POSIX shell wrapper around the bundled
+native binary, so `bun install -g` works even when `node` is not present.
+
 Run:
 
 ```sh
 run9 auth login \
-  --endpoint https://api.run9.example.com \
+  --endpoint https://api.run.sys9.ai \
   --ak ak-... \
   --sk sk-...
 ```

package/bin/run9

@@ -0,0 +1,56 @@
+#!/usr/bin/env sh
+
+set -eu
+
+resolve_script_path() {
+  script_path="$1"
+  while [ -L "$script_path" ]; do
+    link_target="$(readlink "$script_path")"
+    case "$link_target" in
+      /*) script_path="$link_target" ;;
+      *) script_path="$(dirname "$script_path")/$link_target" ;;
+    esac
+  done
+  printf '%s\n' "$script_path"
+}
+
+script_path="$(resolve_script_path "$0")"
+script_dir="$(CDPATH= cd "$(dirname "$script_path")" && pwd)"
+
+uname_s="$(uname -s)"
+uname_m="$(uname -m)"
+
+case "$uname_s" in
+  Linux)
+    case "$uname_m" in
+      x86_64|amd64) target_triple="x86_64-unknown-linux-musl" ;;
+      aarch64|arm64) target_triple="aarch64-unknown-linux-musl" ;;
+      *)
+        echo "Unsupported architecture: $uname_m" >&2
+        exit 1
+        ;;
+    esac
+    ;;
+  Darwin)
+    case "$uname_m" in
+      x86_64|amd64) target_triple="x86_64-apple-darwin" ;;
+      arm64|aarch64) target_triple="aarch64-apple-darwin" ;;
+      *)
+        echo "Unsupported architecture: $uname_m" >&2
+        exit 1
+        ;;
+    esac
+    ;;
+  *)
+    echo "Unsupported platform: $uname_s ($uname_m)" >&2
+    exit 1
+    ;;
+esac
+
+binary_path="${script_dir}/../vendor/${target_triple}/run9/run9"
+if [ ! -x "$binary_path" ]; then
+  echo "Bundled run9 binary not found at ${binary_path}" >&2
+  exit 1
+fi
+
+exec "$binary_path" "$@"

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@sys9/run9-cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "run9 CLI with bundled native binaries for Linux and macOS",
   "license": "MIT",
   "bin": {
-    "run9": "bin/run9.js"
+    "run9": "bin/run9"
   },
   "type": "module",
   "engines": {

package/bin/run9.js

@@ -1,89 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-function resolveTargetTriple(platform, arch) {
-  switch (platform) {
-    case "linux":
-    case "android":
-      switch (arch) {
-        case "x64":
-          return "x86_64-unknown-linux-musl";
-        case "arm64":
-          return "aarch64-unknown-linux-musl";
-        default:
-          return null;
-      }
-    case "darwin":
-      switch (arch) {
-        case "x64":
-          return "x86_64-apple-darwin";
-        case "arm64":
-          return "aarch64-apple-darwin";
-        default:
-          return null;
-      }
-    default:
-      return null;
-  }
-}
-
-const targetTriple = resolveTargetTriple(process.platform, process.arch);
-if (!targetTriple) {
-  throw new Error(`Unsupported platform: ${process.platform} (${process.arch})`);
-}
-
-const binaryPath = path.join(__dirname, "..", "vendor", targetTriple, "run9", "run9");
-if (!existsSync(binaryPath)) {
-  throw new Error(`Bundled run9 binary not found at ${binaryPath}`);
-}
-
-// Use asynchronous spawn so the parent process can forward terminal signals
-// while the native binary is running.
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: "inherit",
-  env: process.env,
-});
-
-child.on("error", (err) => {
-  // eslint-disable-next-line no-console
-  console.error(err);
-  process.exit(1);
-});
-
-const forwardSignal = (signal) => {
-  if (child.killed) {
-    return;
-  }
-  try {
-    child.kill(signal);
-  } catch {
-    // Ignore races where the process already exited.
-  }
-};
-
-["SIGINT", "SIGTERM", "SIGHUP"].forEach((signal) => {
-  process.on(signal, () => forwardSignal(signal));
-});
-
-const childResult = await new Promise((resolve) => {
-  child.on("exit", (code, signal) => {
-    if (signal) {
-      resolve({ type: "signal", signal });
-      return;
-    }
-    resolve({ type: "code", exitCode: code ?? 1 });
-  });
-});
-
-if (childResult.type === "signal") {
-  process.kill(process.pid, childResult.signal);
-} else {
-  process.exit(childResult.exitCode);
-}