@rindle/cli 0.1.0-rc.6

package/README.md

@@ -0,0 +1,132 @@
+# @rindle/cli — the Rindle toolchain, prebuilt for npm
+
+The Rindle **CLI** (`rindle`) and **daemon** (`rindled`), shipped as prebuilt, per-platform binaries
+you can `npm install`. This is how a JS/TS developer runs Rindle locally:
+
+- **`rindled`** — the production Rindle server: the `rindle-server` crate (the SQLite-backed
+  [`rindle-replica`](../../rindle-replica) live-query engine plus the public subscription/lease
+  plane).
+- **`rindle`** — the CLI to inspect, run, and manage a daemon: `rindle status` / `migrate` /
+  `schema`, plus the local-dev pair **`rindle init`** (scaffold) and **`rindle up`**
+  (run-and-supervise a local `rindled`, respawning it on crash or migrate-restart).
+
+This is the network counterpart of [`@rindle/replica`](../replica): both run the same
+`rindle-replica` engine, but `@rindle/replica` is a napi addon that embeds it **in-process**,
+whereas `rindled` is the standalone daemon **executable** that serves many clients over the wire.
+Talk to a running daemon from JS with [`@rindle/daemon-client`](../daemon-client).
+
+> The all-TypeScript [`@rindle/server`](../reference/server) is the *reference* implementation of
+> the same wire protocol; `rindled` is its production replacement.
+
+## Install & run
+
+```sh
+npm i -D @rindle/cli
+npx rindle init      # scaffold daemon.json
+npx rindle up        # start + supervise a local rindled; prints how to connect
+```
+
+`rindle up` prints the address the daemon is reachable at (default `http://127.0.0.1:7600`) and how
+to talk to it. From another terminal:
+
+```sh
+npx rindle status                 # inspect the running daemon
+```
+
+…or from your app, via [`@rindle/daemon-client`](../daemon-client) pointed at the same URL.
+
+Installing pulls in exactly one prebuilt-binary package for your platform via
+`optionalDependencies` (the esbuild/napi pattern) — nothing is compiled, and the other platforms'
+binaries are never downloaded.
+
+### `npm run rindle` / `npm run rindled`
+
+`npm run <name>` runs a **script**, so add this to *your* `package.json` to drive `rindle` through
+your package scripts:
+
+```jsonc
+{
+  "scripts": {
+    "rindle": "rindle"
+  }
+}
+```
+
+Then `npm run rindle up`. (Or skip the script and use `npx rindle …` directly — the bin is on your
+`node_modules/.bin`.) The daemon is run by `rindle up`, not as its own command — see below.
+
+## The daemon (`rindled`)
+
+`rindled` is **not** exposed as a CLI command here — this package is a dev convenience, and `rindle
+up` is the way to run a local daemon. The binary still ships (co-located with `rindle`), so for
+embedding it in your own Node supervisor there are programmatic helpers:
+
+```ts
+import { spawnRindled, rindledBinaryPath } from "@rindle/cli";
+
+const child = spawnRindled(["--config", "./rindled.toml"]); // inherits stdio
+// …or just locate the binary and manage the process yourself:
+const bin = rindledBinaryPath();
+```
+
+> Running the daemon directly under an external supervisor (systemd / Docker / k8s) in production is
+> a job for the cargo-dist installers or a container image, not npm.
+
+## How the packaging works
+
+- **`@rindle/cli`** (this package) is a tiny, dependency-free launcher. Its `bin/rindle`
+  (`dist/cli.js`) resolves the matching `rindle` binary for the host and execs it, forwarding
+  argv/stdio and the exit code.
+- **`@rindle/cli-<key>`** — one package per target (`darwin-arm64`, `darwin-x64`, `linux-x64-gnu`,
+  `linux-arm64-gnu`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64-msvc`), each carrying **both**
+  `rindle` and `rindled` for that platform under `bin/`,
+  gated by `os`/`cpu`/`libc`. They're listed as `optionalDependencies` of this package, so the
+  installer fetches only the matching one. They are **generated at release time** (like the napi
+  platform packages for `@rindle/replica`), never committed.
+
+Both binaries ship **co-located** on purpose: even though only `rindle` is a bin, `rindle up` runs
+`rindled` by finding it as a sibling of its own executable (rindle-cli §7.1), so the two must live in
+the same `bin/` directory.
+
+Resolution order at runtime (`src/index.ts`):
+
+1. `RINDLE_BINARY_PATH` / `RINDLED_BINARY_PATH` — explicit path to that one binary.
+2. `RINDLE_BIN_DIR` — a directory holding both (see dev usage below).
+3. the installed `@rindle/cli-<key>` optional dependency.
+
+## Local development (in this monorepo)
+
+No platform packages are installed in the workspace, so build the binaries and point the launcher at
+the build directory — one env var lights up both (and keeps them co-located for `rindle up`):
+
+```sh
+cargo build -p rindle-cli -p rindle-server --bin rindle --bin rindled --release
+RINDLE_BIN_DIR="$PWD/target/release" npx rindle up      # finds rindled in the same dir
+RINDLE_BIN_DIR="$PWD/target/release" npx rindle status
+```
+
+(Or set `RINDLE_BINARY_PATH` / `RINDLED_BINARY_PATH` to point at one binary each — e.g.
+`RINDLED_BINARY_PATH` is what `spawnRindled()` / `rindledBinaryPath()` resolve in dev.)
+
+## Releasing
+
+The native binaries already come from dist (cargo-dist): `rindle-cli` and `rindle-server` are both
+`[package.metadata.dist] dist = true`, so dist builds `rindle` and `rindled` for all four targets
+and uploads the archives + `dist-manifest.json` to a GitHub release.
+`scripts/build-npm-packages.mjs` is the bridge from those artifacts to npm:
+
+```sh
+# from a published release (reads its dist-manifest.json — no archive-name guessing):
+node scripts/build-npm-packages.mjs --from-release rindle-cli-v0.1.0 --update-root
+
+# …or from locally available binaries laid out as <dir>/<rust-target>/<bin>[.exe]:
+node scripts/build-npm-packages.mjs --bin-dir ./bins --version 0.1.0 --update-root
+```
+
+`--update-root` writes this package's `version` + `optionalDependencies` in lockstep. Then publish
+each `npm/<key>` package, then the umbrella. (The binaries + targets live in `package.json` under
+`"rindle"`, the single source of truth shared by the generator and the runtime resolver.)
+
+> This package is currently `"private": true` / `0.0.0` while the API surface settles. Clear
+> `private` and set a real version (the generator's `--version`/`--update-root` does the latter)
+> before the first publish.

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// The `rindle` CLI bin (package.json "bin" → dist/cli.js; tsc preserves this shebang). Resolves the
+// prebuilt `rindle` binary for this host and execs it, forwarding argv + stdio and propagating its
+// exit code (or re-raising its terminating signal). The daemon (`rindled`) is intentionally NOT a
+// bin — run it via `rindle up` (dev) or `spawnRindled()`; its binary still ships co-located so
+// `rindle up` finds it as a sibling.
+import { spawnSync } from "node:child_process";
+import { binaryPath, UnsupportedPlatformError } from "./index.js";
+let bin;
+try {
+    bin = binaryPath("rindle");
+}
+catch (err) {
+    process.stderr.write(`rindle: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(err instanceof UnsupportedPlatformError ? 64 : 1); // 64 = EX_USAGE
+}
+const { status, signal, error } = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+if (error) {
+    process.stderr.write(`rindle: failed to launch ${bin}: ${error.message}\n`);
+    process.exit(1);
+}
+if (typeof status === "number") {
+    process.exit(status);
+}
+// Killed by a signal — re-raise it on ourselves so the parent observes the same cause.
+process.kill(process.pid, signal ?? "SIGTERM");
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,oGAAoG;AACpG,mGAAmG;AACnG,kGAAkG;AAClG,+FAA+F;AAC/F,qCAAqC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAElE,IAAI,GAAW,CAAC;AAChB,IAAI,CAAC;IACH,GAAG,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC7B,CAAC;AAAC,OAAO,GAAG,EAAE,CAAC;IACb,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACtF,OAAO,CAAC,IAAI,CAAC,GAAG,YAAY,wBAAwB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB;AAClF,CAAC;AAED,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;AAC9F,IAAI,KAAK,EAAE,CAAC;IACV,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,GAAG,KAAK,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;IAC5E,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AACD,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;IAC/B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AACvB,CAAC;AACD,uFAAuF;AACvF,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,IAAI,SAAS,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+import { type Binary } from "./platform.ts";
+export { binaryName, platformKey, platformPackageName, UnsupportedPlatformError, } from "./platform.ts";
+export type { Binary, Libc } from "./platform.ts";
+/**
+ * Absolute path to a Rindle binary (`"rindle"` or `"rindled"`) for the current platform.
+ *
+ * Resolution order (the first three are dev overrides for working in this monorepo):
+ *  1. `RINDLE_BINARY_PATH` / `RINDLED_BINARY_PATH` — an explicit path to that one binary.
+ *  2. `RINDLE_BIN_DIR` — a directory holding both binaries. Point it at `target/release` after
+ *     `cargo build -p rindle-cli -p rindle-server --release` and a single env var lights up both
+ *     (and keeps them co-located, so `rindle up` still finds `rindled` as a sibling).
+ *  3. The matching `@rindle/cli-<key>` optional dependency that npm/pnpm installed.
+ *
+ * Throws `UnsupportedPlatformError` for an un-targeted host, or a descriptive Error if the
+ * platform package isn't installed (e.g. installed with `--no-optional`, or on a host the last
+ * publish didn't target) and no override is set.
+ */
+export declare function binaryPath(bin: Binary): string;
+/** Absolute path to the `rindle` CLI binary for the current platform. See {@link binaryPath}. */
+export declare function rindleBinaryPath(): string;
+/** Absolute path to the `rindled` daemon binary for the current platform. See {@link binaryPath}. */
+export declare function rindledBinaryPath(): string;
+/** Spawn `bin` with `args`, inheriting stdio by default. A thin wrapper over `child_process.spawn`. */
+export declare function spawnBinary(bin: Binary, args?: string[], options?: SpawnOptions): ChildProcess;
+/** Spawn the `rindle` CLI with `args`. See {@link spawnBinary}. */
+export declare function spawnRindle(args?: string[], options?: SpawnOptions): ChildProcess;
+/** Spawn the `rindled` daemon with `args`, for embedding it in a Node supervisor. See {@link spawnBinary}. */
+export declare function spawnRindled(args?: string[], options?: SpawnOptions): ChildProcess;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAS,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKjF,OAAO,EAKL,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,UAAU,EACV,WAAW,EACX,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAIlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA8B9C;AAED,iGAAiG;AACjG,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,qGAAqG;AACrG,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,uGAAuG;AACvG,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,EAAE,OAAO,GAAE,YAAiB,GAAG,YAAY,CAEtG;AAED,mEAAmE;AACnE,wBAAgB,WAAW,CAAC,IAAI,GAAE,MAAM,EAAO,EAAE,OAAO,GAAE,YAAiB,GAAG,YAAY,CAEzF;AAED,8GAA8G;AAC9G,wBAAgB,YAAY,CAAC,IAAI,GAAE,MAAM,EAAO,EAAE,OAAO,GAAE,YAAiB,GAAG,YAAY,CAE1F"}

package/dist/index.js

@@ -0,0 +1,82 @@
+// @rindle/cli — the Rindle toolchain (`rindle` CLI + `rindled` daemon) as prebuilt npm binaries.
+//
+// `rindled` is the *network front* of the engine: the `rindle-server` crate — the SQLite-backed
+// `rindle-replica` live-query engine plus the public subscription/lease plane. `rindle` is the CLI
+// that inspects and manages a deployed daemon (`rindle status`/`migrate`/…) and, for local dev,
+// scaffolds and supervises one (`rindle init` / `rindle up`). Where `@rindle/replica` is a napi
+// addon that embeds the engine *in-process*, this package ships the standalone executables,
+// prebuilt per platform by dist (cargo-dist), **co-located** so `rindle up` finds `rindled` beside
+// it. This module resolves the right binary for the host; the `rindle` bin (dist/cli.js) execs the
+// CLI, and the daemon runs via `rindle up` or `spawnRindled()` (it is not exposed as its own bin —
+// this package is a dev convenience). Pair with `@rindle/daemon-client` to talk to a running daemon.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { binaryName, platformKey, platformPackageName, UnsupportedPlatformError, } from "./platform.js";
+export { binaryName, platformKey, platformPackageName, UnsupportedPlatformError, } from "./platform.js";
+const require = createRequire(import.meta.url);
+/**
+ * Absolute path to a Rindle binary (`"rindle"` or `"rindled"`) for the current platform.
+ *
+ * Resolution order (the first three are dev overrides for working in this monorepo):
+ *  1. `RINDLE_BINARY_PATH` / `RINDLED_BINARY_PATH` — an explicit path to that one binary.
+ *  2. `RINDLE_BIN_DIR` — a directory holding both binaries. Point it at `target/release` after
+ *     `cargo build -p rindle-cli -p rindle-server --release` and a single env var lights up both
+ *     (and keeps them co-located, so `rindle up` still finds `rindled` as a sibling).
+ *  3. The matching `@rindle/cli-<key>` optional dependency that npm/pnpm installed.
+ *
+ * Throws `UnsupportedPlatformError` for an un-targeted host, or a descriptive Error if the
+ * platform package isn't installed (e.g. installed with `--no-optional`, or on a host the last
+ * publish didn't target) and no override is set.
+ */
+export function binaryPath(bin) {
+    const explicit = process.env[`${bin.toUpperCase()}_BINARY_PATH`];
+    if (explicit) {
+        if (!existsSync(explicit)) {
+            throw new Error(`${bin.toUpperCase()}_BINARY_PATH points at a missing file: ${explicit}`);
+        }
+        return explicit;
+    }
+    const file = binaryName(bin);
+    const binDir = process.env.RINDLE_BIN_DIR;
+    if (binDir) {
+        const candidate = join(binDir, file);
+        if (existsSync(candidate))
+            return candidate;
+        // Fall through to the installed package — `RINDLE_BIN_DIR` may legitimately hold only one bin.
+    }
+    const key = platformKey(); // throws UnsupportedPlatformError for un-targeted hosts
+    const pkg = platformPackageName(key);
+    let manifest;
+    try {
+        manifest = require.resolve(`${pkg}/package.json`);
+    }
+    catch {
+        throw new Error(`${pkg} is not installed — the prebuilt Rindle binaries for "${key}" are missing.\n` +
+            `They ship as an optional dependency of @rindle/cli; reinstall without --no-optional, ` +
+            `or set RINDLE_BIN_DIR to a directory of locally built binaries.`);
+    }
+    return join(dirname(manifest), "bin", file);
+}
+/** Absolute path to the `rindle` CLI binary for the current platform. See {@link binaryPath}. */
+export function rindleBinaryPath() {
+    return binaryPath("rindle");
+}
+/** Absolute path to the `rindled` daemon binary for the current platform. See {@link binaryPath}. */
+export function rindledBinaryPath() {
+    return binaryPath("rindled");
+}
+/** Spawn `bin` with `args`, inheriting stdio by default. A thin wrapper over `child_process.spawn`. */
+export function spawnBinary(bin, args = [], options = {}) {
+    return spawn(binaryPath(bin), args, { stdio: "inherit", ...options });
+}
+/** Spawn the `rindle` CLI with `args`. See {@link spawnBinary}. */
+export function spawnRindle(args = [], options = {}) {
+    return spawnBinary("rindle", args, options);
+}
+/** Spawn the `rindled` daemon with `args`, for embedding it in a Node supervisor. See {@link spawnBinary}. */
+export function spawnRindled(args = [], options = {}) {
+    return spawnBinary("rindled", args, options);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/platform.d.ts

@@ -0,0 +1,17 @@
+export type Libc = "gnu" | "musl";
+/** A Rindle binary shipped by this toolchain: the CLI (`rindle`) or the daemon (`rindled`). */
+export type Binary = "rindle" | "rindled";
+/**
+ * The package-name suffix identifying a build target for the current (or given) host:
+ * `darwin-{arm64,x64}`, `linux-{x64,arm64}-{gnu,musl}`, `win32-x64-msvc`. Throws
+ * `UnsupportedPlatformError` for a host we don't publish binaries for.
+ */
+export declare function platformKey(platform?: NodeJS.Platform, arch?: string, libc?: Libc): string;
+/** The npm package name carrying the binaries for `key` (default: the current host's key). */
+export declare function platformPackageName(key?: string): string;
+/** The on-disk filename of `bin` inside a platform package (`rindle` / `rindled.exe`). */
+export declare function binaryName(bin: Binary, platform?: NodeJS.Platform): string;
+export declare class UnsupportedPlatformError extends Error {
+    constructor(platform: string, arch: string);
+}
+//# sourceMappingURL=platform.d.ts.map

package/dist/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../src/platform.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,MAAM,CAAC;AAElC,+FAA+F;AAC/F,MAAM,MAAM,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE1C;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,GAAE,MAAM,CAAC,QAA2B,EAC5C,IAAI,GAAE,MAAqB,EAC3B,IAAI,GAAE,IAA2B,GAChC,MAAM,CAWR;AAED,8FAA8F;AAC9F,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAsB,GAAG,MAAM,CAEvE;AAED,0FAA0F;AAC1F,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAAG,MAAM,CAE5F;AAED,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAI3C"}

package/dist/platform.js

@@ -0,0 +1,54 @@
+// Single source of truth for mapping the *running* Node platform to the per-platform package that
+// carries the prebuilt Rindle binaries (`rindle` + `rindled`) for it. Those packages
+// (`@rindle/cli-<key>`) are generated at release time by `scripts/build-npm-packages.mjs` from
+// dist's (cargo-dist) release archives, and declared as optionalDependencies of this umbrella
+// package — so npm/pnpm install only the one whose `os`/`cpu` match the host. Both binaries ship
+// **co-located** in that one package's `bin/`, which is required: the `rindle` CLI's `rindle up`
+// finds `rindled` as a sibling of its own executable (rindle-cli §7.1). This module and the
+// generator MUST agree on the `<key>` scheme; it is defined here and mirrored in the generator.
+/**
+ * The package-name suffix identifying a build target for the current (or given) host:
+ * `darwin-{arm64,x64}`, `linux-{x64,arm64}-{gnu,musl}`, `win32-x64-msvc`. Throws
+ * `UnsupportedPlatformError` for a host we don't publish binaries for.
+ */
+export function platformKey(platform = process.platform, arch = process.arch, libc = detectLibc(platform)) {
+    switch (platform) {
+        case "darwin":
+            return `darwin-${arch}`;
+        case "linux":
+            return `linux-${arch}-${libc}`;
+        case "win32":
+            return `win32-${arch}-msvc`;
+        default:
+            throw new UnsupportedPlatformError(platform, arch);
+    }
+}
+/** The npm package name carrying the binaries for `key` (default: the current host's key). */
+export function platformPackageName(key = platformKey()) {
+    return `@rindle/cli-${key}`;
+}
+/** The on-disk filename of `bin` inside a platform package (`rindle` / `rindled.exe`). */
+export function binaryName(bin, platform = process.platform) {
+    return platform === "win32" ? `${bin}.exe` : bin;
+}
+export class UnsupportedPlatformError extends Error {
+    constructor(platform, arch) {
+        super(`@rindle/cli ships no prebuilt Rindle binaries for ${platform}-${arch}`);
+        this.name = "UnsupportedPlatformError";
+    }
+}
+// glibc vs musl: Node reports the runtime glibc version in its process report on glibc systems;
+// its absence on linux implies musl. We publish both `-gnu` and `-musl` Linux packages, so this
+// picks the right one (and avoids a `detect-libc` dependency — the launcher stays dep-free).
+function detectLibc(platform) {
+    if (platform !== "linux")
+        return "gnu";
+    try {
+        const report = process.report?.getReport();
+        return report?.header?.glibcVersionRuntime ? "gnu" : "musl";
+    }
+    catch {
+        return "gnu";
+    }
+}
+//# sourceMappingURL=platform.js.map

package/dist/platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","sourceRoot":"","sources":["../src/platform.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,qFAAqF;AACrF,+FAA+F;AAC/F,8FAA8F;AAC9F,iGAAiG;AACjG,iGAAiG;AACjG,4FAA4F;AAC5F,gGAAgG;AAOhG;;;;GAIG;AACH,MAAM,UAAU,WAAW,CACzB,WAA4B,OAAO,CAAC,QAAQ,EAC5C,OAAe,OAAO,CAAC,IAAI,EAC3B,OAAa,UAAU,CAAC,QAAQ,CAAC;IAEjC,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,QAAQ;YACX,OAAO,UAAU,IAAI,EAAE,CAAC;QAC1B,KAAK,OAAO;YACV,OAAO,SAAS,IAAI,IAAI,IAAI,EAAE,CAAC;QACjC,KAAK,OAAO;YACV,OAAO,SAAS,IAAI,OAAO,CAAC;QAC9B;YACE,MAAM,IAAI,wBAAwB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACvD,CAAC;AACH,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,mBAAmB,CAAC,MAAc,WAAW,EAAE;IAC7D,OAAO,eAAe,GAAG,EAAE,CAAC;AAC9B,CAAC;AAED,0FAA0F;AAC1F,MAAM,UAAU,UAAU,CAAC,GAAW,EAAE,WAA4B,OAAO,CAAC,QAAQ;IAClF,OAAO,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;AACnD,CAAC;AAED,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IACjD,YAAY,QAAgB,EAAE,IAAY;QACxC,KAAK,CAAC,qDAAqD,QAAQ,IAAI,IAAI,EAAE,CAAC,CAAC;QAC/E,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AAED,gGAAgG;AAChG,gGAAgG;AAChG,6FAA6F;AAC7F,SAAS,UAAU,CAAC,QAAyB;IAC3C,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IACvC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,SAAS,EAE3B,CAAC;QACd,OAAO,MAAM,EAAE,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;IAC9D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC"}

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@rindle/cli",
+  "version": "0.1.0-rc.6",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rindle-sh/rindle.git",
+    "directory": "packages/cli"
+  },
+  "type": "module",
+  "description": "The Rindle toolchain for JS devs: the `rindle` CLI and the `rindled` daemon as prebuilt, per-platform binaries you can `npm install`. `rindle up` scaffolds and supervises a local daemon.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "bin": {
+    "rindle": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "@rindle/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "tsc --noEmit && node --conditions=@rindle/source --test test/*.test.ts",
+    "build:npm": "node scripts/build-npm-packages.mjs"
+  },
+  "rindle": {
+    "binaries": [
+      "rindle",
+      "rindled"
+    ],
+    "repository": "rindle-sh/rindle",
+    "targets": [
+      {
+        "rust": "aarch64-apple-darwin",
+        "os": "darwin",
+        "cpu": "arm64"
+      },
+      {
+        "rust": "x86_64-apple-darwin",
+        "os": "darwin",
+        "cpu": "x64"
+      },
+      {
+        "rust": "x86_64-unknown-linux-gnu",
+        "os": "linux",
+        "cpu": "x64",
+        "libc": "gnu"
+      },
+      {
+        "rust": "aarch64-unknown-linux-gnu",
+        "os": "linux",
+        "cpu": "arm64",
+        "libc": "gnu"
+      },
+      {
+        "rust": "x86_64-unknown-linux-musl",
+        "os": "linux",
+        "cpu": "x64",
+        "libc": "musl"
+      },
+      {
+        "rust": "aarch64-unknown-linux-musl",
+        "os": "linux",
+        "cpu": "arm64",
+        "libc": "musl"
+      },
+      {
+        "rust": "x86_64-pc-windows-msvc",
+        "os": "win32",
+        "cpu": "x64"
+      }
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0"
+  },
+  "optionalDependencies": {
+    "@rindle/cli-darwin-arm64": "0.1.0-rc.6",
+    "@rindle/cli-darwin-x64": "0.1.0-rc.6",
+    "@rindle/cli-linux-arm64-gnu": "0.1.0-rc.6",
+    "@rindle/cli-linux-arm64-musl": "0.1.0-rc.6",
+    "@rindle/cli-linux-x64-gnu": "0.1.0-rc.6",
+    "@rindle/cli-linux-x64-musl": "0.1.0-rc.6",
+    "@rindle/cli-win32-x64-msvc": "0.1.0-rc.6"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// The `rindle` CLI bin (package.json "bin" → dist/cli.js; tsc preserves this shebang). Resolves the
+// prebuilt `rindle` binary for this host and execs it, forwarding argv + stdio and propagating its
+// exit code (or re-raising its terminating signal). The daemon (`rindled`) is intentionally NOT a
+// bin — run it via `rindle up` (dev) or `spawnRindled()`; its binary still ships co-located so
+// `rindle up` finds it as a sibling.
+import { spawnSync } from "node:child_process";
+
+import { binaryPath, UnsupportedPlatformError } from "./index.ts";
+
+let bin: string;
+try {
+  bin = binaryPath("rindle");
+} catch (err) {
+  process.stderr.write(`rindle: ${err instanceof Error ? err.message : String(err)}\n`);
+  process.exit(err instanceof UnsupportedPlatformError ? 64 : 1); // 64 = EX_USAGE
+}
+
+const { status, signal, error } = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+if (error) {
+  process.stderr.write(`rindle: failed to launch ${bin}: ${error.message}\n`);
+  process.exit(1);
+}
+if (typeof status === "number") {
+  process.exit(status);
+}
+// Killed by a signal — re-raise it on ourselves so the parent observes the same cause.
+process.kill(process.pid, signal ?? "SIGTERM");

package/src/index.ts

@@ -0,0 +1,104 @@
+// @rindle/cli — the Rindle toolchain (`rindle` CLI + `rindled` daemon) as prebuilt npm binaries.
+//
+// `rindled` is the *network front* of the engine: the `rindle-server` crate — the SQLite-backed
+// `rindle-replica` live-query engine plus the public subscription/lease plane. `rindle` is the CLI
+// that inspects and manages a deployed daemon (`rindle status`/`migrate`/…) and, for local dev,
+// scaffolds and supervises one (`rindle init` / `rindle up`). Where `@rindle/replica` is a napi
+// addon that embeds the engine *in-process*, this package ships the standalone executables,
+// prebuilt per platform by dist (cargo-dist), **co-located** so `rindle up` finds `rindled` beside
+// it. This module resolves the right binary for the host; the `rindle` bin (dist/cli.js) execs the
+// CLI, and the daemon runs via `rindle up` or `spawnRindled()` (it is not exposed as its own bin —
+// this package is a dev convenience). Pair with `@rindle/daemon-client` to talk to a running daemon.
+import { spawn, type ChildProcess, type SpawnOptions } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+import {
+  binaryName,
+  platformKey,
+  platformPackageName,
+  UnsupportedPlatformError,
+  type Binary,
+} from "./platform.ts";
+
+export {
+  binaryName,
+  platformKey,
+  platformPackageName,
+  UnsupportedPlatformError,
+} from "./platform.ts";
+export type { Binary, Libc } from "./platform.ts";
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Absolute path to a Rindle binary (`"rindle"` or `"rindled"`) for the current platform.
+ *
+ * Resolution order (the first three are dev overrides for working in this monorepo):
+ *  1. `RINDLE_BINARY_PATH` / `RINDLED_BINARY_PATH` — an explicit path to that one binary.
+ *  2. `RINDLE_BIN_DIR` — a directory holding both binaries. Point it at `target/release` after
+ *     `cargo build -p rindle-cli -p rindle-server --release` and a single env var lights up both
+ *     (and keeps them co-located, so `rindle up` still finds `rindled` as a sibling).
+ *  3. The matching `@rindle/cli-<key>` optional dependency that npm/pnpm installed.
+ *
+ * Throws `UnsupportedPlatformError` for an un-targeted host, or a descriptive Error if the
+ * platform package isn't installed (e.g. installed with `--no-optional`, or on a host the last
+ * publish didn't target) and no override is set.
+ */
+export function binaryPath(bin: Binary): string {
+  const explicit = process.env[`${bin.toUpperCase()}_BINARY_PATH`];
+  if (explicit) {
+    if (!existsSync(explicit)) {
+      throw new Error(`${bin.toUpperCase()}_BINARY_PATH points at a missing file: ${explicit}`);
+    }
+    return explicit;
+  }
+
+  const file = binaryName(bin);
+  const binDir = process.env.RINDLE_BIN_DIR;
+  if (binDir) {
+    const candidate = join(binDir, file);
+    if (existsSync(candidate)) return candidate;
+    // Fall through to the installed package — `RINDLE_BIN_DIR` may legitimately hold only one bin.
+  }
+
+  const key = platformKey(); // throws UnsupportedPlatformError for un-targeted hosts
+  const pkg = platformPackageName(key);
+  let manifest: string;
+  try {
+    manifest = require.resolve(`${pkg}/package.json`);
+  } catch {
+    throw new Error(
+      `${pkg} is not installed — the prebuilt Rindle binaries for "${key}" are missing.\n` +
+        `They ship as an optional dependency of @rindle/cli; reinstall without --no-optional, ` +
+        `or set RINDLE_BIN_DIR to a directory of locally built binaries.`,
+    );
+  }
+  return join(dirname(manifest), "bin", file);
+}
+
+/** Absolute path to the `rindle` CLI binary for the current platform. See {@link binaryPath}. */
+export function rindleBinaryPath(): string {
+  return binaryPath("rindle");
+}
+
+/** Absolute path to the `rindled` daemon binary for the current platform. See {@link binaryPath}. */
+export function rindledBinaryPath(): string {
+  return binaryPath("rindled");
+}
+
+/** Spawn `bin` with `args`, inheriting stdio by default. A thin wrapper over `child_process.spawn`. */
+export function spawnBinary(bin: Binary, args: string[] = [], options: SpawnOptions = {}): ChildProcess {
+  return spawn(binaryPath(bin), args, { stdio: "inherit", ...options });
+}
+
+/** Spawn the `rindle` CLI with `args`. See {@link spawnBinary}. */
+export function spawnRindle(args: string[] = [], options: SpawnOptions = {}): ChildProcess {
+  return spawnBinary("rindle", args, options);
+}
+
+/** Spawn the `rindled` daemon with `args`, for embedding it in a Node supervisor. See {@link spawnBinary}. */
+export function spawnRindled(args: string[] = [], options: SpawnOptions = {}): ChildProcess {
+  return spawnBinary("rindled", args, options);
+}

package/src/platform.ts

@@ -0,0 +1,67 @@
+// Single source of truth for mapping the *running* Node platform to the per-platform package that
+// carries the prebuilt Rindle binaries (`rindle` + `rindled`) for it. Those packages
+// (`@rindle/cli-<key>`) are generated at release time by `scripts/build-npm-packages.mjs` from
+// dist's (cargo-dist) release archives, and declared as optionalDependencies of this umbrella
+// package — so npm/pnpm install only the one whose `os`/`cpu` match the host. Both binaries ship
+// **co-located** in that one package's `bin/`, which is required: the `rindle` CLI's `rindle up`
+// finds `rindled` as a sibling of its own executable (rindle-cli §7.1). This module and the
+// generator MUST agree on the `<key>` scheme; it is defined here and mirrored in the generator.
+
+export type Libc = "gnu" | "musl";
+
+/** A Rindle binary shipped by this toolchain: the CLI (`rindle`) or the daemon (`rindled`). */
+export type Binary = "rindle" | "rindled";
+
+/**
+ * The package-name suffix identifying a build target for the current (or given) host:
+ * `darwin-{arm64,x64}`, `linux-{x64,arm64}-{gnu,musl}`, `win32-x64-msvc`. Throws
+ * `UnsupportedPlatformError` for a host we don't publish binaries for.
+ */
+export function platformKey(
+  platform: NodeJS.Platform = process.platform,
+  arch: string = process.arch,
+  libc: Libc = detectLibc(platform),
+): string {
+  switch (platform) {
+    case "darwin":
+      return `darwin-${arch}`;
+    case "linux":
+      return `linux-${arch}-${libc}`;
+    case "win32":
+      return `win32-${arch}-msvc`;
+    default:
+      throw new UnsupportedPlatformError(platform, arch);
+  }
+}
+
+/** The npm package name carrying the binaries for `key` (default: the current host's key). */
+export function platformPackageName(key: string = platformKey()): string {
+  return `@rindle/cli-${key}`;
+}
+
+/** The on-disk filename of `bin` inside a platform package (`rindle` / `rindled.exe`). */
+export function binaryName(bin: Binary, platform: NodeJS.Platform = process.platform): string {
+  return platform === "win32" ? `${bin}.exe` : bin;
+}
+
+export class UnsupportedPlatformError extends Error {
+  constructor(platform: string, arch: string) {
+    super(`@rindle/cli ships no prebuilt Rindle binaries for ${platform}-${arch}`);
+    this.name = "UnsupportedPlatformError";
+  }
+}
+
+// glibc vs musl: Node reports the runtime glibc version in its process report on glibc systems;
+// its absence on linux implies musl. We publish both `-gnu` and `-musl` Linux packages, so this
+// picks the right one (and avoids a `detect-libc` dependency — the launcher stays dep-free).
+function detectLibc(platform: NodeJS.Platform): Libc {
+  if (platform !== "linux") return "gnu";
+  try {
+    const report = process.report?.getReport() as
+      | { header?: { glibcVersionRuntime?: string } }
+      | undefined;
+    return report?.header?.glibcVersionRuntime ? "gnu" : "musl";
+  } catch {
+    return "gnu";
+  }
+}