@civitai/cli 0.1.119 → 0.1.121

package/README.md

@@ -2,8 +2,10 @@
 
 The Civitai CLI — author and ship [Civitai App Blocks](https://github.com/civitai/cli).
 
-This npm package is a **thin wrapper** over the Go CLI. On install it downloads
-the prebuilt binary for your platform from the project's
+This npm package is a **thin wrapper** over the Go CLI. On linux/x64 the
+prebuilt binary arrives as an npm package of its own
+(`@civitai/cli-linux-x64`), so installing needs only the npm registry. On other
+platforms the wrapper downloads the binary from the project's
 [GitHub Releases](https://github.com/civitai/cli/releases) and verifies its
 sha256 checksum.
 
@@ -22,7 +24,11 @@ npx @civitai/cli app create my-app
 
 ## How it works
 
-- On `npm install`, a `postinstall` step downloads
+- On linux/x64, npm installs `@civitai/cli-linux-x64` (an optional dependency
+  pinned to the same version), which contains the binary. Nothing is
+  downloaded outside the npm registry.
+- Everywhere else — or if optional dependencies were skipped
+  (`--omit=optional`) — a `postinstall` step downloads
   `civitai_<version>_<os>_<arch>` from the matching GitHub Release and verifies
   it against `checksums.txt`.
 - The `civitai` command then execs that binary, forwarding all arguments and

package/bin/civitai.js

@@ -1,22 +1,21 @@
 #!/usr/bin/env node
 "use strict";
 
-// Thin launcher for the @civitai/cli wrapper: locate (or lazily download) the
-// prebuilt Go binary and exec it, forwarding args, stdio, and exit status.
+// Thin launcher for the @civitai/cli wrapper: locate the prebuilt Go binary
+// (platform package first, else a lazily downloaded one — see lib/install.js)
+// and exec it, forwarding args, stdio, and exit status.
 
 const fs = require("fs");
 const { spawnSync } = require("child_process");
-const { ensureBinary, binaryPath } = require("../lib/install.js");
+const { ensureBinary } = require("../lib/install.js");
 
 async function resolveBinary() {
   // Escape hatch + test hook: use an explicit binary if provided and present.
   const override = process.env.CIVITAI_CLI_BINARY;
   if (override && fs.existsSync(override)) return override;
 
-  const bin = binaryPath();
-  if (fs.existsSync(bin)) return bin;
-
-  // Missing (e.g. `npm install --ignore-scripts`) — download it now.
+  // The platform package's binary, else the one postinstall downloaded, else
+  // (e.g. `npm install --ignore-scripts`) download it now.
   return ensureBinary();
 }
 

package/lib/install.js

@@ -2,11 +2,20 @@
 
 // Dependency-free installer for the @civitai/cli wrapper.
 //
-// Downloads the prebuilt Go binary produced by GoReleaser from the matching
-// GitHub Release, verifies its sha256 against checksums.txt, and drops it at
-// lib/binaries/civitai(.exe). Runs from the npm `postinstall` hook, and is also
-// exported as ensureBinary() so the launcher can lazily download on first run
-// (covers `npm install --ignore-scripts`).
+// Finds the prebuilt Go binary, in this order:
+//
+//  1. The platform package (an `optionalDependencies` entry such as
+//     @civitai/cli-linux-x64, listed in ./platforms.json) when npm installed
+//     one for this host. It IS the binary, so nothing is downloaded — the
+//     install works where only the npm registry is reachable.
+//  2. Otherwise the GitHub Release: download the raw binary GoReleaser
+//     produced, verify its sha256 against checksums.txt, and drop it at
+//     lib/binaries/civitai(.exe). This is every platform without a row in
+//     platforms.json, and any install that skipped optional dependencies.
+//
+// Runs from the npm `postinstall` hook, and is also exported as ensureBinary()
+// so the launcher can resolve lazily on first run (covers
+// `npm install --ignore-scripts`).
 
 const fs = require("fs");
 const path = require("path");
@@ -19,6 +28,15 @@ const PLACEHOLDER_VERSION = "0.0.0-dev";
 
 const BINARIES_DIR = path.join(__dirname, "binaries");
 
+// THE list of platform packages: one row per package, `{ package, os, cpu }` in
+// Node's own process.platform / process.arch vocabulary. This resolver and the
+// release workflow follow it: scripts/release.js generates the published
+// package.json's optionalDependencies from it and tells the workflow what to
+// publish. Adding a non-Windows platform is one row here — and a one-time
+// manual first publish of the new package name, which is why the list is short.
+// A win32 row also needs PLATFORM_BINARY_FILE to gain the `.exe` suffix.
+const PLATFORMS = require("./platforms.json");
+
 // Map Node's platform/arch onto GoReleaser's os/arch tokens.
 const OS_MAP = { linux: "linux", darwin: "darwin", win32: "windows" };
 const ARCH_MAP = { x64: "amd64", arm64: "arm64" };
@@ -28,12 +46,12 @@ const ARCH_MAP = { x64: "amd64", arm64: "arm64" };
 // re-add an entry here if a target is ever dropped from the release matrix.
 const UNSUPPORTED = new Set([]);
 
-function target() {
-  const goos = OS_MAP[process.platform];
-  const goarch = ARCH_MAP[process.arch];
+function target(platform = process.platform, arch = process.arch) {
+  const goos = OS_MAP[platform];
+  const goarch = ARCH_MAP[arch];
   if (!goos || !goarch) {
     throw new Error(
-      `Unsupported platform for @civitai/cli: ${process.platform}/${process.arch}. ` +
+      `Unsupported platform for @civitai/cli: ${platform}/${arch}. ` +
         `Supported: linux, darwin, windows on x64/arm64. ` +
         `Install the CLI another way: https://github.com/${REPO}#installation`
     );
@@ -52,6 +70,51 @@ function binaryPath() {
   return path.join(BINARIES_DIR, exe);
 }
 
+// Where a platform package keeps its binary, relative to the package root.
+const PLATFORM_BINARY_FILE = "bin/civitai";
+
+// The binary shipped by this host's platform package, or null when there is no
+// row for this host, npm did not install the package (--omit=optional, an
+// older lockfile, a platform without a row), or the copy node resolves is a
+// different version from this wrapper (a hoisted leftover) — the caller then
+// downloads the right one. Never touches the network.
+function platformBinary() {
+  const row = PLATFORMS.find((p) => p.os === process.platform && p.cpu === process.arch);
+  if (!row) return null;
+  try {
+    if (require(`${row.package}/package.json`).version !== require("../package.json").version) {
+      return null;
+    }
+    return require.resolve(`${row.package}/${PLATFORM_BINARY_FILE}`);
+  } catch (_) {
+    return null;
+  }
+}
+
+// Keep lib/binaries/civitai pointing at the platform package's binary.
+// `civitai agent-setup --fix-path` writes that directory into shell profiles
+// (it is where the downloaded binary lives), guarded by `[ -x …/civitai ]`;
+// without this link an upgrade to a platform-package version would silently
+// drop `civitai` from those users' PATH. Replaces whatever is there, so a
+// binary downloaded by an older version cannot be left behind. Best effort: the
+// platform binary works without it.
+function linkPlatformBinary(shipped) {
+  const dest = binaryPath();
+  const want = path.relative(BINARIES_DIR, shipped);
+  try {
+    if (fs.readlinkSync(dest) === want) return;
+  } catch (_) {
+    // not a symlink, or not there
+  }
+  try {
+    fs.mkdirSync(BINARIES_DIR, { recursive: true });
+    fs.rmSync(dest, { force: true });
+    fs.symlinkSync(want, dest);
+  } catch (_) {
+    // read-only install tree, or a filesystem without symlinks
+  }
+}
+
 function resolveVersion() {
   const { version } = require("../package.json");
   if (!version || version === PLACEHOLDER_VERSION) {
@@ -139,7 +202,16 @@ function findChecksum(checksumsText, asset) {
 }
 
 async function ensureBinary() {
+  const shipped = platformBinary();
+  if (shipped) {
+    linkPlatformBinary(shipped);
+    return shipped;
+  }
+
   const dest = binaryPath();
+  // A link left by linkPlatformBinary is not a download: the platform package
+  // it pointed at is gone or is now the wrong version.
+  if (fs.lstatSync(dest, { throwIfNoEntry: false })?.isSymbolicLink()) fs.rmSync(dest);
   if (fs.existsSync(dest)) return dest;
 
   const t = target();
@@ -172,12 +244,21 @@ async function ensureBinary() {
   return dest;
 }
 
-module.exports = { ensureBinary, binaryPath };
+module.exports = {
+  ensureBinary,
+  binaryPath,
+  platformBinary,
+  // For scripts/release.js, which builds the platform packages at publish time.
+  PLATFORMS,
+  PLATFORM_BINARY_FILE,
+  target,
+  assetName,
+};
 
 if (require.main === module) {
   ensureBinary()
     .then((p) => {
-      console.log(`@civitai/cli: installed binary at ${p}`);
+      console.log(`@civitai/cli: using binary at ${p}`);
     })
     .catch((err) => {
       console.error(`@civitai/cli: failed to install binary.\n${err.message}`);

package/lib/platforms.json

@@ -0,0 +1,3 @@
+[
+  { "package": "@civitai/cli-linux-x64", "os": "linux", "cpu": "x64" }
+]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civitai/cli",
-  "version": "0.1.119",
+  "version": "0.1.121",
   "description": "The Civitai CLI — author and ship Civitai App Blocks. Installs the prebuilt Go binary.",
   "bin": {
     "civitai": "bin/civitai.js"
@@ -43,5 +43,8 @@
   "cpu": [
     "x64",
     "arm64"
-  ]
+  ],
+  "optionalDependencies": {
+    "@civitai/cli-linux-x64": "0.1.121"
+  }
 }