zelosh 0.0.1

package/README.md

@@ -0,0 +1,49 @@
+# zelosh
+
+`zelosh` is a publish-only wrapper package that exposes two CLI entrypoints:
+
+- `zelo`
+- `zelo-server`
+
+At runtime it selects a prebuilt native binary by platform/arch and executes it.
+
+The binaries are shipped via platform-specific optional dependencies:
+
+- `@zelo/zelosh-darwin-arm64`
+- `@zelo/zelosh-darwin-x64`
+- `@zelo/zelosh-linux-arm64`
+- `@zelo/zelosh-linux-x64`
+- `@zelo/zelosh-win32-arm64`
+- `@zelo/zelosh-win32-x64`
+
+At runtime it resolves `@zelo/zelosh-${process.platform}-${process.arch}` and executes the binary from that package.
+
+## Platform package layout
+
+Inside each `@zelo/zelosh-<platform>-<arch>` package:
+
+```
+bin/
+  zelo[.exe]
+  zelo-server[.exe]
+```
+
+## Release (CI-friendly)
+
+Bun can't cross-compile `--compile` binaries, so build each platform/arch in a matrix, then assemble and publish in a final job.
+
+Build (per platform job):
+
+```bash
+bun run scripts/release-zelosh.ts pack
+```
+
+This produces an npm tarball under `dist/` like:
+
+- `dist/zelo-zelosh-<platform>-<arch>-<version>.tgz`
+
+Publish (final job):
+
+```bash
+bun run scripts/release-zelosh.ts release --artifacts dist -- --access public
+```

package/bin/_runner.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+function resolveBinaryPath(binBaseName) {
+  const platform = process.platform;
+  const arch = process.arch;
+  const exe = platform === "win32" ? ".exe" : "";
+
+  const target = `${platform}-${arch}`;
+  const platformPackageName = `@zelo/zelosh-${target}`;
+
+  let platformPackageRoot = null;
+  try {
+    const pkgJsonPath = require.resolve(`${platformPackageName}/package.json`);
+    platformPackageRoot = path.dirname(pkgJsonPath);
+  } catch {
+    // ignore
+  }
+
+  const binPath = platformPackageRoot ? path.join(platformPackageRoot, "bin", `${binBaseName}${exe}`) : "";
+
+  return { binPath, target, platformPackageName, platformPackageRoot };
+}
+
+function ensureUnixExecutable(binPath) {
+  if (process.platform === "win32") return;
+  try {
+    fs.accessSync(binPath, fs.constants.X_OK);
+  } catch {
+    try {
+      fs.chmodSync(binPath, 0o755);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function printMissingBinaryHelp(binBaseName, target, platformPackageName, binPath, platformPackageRoot) {
+  const exe = process.platform === "win32" ? ".exe" : "";
+  const expectedBinaryPath = binPath || `<node_modules>/${platformPackageName}/bin/${binBaseName}${exe}`;
+  // eslint-disable-next-line no-console
+  console.error(
+    [
+      `zelosh: missing binary for ${target}.`,
+      `Expected package: ${platformPackageName}`,
+      `Expected binary: ${expectedBinaryPath}`,
+      "",
+      platformPackageRoot ? "The platform package is installed, but the binary is missing/corrupted." : "The platform package is not installed (optionalDependencies may have been skipped).",
+      "",
+      "Try reinstalling without --no-optional, or install the platform package manually.",
+    ].join("\n"),
+  );
+}
+
+function run(binBaseName) {
+  const { binPath, target, platformPackageName, platformPackageRoot } = resolveBinaryPath(binBaseName);
+  if (!fs.existsSync(binPath)) {
+    printMissingBinaryHelp(binBaseName, target, platformPackageName, binPath, platformPackageRoot);
+    process.exitCode = 1;
+    return;
+  }
+
+  ensureUnixExecutable(binPath);
+
+  const child = spawn(binPath, process.argv.slice(2), { stdio: "inherit", windowsHide: true });
+
+  child.on("error", (err) => {
+    // eslint-disable-next-line no-console
+    console.error(`zelosh: failed to start ${binBaseName}:`, err);
+    process.exitCode = 1;
+  });
+
+  child.on("exit", (code, signal) => {
+    if (typeof code === "number") {
+      process.exit(code);
+      return;
+    }
+    // Best-effort: mirror signal behavior when possible.
+    if (signal) {
+      try {
+        process.kill(process.pid, signal);
+        return;
+      } catch {
+        // ignore
+      }
+    }
+    process.exit(1);
+  });
+}
+
+module.exports = { run };

package/bin/zelo-server.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+
+const { run } = require("./_runner");
+
+run("zelo-server");
+

package/bin/zelo.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+
+const { run } = require("./_runner");
+
+run("zelo");
+

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "zelosh",
+  "version": "0.0.1",
+  "private": false,
+  "type": "commonjs",
+  "description": "Zelo published binaries wrapper (zelo, zelo-server).",
+  "bin": {
+    "zelo": "./bin/zelo.js",
+    "zelo-server": "./bin/zelo-server.js"
+  },
+  "optionalDependencies": {
+    "@zelo/zelosh-darwin-arm64": "0.0.1",
+    "@zelo/zelosh-darwin-x64": "0.0.1",
+    "@zelo/zelosh-linux-arm64": "0.0.1",
+    "@zelo/zelosh-linux-x64": "0.0.1",
+    "@zelo/zelosh-win32-arm64": "0.0.1",
+    "@zelo/zelosh-win32-x64": "0.0.1"
+  },
+  "files": [
+    "bin/",
+    "README.md"
+  ]
+}