@one2x/merouter 0.1.7-linux-arm64 → 0.1.7

package/bin/bin.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveBinaryPath, resolvePlatformOrThrow } from "./binary-resolver.js";
+import { detectPackageManager, reinstallHint, } from "./package-manager.js";
+import { runBinary } from "./spawn-child.js";
+const shimDirname = path.dirname(fileURLToPath(import.meta.url));
+const manager = detectPackageManager(shimDirname);
+const platform = resolvePlatformOrThrow();
+const binaryPath = resolveBinaryPath(platform, shimDirname, reinstallHint(manager));
+await runBinary(binaryPath, process.argv.slice(2), manager);

package/bin/binary-resolver.js

@@ -0,0 +1,36 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { detectPlatform, getBinaryName, getPlatformPackageName, } from "./utils/platforms.js";
+const require = createRequire(import.meta.url);
+export function resolvePlatformOrThrow() {
+    const platform = detectPlatform(process.platform, process.arch);
+    if (!platform) {
+        throw new Error(`Unsupported platform: ${process.platform} (${process.arch}).`);
+    }
+    return platform;
+}
+export function resolveBinaryPath(platform, shimDirname, reinstall) {
+    const binaryName = getBinaryName(platform.os);
+    const packageName = getPlatformPackageName(platform.key);
+    const localVendorRoot = path.join(shimDirname, "..", "vendor");
+    const localBinaryPath = path.join(localVendorRoot, platform.target, "merouter", binaryName);
+    let vendorRoot;
+    try {
+        const packageJsonPath = require.resolve(`${packageName}/package.json`);
+        vendorRoot = path.join(path.dirname(packageJsonPath), "vendor");
+    }
+    catch {
+        if (existsSync(localBinaryPath)) {
+            vendorRoot = localVendorRoot;
+        }
+        else {
+            throw new Error(`Missing optional dependency ${packageName}. Reinstall merouter: ${reinstall}`);
+        }
+    }
+    const binaryPath = path.join(vendorRoot, platform.target, "merouter", binaryName);
+    if (!existsSync(binaryPath)) {
+        throw new Error(`Binary not found at ${binaryPath}. Reinstall merouter: ${reinstall}`);
+    }
+    return binaryPath;
+}

package/bin/package-manager.js

@@ -0,0 +1,17 @@
+export function detectPackageManager(dirname) {
+    const userAgent = process.env.npm_config_user_agent ?? "";
+    if (/\bbun\//.test(userAgent))
+        return "bun";
+    if ((process.env.npm_execpath ?? "").includes("bun"))
+        return "bun";
+    if (dirname.includes(".bun/install/global") ||
+        dirname.includes(".bun\\install\\global")) {
+        return "bun";
+    }
+    return userAgent ? "npm" : null;
+}
+export function reinstallHint(manager) {
+    return manager === "bun"
+        ? "bun install -g @one2x/merouter@latest"
+        : "npm install -g @one2x/merouter@latest";
+}

package/bin/spawn-child.js

@@ -0,0 +1,48 @@
+import { spawn } from "node:child_process";
+const FORWARDED_SIGNALS = [
+    "SIGINT",
+    "SIGTERM",
+    "SIGHUP",
+];
+export async function runBinary(binaryPath, argv, manager) {
+    const env = {
+        ...process.env,
+        [manager === "bun"
+            ? "MEROUTER_MANAGED_BY_BUN"
+            : "MEROUTER_MANAGED_BY_NPM"]: "1",
+    };
+    const child = spawn(binaryPath, argv, { stdio: "inherit", env });
+    child.on("error", (err) => {
+        console.error(err);
+        process.exit(1);
+    });
+    for (const sig of FORWARDED_SIGNALS) {
+        process.on(sig, () => {
+            if (!child.killed) {
+                try {
+                    child.kill(sig);
+                }
+                catch {
+                    /* child already exited */
+                }
+            }
+        });
+    }
+    const result = await new Promise((resolve) => {
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                resolve({ type: "signal", signal });
+            }
+            else {
+                resolve({ type: "code", exitCode: code ?? 1 });
+            }
+        });
+    });
+    if (result.type === "signal") {
+        process.kill(process.pid, result.signal);
+    }
+    else {
+        process.exit(result.exitCode);
+    }
+    throw new Error("unreachable");
+}

package/bin/utils/platforms.js

@@ -0,0 +1,88 @@
+/**
+ * Single source of truth for platform data used by both the runtime shim
+ * (src/bin.ts) and the publish-time stager (scripts/stage/main.ts).
+ *
+ * Add a new supported platform by appending to `PLATFORMS` — no other file
+ * in this package needs to change.
+ */
+export const PLATFORMS = [
+    {
+        key: "linux-x64",
+        target: "x86_64-unknown-linux-gnu",
+        os: "linux",
+        cpu: "x64",
+        archive: "tar.gz",
+    },
+    {
+        key: "linux-arm64",
+        target: "aarch64-unknown-linux-gnu",
+        os: "linux",
+        cpu: "arm64",
+        archive: "tar.gz",
+    },
+    {
+        key: "darwin-x64",
+        target: "x86_64-apple-darwin",
+        os: "darwin",
+        cpu: "x64",
+        archive: "tar.gz",
+    },
+    {
+        key: "darwin-arm64",
+        target: "aarch64-apple-darwin",
+        os: "darwin",
+        cpu: "arm64",
+        archive: "tar.gz",
+    },
+    {
+        key: "win32-x64",
+        target: "x86_64-pc-windows-msvc",
+        os: "win32",
+        cpu: "x64",
+        archive: "zip",
+    },
+];
+/** Base npm package name shared by the main shim and all platform artifacts. */
+export const NPM_NAME = "@one2x/merouter";
+/**
+ * Returns the executable filename for the given OS.
+ *
+ * Usage:
+ *   getBinaryName("linux")  // "merouter"
+ *   getBinaryName("win32")  // "merouter.exe"
+ */
+export function getBinaryName(os) {
+    return os === "win32" ? "merouter.exe" : "merouter";
+}
+/**
+ * Returns the npm optionalDependency package key for a platform.
+ *
+ * The key MUST match the LHS of the `optionalDependencies` entries in
+ * packages/merouter/package.json — npm stores the aliased package under
+ * `node_modules/<key>/` regardless of the real underlying name/version.
+ *
+ * Usage:
+ *   getPlatformPackageName("linux-x64")  // "@one2x/merouter-linux-x64"
+ */
+export function getPlatformPackageName(key) {
+    return `${NPM_NAME}-${key}`;
+}
+/**
+ * Detects the current host's platform from Node's `process.platform` and
+ * `process.arch`, returning null if the combination is unsupported.
+ */
+export function detectPlatform(platform, arch) {
+    const nodeOs = platform === "linux" || platform === "android"
+        ? "linux"
+        : platform === "darwin"
+            ? "darwin"
+            : platform === "win32"
+                ? "win32"
+                : null;
+    if (!nodeOs)
+        return null;
+    const nodeCpu = arch === "x64" ? "x64" : arch === "arm64" ? "arm64" : null;
+    if (!nodeCpu)
+        return null;
+    return PLATFORMS.find((p) => p.os === nodeOs && p.cpu === nodeCpu) ?? null;
+}

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@one2x/merouter",
-  "version": "0.1.7-linux-arm64",
+  "version": "0.1.7",
+  "description": "Unified CLI for managing and routing across multiple AI model providers.",
   "license": "SEE LICENSE IN LICENSE",
-  "description": "merouter CLI native binary for linux/arm64.",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "arm64"
-  ],
+  "type": "module",
+  "bin": {
+    "merouter": "bin/bin.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
   "files": [
-    "vendor",
+    "bin",
+    "LICENSE",
     "README.md"
   ],
   "repository": {
@@ -20,5 +22,12 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "optionalDependencies": {
+    "@one2x/merouter-linux-x64": "npm:@one2x/merouter@0.1.7-linux-x64",
+    "@one2x/merouter-linux-arm64": "npm:@one2x/merouter@0.1.7-linux-arm64",
+    "@one2x/merouter-darwin-x64": "npm:@one2x/merouter@0.1.7-darwin-x64",
+    "@one2x/merouter-darwin-arm64": "npm:@one2x/merouter@0.1.7-darwin-arm64",
+    "@one2x/merouter-win32-x64": "npm:@one2x/merouter@0.1.7-win32-x64"
   }
 }