@uniac/cli 0.0.1 → 0.2.1

package/README.md

@@ -8,30 +8,39 @@ Control-plane CLI for [Uniac](https://uniac.ai).
 npm i -g @uniac/cli
 ```
 
-Verify:
+Or run without installing:
 
 ```bash
-uniac --version
+npx -y @uniac/cli version
 ```
 
-## Other channels
-
-- GitHub Releases (raw tar.gz): <https://github.com/uniac-ai/Uniac/releases>
-
 ## How it works
 
-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 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.
+`@uniac/cli` is a tiny JS shim plus one `optionalDependencies` entry
+per supported platform (`@uniac/cli-darwin-arm64`, …), each carrying
+the prebuilt Go binary. npm installs only the package whose `os`/`cpu`
+fields match the machine and verifies its registry checksum; the shim
+resolves that package's `bin/uniac` and runs it with your argv.
+
+No package in the set has install scripts or fetches anything outside
+the npm registry, so installs work in restricted environments — CI,
+containers, AI-agent sandboxes — including under `--ignore-scripts`
+and behind proxies or registry mirrors.
+
+Supported platforms: `darwin-arm64`, `darwin-x64`, `linux-arm64`,
+`linux-x64` — the authoritative table is [`targets.js`](./targets.js).
+On any other platform, grab a tar.gz from
+[GitHub Releases](https://github.com/uniac-ai/Uniac/releases) and put
+`uniac` on `$PATH`.
+
+## Releasing
+
+`.github/workflows/release.yml` publishes on `cli-v*` tags: it runs
+[`scripts/package-platform-npm.js`](./scripts/package-platform-npm.js)
+to turn GoReleaser's `dist/` into the platform packages and pin them
+as exact-version `optionalDependencies` here, then publishes the
+platform packages followed by this meta package. See
+[`../go/README.md`](../go/README.md) for the full release runbook.
 
 ## License
 

package/bin/uniac.js

@@ -1,17 +1,47 @@
 #!/usr/bin/env node
-// 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";
+// Shim that resolves the platform-matched `uniac` Go binary — shipped
+// as the optionalDependency @uniac/cli-<platform>-<arch> — and runs
+// it with this process's argv, stdio, and exit status.
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { TARGETS, packageName } from "../targets.js";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const exe = process.platform === "win32" ? "uniac.exe" : "uniac";
+const key = `${process.platform}-${process.arch}`;
 
+function fail(lines) {
+  console.error(lines.map((l) => `[uniac] ${l}`).join("\n"));
+  process.exit(1);
+}
+
+if (!(key in TARGETS)) {
+  fail([
+    `no prebuilt binary for ${key}.`,
+    `Supported: ${Object.keys(TARGETS).join(", ")}.`,
+    "Grab a tar.gz from https://github.com/uniac-ai/Uniac/releases",
+    "and put `uniac` on $PATH instead.",
+  ]);
+}
+
+let binary;
 try {
-  execFileSync(path.join(__dirname, exe), process.argv.slice(2), {
-    stdio: "inherit",
-  });
-} catch (err) {
-  process.exit(typeof err.status === "number" ? err.status : 1);
+  binary = createRequire(import.meta.url).resolve(
+    `${packageName(key)}/bin/uniac`
+  );
+} catch {
+  fail([
+    `${packageName(key)} is missing.`,
+    "It carries the uniac binary and installs as an optionalDependency",
+    "of @uniac/cli — reinstall without --omit=optional/--no-optional:",
+    "  npm install -g @uniac/cli",
+  ]);
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+if (result.error) {
+  fail([`failed to run ${binary}: ${result.error.message}`]);
+}
+if (result.signal) {
+  // Re-raise so the caller observes the same termination signal.
+  process.kill(process.pid, result.signal);
 }
+process.exit(result.status ?? 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniac/cli",
-  "version": "0.0.1",
+  "version": "0.2.1",
   "type": "module",
   "description": "Control-plane CLI for Uniac services",
   "bin": {
@@ -24,5 +24,11 @@
     "url": "https://github.com/uniac-ai/Uniac.git",
     "directory": "uniac_cli/npm"
   },
-  "homepage": "https://uniac.ai"
+  "homepage": "https://uniac.ai",
+  "optionalDependencies": {
+    "@uniac/cli-darwin-arm64": "0.2.1",
+    "@uniac/cli-darwin-x64": "0.2.1",
+    "@uniac/cli-linux-arm64": "0.2.1",
+    "@uniac/cli-linux-x64": "0.2.1"
+  }
 }

package/npm-install/config.js

@@ -1,25 +0,0 @@
-// 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

@@ -1,77 +0,0 @@
-// 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);
-});