@uniac/cli 0.0.0 → 0.0.1

package/README.md

@@ -20,12 +20,18 @@ uniac --version
 
 ## How it works
 
-This package is a thin JS shim. It resolves the platform-specific binary
-(shipped via `@uniac/cli-<platform>-<arch>` packages, declared as
-`optionalDependencies`) and execs into it. No postinstall script, no
-runtime download.
+This package ships a JS shim plus a postinstall script. After `npm install`,
+the postinstall downloads the matching Go binary from this repo's
+[GitHub Releases](https://github.com/uniac-ai/Uniac/releases) and drops it
+next to the shim. The shim then `execFileSync`s the binary with your argv.
 
-Supported: `darwin-arm64`, `darwin-x64`, `linux-arm64`, `linux-x64`.
+Supported platforms: `darwin-arm64`, `darwin-x64`, `linux-arm64`, `linux-x64`.
+
+Requirements: Node 18+ (for built-in `fetch`) and `tar` on `$PATH`
+(present by default on macOS, Linux, and Windows 10 1803+).
+
+Set `UNIAC_SKIP_POSTINSTALL=1` to skip the binary download — useful for
+sandboxes that vendor the binary by other means.
 
 ## License
 

package/bin/uniac.js

@@ -1,26 +1,17 @@
 #!/usr/bin/env node
-const { execFileSync } = require('node:child_process');
-const path = require('node:path');
+// Thin shim. The postinstall script downloads the matching `uniac` Go
+// binary into this same directory; we just exec it with our argv.
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 
-const pkg = `@uniac/cli-${process.platform}-${process.arch}`;
-const exe = process.platform === 'win32' ? 'uniac.exe' : 'uniac';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const exe = process.platform === "win32" ? "uniac.exe" : "uniac";
 
-let binary;
 try {
-  const pkgJson = require.resolve(`${pkg}/package.json`);
-  binary = path.join(path.dirname(pkgJson), 'bin', exe);
-} catch {
-  console.error(
-    `[uniac] no prebuilt binary for ${process.platform}-${process.arch}.\n` +
-    `Supported: darwin-arm64, darwin-x64, linux-arm64, linux-x64.\n` +
-    `Grab the matching tar.gz from\n` +
-    `https://github.com/uniac-ai/Uniac/releases and put \`uniac\` on $PATH.`
-  );
-  process.exit(1);
-}
-
-try {
-  execFileSync(binary, process.argv.slice(2), { stdio: 'inherit' });
+  execFileSync(path.join(__dirname, exe), process.argv.slice(2), {
+    stdio: "inherit",
+  });
 } catch (err) {
-  process.exit(typeof err.status === 'number' ? err.status : 1);
+  process.exit(typeof err.status === "number" ? err.status : 1);
 }

package/npm-install/config.js

@@ -0,0 +1,25 @@
+// Postinstall configuration. Pure data, no runtime logic — keep it
+// trivial so platform/URL changes don't touch postinstall.js.
+//
+// The URL template must match the archive name_template in
+// uniac_ctl/.goreleaser.yml — they're two sides of the same contract.
+// GoReleaser produces archives named:
+//   uniac_<version>_<title-case OS>_<arch>.tar.gz
+// where arch is x86_64 for amd64 and bare arch otherwise. The GitHub
+// Release tag GoReleaser creates strips the `cli-` prefix from the
+// user-pushed tag, so the URL path uses v<version>.
+
+export const PLATFORMS = {
+  // process.platform-process.arch -> { os, arch } parts of the archive name
+  "darwin-arm64": { os: "Darwin", arch: "arm64" },
+  "darwin-x64":   { os: "Darwin", arch: "x86_64" },
+  "linux-arm64":  { os: "Linux",  arch: "arm64" },
+  "linux-x64":    { os: "Linux",  arch: "x86_64" },
+};
+
+export const URL_TEMPLATE =
+  "https://github.com/uniac-ai/Uniac/releases/download/v{{version}}/uniac_{{version}}_{{os}}_{{arch}}.tar.gz";
+
+// Name of the binary inside the tar.gz (top-level entry — GoReleaser
+// doesn't nest under a directory).
+export const BINARY_NAME = "uniac";

package/npm-install/postinstall.js

@@ -0,0 +1,77 @@
+// Runs after `npm install @uniac/cli`. Downloads the matching Go binary
+// from this repo's GitHub Release and drops it next to bin/uniac.js so
+// the shim can exec it. Zero npm deps — uses Node 18+ built-in fetch +
+// the system `tar` binary (Win10 1803+ ships one).
+//
+// Skip with UNIAC_SKIP_POSTINSTALL=1. Useful for sandbox / CI builds
+// that vendor the binary by other means.
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { PLATFORMS, URL_TEMPLATE, BINARY_NAME } from "./config.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(__dirname, "..");
+const binDir = path.join(pkgRoot, "bin");
+
+async function main() {
+  if (process.env.UNIAC_SKIP_POSTINSTALL === "1") {
+    console.log("[uniac] UNIAC_SKIP_POSTINSTALL=1 — skipping binary download.");
+    return;
+  }
+
+  const key = `${process.platform}-${process.arch}`;
+  const target = PLATFORMS[key];
+  if (!target) {
+    console.error(
+      `[uniac] no prebuilt binary for ${key}.\n` +
+      `Supported: ${Object.keys(PLATFORMS).join(", ")}.\n` +
+      `Grab the matching tar.gz from\n` +
+      `https://github.com/uniac-ai/Uniac/releases and put \`${BINARY_NAME}\` on $PATH.`
+    );
+    process.exit(1);
+  }
+
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8")
+  );
+  const version = pkg.version;
+  const url = URL_TEMPLATE
+    .replaceAll("{{version}}", version)
+    .replaceAll("{{os}}", target.os)
+    .replaceAll("{{arch}}", target.arch);
+
+  fs.mkdirSync(binDir, { recursive: true });
+  const tarPath = path.join(binDir, "uniac.tar.gz");
+
+  console.log(`[uniac] downloading ${url}`);
+  await downloadTo(url, tarPath);
+
+  // Extract just the binary — GoReleaser archives also include LICENSE
+  // and README*, which would clutter bin/. Positional arg restricts the
+  // extraction to a single entry.
+  execFileSync("tar", ["-xzf", tarPath, "-C", binDir, BINARY_NAME], {
+    stdio: "inherit",
+  });
+  fs.unlinkSync(tarPath);
+  fs.chmodSync(path.join(binDir, BINARY_NAME), 0o755);
+  console.log(`[uniac] installed ${BINARY_NAME} ${version} for ${key}`);
+}
+
+async function downloadTo(url, destPath) {
+  // Built-in fetch follows redirects automatically. GitHub Releases
+  // 302s to a CDN — Node 18+ handles that without extra code.
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText} fetching ${url}`);
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  fs.writeFileSync(destPath, buf);
+}
+
+main().catch((err) => {
+  console.error("[uniac] postinstall failed:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,29 +1,28 @@
 {
   "name": "@uniac/cli",
-  "version": "0.0.0",
+  "version": "0.0.1",
+  "type": "module",
   "description": "Control-plane CLI for Uniac services",
   "bin": {
     "uniac": "bin/uniac.js"
   },
+  "scripts": {
+    "postinstall": "node ./npm-install/postinstall.js"
+  },
   "files": [
     "bin/uniac.js",
+    "npm-install/",
     "README.md",
     "LICENSE"
   ],
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/uniac-ai/Uniac.git",
-    "directory": "uniac_ctl"
+    "directory": "uniac_cli/npm"
   },
-  "homepage": "https://uniac.ai",
-  "optionalDependencies": {
-    "@uniac/cli-darwin-arm64": "0.0.0",
-    "@uniac/cli-darwin-x64": "0.0.0",
-    "@uniac/cli-linux-arm64": "0.0.0",
-    "@uniac/cli-linux-x64": "0.0.0"
-  }
+  "homepage": "https://uniac.ai"
 }