@hlix/cli 0.7.1 → 0.7.2

package/README.md

@@ -42,12 +42,20 @@ hlix --help          # the commands
 hlix                 # open Hlix Code
 ```
 
+`hlix` runs as one self-contained executable: npm installs the one for your
+platform (`@hlix/cli-darwin-arm64`, `-darwin-x64`, `-linux-x64` or
+`-linux-arm64`) and `hlix` runs it directly. Where there is none (Windows,
+musl-based Linux, `--omit=optional`) the Node build in this package runs
+instead, after one line on stderr. Without npm,
+`curl -fsSL https://staging.hlix.ai/install.sh | bash` installs the same
+executable, and so does `brew install hlix-ai/tap/hlix`.
+
 For CI, and for anything else that must not change underneath you, pin the
 version instead of floating to `latest`:
 
 ```bash
-npm install --global @hlix/cli@0.7.1
-npx @hlix/cli@0.7.1 status --json
+npm install --global @hlix/cli@0.7.2
+npx @hlix/cli@0.7.2 status --json
 ```
 
 ## Authenticate

package/bin/hlix

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// `hlix` as npm installs it. After a normal install the postinstall
+// (install.cjs) has replaced this file with the standalone binary itself, so
+// this only runs when that did not happen: scripts off (--ignore-scripts, pnpm)
+// runs the platform package's binary from here; no platform package
+// (--omit=optional, an unsupported platform) runs the Node build, after one line.
+import { spawn } from "node:child_process"
+import { createRequire } from "node:module"
+import { fileURLToPath } from "node:url"
+
+const { nativeBinary } = createRequire(import.meta.url)("../install.cjs")
+const found = nativeBinary()
+let command = found.binary
+let args = process.argv.slice(2)
+if (!command) {
+  process.stderr.write(`hlix: using the Node build (${found.reason})\n`)
+  command = process.execPath
+  args = [fileURLToPath(new URL("../dist/index.js", import.meta.url)), ...args]
+}
+
+// This copy is the one a person installed; the binary runs from the platform
+// package, so it is told which path to report (hlix status).
+const child = spawn(command, args, { stdio: "inherit", env: { ...process.env, HLIX_SELF: process.argv[1] } })
+// The terminal signals the whole process group; a signal sent to this
+// process alone (a supervisor, `kill`) is passed on instead of orphaning it.
+const forward = (signal) => child.kill(signal)
+const signals = ["SIGINT", "SIGTERM", "SIGHUP"]
+for (const signal of signals) process.on(signal, forward)
+child.on("error", (error) => {
+  process.stderr.write(`hlix: ${command}: ${error.message}\n`)
+  process.exit(1)
+})
+child.on("exit", (code, signal) => {
+  for (const name of signals) process.off(name, forward)
+  if (signal) process.kill(process.pid, signal)
+  else process.exit(code ?? 1)
+})