@railway/cli 5.30.3 → 5.31.1

package/bin/railway.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { execFileSync } from "child_process";
+import { constants } from "os";
 import path from "path";
 import { exit } from "process";
 import { fileURLToPath } from "url";
@@ -7,10 +8,38 @@ import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const binName = process.platform === "win32" ? "railway.exe" : "railway";
+const binPath = path.resolve(__dirname, binName);
+
 try {
-	execFileSync(path.resolve(`${__dirname}/${binName}`), process.argv.slice(2), {
-		stdio: "inherit",
-	});
+    execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
 } catch (e) {
-	exit(1);
+    // The binary is downloaded by npm-install/postinstall.js. If that step was
+    // skipped (--ignore-scripts) or failed (unsupported platform, network), the
+    // spawn fails with ENOENT — say so instead of exiting 1 with no output.
+    if (e.code === "ENOENT") {
+        console.error(
+            `railway: could not find the CLI binary at ${binPath}\n` +
+                `The @railway/cli install step did not complete. Try:\n` +
+                `  npm install -g @railway/cli --foreground-scripts\n` +
+                `or install the CLI directly:\n` +
+                `  curl -fsSL https://railway.com/install.sh | sh`,
+        );
+        exit(127);
+    }
+
+    // Propagate the real exit status. Without this every failure collapses to 1,
+    // which hides usage errors (clap exits 2), breaks `set -e` callers that
+    // inspect the code, and masks crashes as ordinary failures.
+    if (typeof e.status === "number") {
+        exit(e.status);
+    }
+
+    // Killed by a signal: report it the way a shell does (128 + signal number)
+    // so a segfault surfaces as 139 rather than a generic 1.
+    if (e.signal) {
+        const signum = constants.signals[e.signal];
+        exit(signum ? 128 + signum : 1);
+    }
+
+    exit(1);
 }

package/npm-install/postinstall.js

@@ -1,48 +1,114 @@
-import triples from "@napi-rs/triples";
 import { createWriteStream } from "fs";
 import * as fs from "fs/promises";
 import fetch from "node-fetch";
+import path from "path";
 import { pipeline } from "stream/promises";
+import { fileURLToPath } from "url";
 import tar from "tar";
 
 import { CONFIG } from "./config.js";
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+
+// process.platform/arch -> release target triple.
+//
+// This is deliberately hand-maintained rather than derived from a generic table
+// (we previously used @napi-rs/triples): the generic answer for Linux is always
+// `*-unknown-linux-gnu`, and we do not publish gnu builds for any Linux arch
+// except x86_64. That silently broke `npm i -g @railway/cli` on arm64/arm/ia32
+// Linux with "Failed fetching the binary: Not Found".
+//
+// Every entry below must correspond to an asset produced by
+// .github/workflows/release.yml. Linux uses the statically linked musl builds
+// for the same reason install.sh does: one binary that runs regardless of the
+// host's libc.
+const TARGETS = {
+    linux: {
+        x64: "x86_64-unknown-linux-musl",
+        arm64: "aarch64-unknown-linux-musl",
+        ia32: "i686-unknown-linux-musl",
+        arm: "arm-unknown-linux-musleabihf",
+    },
+    darwin: {
+        x64: "x86_64-apple-darwin",
+        arm64: "aarch64-apple-darwin",
+    },
+    win32: {
+        x64: "x86_64-pc-windows-gnu",
+        ia32: "i686-pc-windows-gnu",
+        arm64: "aarch64-pc-windows-msvc",
+    },
+};
+
+function resolveTarget() {
+    const { platform, arch } = process;
+    const triple = TARGETS[platform]?.[arch];
+
+    if (!triple) {
+        const supported = Object.entries(TARGETS)
+            .flatMap(([p, arches]) => Object.keys(arches).map((a) => `${p}-${a}`))
+            .join(", ");
+        throw new Error(
+            `Railway CLI does not ship a prebuilt binary for ${platform}-${arch}.\n` +
+                `Supported: ${supported}\n` +
+                `Request a build at https://github.com/railwayapp/cli/issues/new, ` +
+                `or build from source with \`cargo install railwayapp\`.`,
+        );
+    }
+
+    return triple;
+}
+
 async function install() {
-	const packageJson = await fs.readFile("package.json").then(JSON.parse);
-	let version = packageJson.version;
-
-	if (typeof version !== "string") {
-		throw new Error("Missing version in package.json");
-	}
-
-	if (version[0] === "v") version = version.slice(1);
-
-	// Fetch Static Config
-	let { name: binName, path: binPath, url } = CONFIG;
-	let triple = triples.platformArchTriples[process.platform][process.arch][0];
-
-	url = url.replace(/{{triple}}/g, triple.raw);
-	url = url.replace(/{{version}}/g, version);
-	url = url.replace(/{{bin_name}}/g, binName);
-	console.log(url);
-	const response = await fetch(url);
-	if (!response.ok) {
-		throw new Error("Failed fetching the binary: " + response.statusText);
-	}
-
-	const tarFile = "downloaded.tar.gz";
-
-	await fs.mkdir(binPath, { recursive: true });
-	await pipeline(response.body, createWriteStream(tarFile));
-	await tar.x({ file: tarFile, cwd: binPath });
-	await fs.rm(tarFile);
+    const packageJson = await fs
+        .readFile(path.join(PACKAGE_ROOT, "package.json"), "utf8")
+        .then(JSON.parse);
+    let version = packageJson.version;
+
+    if (typeof version !== "string") {
+        throw new Error("Missing version in package.json");
+    }
+
+    if (version[0] === "v") version = version.slice(1);
+
+    const { name: binName, path: binPath, url } = CONFIG;
+    const triple = resolveTarget();
+
+    const downloadUrl = url
+        .replace(/{{triple}}/g, triple)
+        .replace(/{{version}}/g, version)
+        .replace(/{{bin_name}}/g, binName);
+
+    console.log(downloadUrl);
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+        throw new Error(
+            `Failed fetching the binary (${response.status} ${response.statusText}): ${downloadUrl}`,
+        );
+    }
+
+    const destDir = path.resolve(PACKAGE_ROOT, binPath);
+    const tarFile = path.join(PACKAGE_ROOT, "downloaded.tar.gz");
+
+    await fs.mkdir(destDir, { recursive: true });
+    await pipeline(response.body, createWriteStream(tarFile));
+    await tar.x({ file: tarFile, cwd: destDir });
+    await fs.rm(tarFile);
+
+    // Fail loudly here rather than leaving a package whose `railway` shim exits
+    // with a confusing ENOENT on first use.
+    const expected = path.join(destDir, process.platform === "win32" ? "railway.exe" : "railway");
+    await fs.access(expected).catch(() => {
+        throw new Error(`Archive did not contain the expected binary at ${expected}`);
+    });
 }
 
 install()
-	.then(async () => {
-		process.exit(0);
-	})
-	.catch(async (err) => {
-		console.error(err);
-		process.exit(1);
-	});
+    .then(async () => {
+        process.exit(0);
+    })
+    .catch(async (err) => {
+        console.error(err.message ?? err);
+        process.exit(1);
+    });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@railway/cli",
-  "version": "5.30.3",
+  "version": "5.31.1",
   "description": "Develop and deploy code with zero configuration",
   "type": "module",
   "author": "Jake Runzer",
@@ -24,7 +24,6 @@
     "README.md"
   ],
   "dependencies": {
-    "@napi-rs/triples": "^1.1.0",
     "node-fetch": "^3.1.0",
     "tar": "^6.1.11"
   }