riftri 0.6.1 → 0.6.3

package/lib/client.d.ts

@@ -5,6 +5,9 @@ export const EXIT_OPERATIONAL: 1;
 export const EXIT_USAGE: 2;
 export const EXIT_POLICY: 3;
 
+/** Resolve and validate the installed native executable, honoring RIFTRI_BINARY. Does not spawn. */
+export function resolveBinary(): string;
+
 /** One versioned failure receipt, as emitted by `--json-errors`. */
 export interface FailureReceipt {
   schemaVersion: number;
@@ -37,7 +40,9 @@ export class RiftriError extends Error {
   /** The process was killed rather than exiting on its own. */
   readonly wasSignalled: boolean;
   readonly receipt: FailureReceipt | null;
-  /** Riftri declined before touching anything; falling back is safe. */
+  /** Parsed stdout on a nonzero exit (for example a failed post-checkout hook), or null. Validate before use. */
+  readonly report: unknown;
+  /** A native policy receipt confirms no mutation; an exit code alone is insufficient. */
   readonly isPolicyRefusal: boolean;
   /** The request was malformed; never retry it unchanged. */
   readonly isUsageError: boolean;
@@ -110,6 +115,28 @@ export interface WorktreeInventory {
   native_path_encoding: string;
 }
 
+export interface WorktreeOwner {
+  schema_version: 1;
+  /** Null only when no registered state claims the path. Errors reject. */
+  state_directory: string | null;
+  state_directory_native_hex: string | null;
+  native_path_encoding: string;
+}
+
+export interface WorktreeInspectionReport {
+  schema_version: 1;
+  native_path_encoding: string;
+  worktrees: Array<{
+    path: string;
+    path_native_hex: string;
+    state_directory: string | null;
+    state_directory_native_hex: string | null;
+    backend: string | null;
+    /** Null unless the managed backend needs a mount. Inspection never repairs. */
+    mount_status: "active" | "recovery-required" | "different-namespace" | "foreign" | "unavailable" | null;
+  }>;
+}
+
 export interface StateDiagnosticIssue {
   path: string;
   path_native_hex: string;
@@ -239,6 +266,10 @@ export class Riftri {
 
   readonly worktree: {
     add(destination: string, options?: AddOptions): Promise<AddReport>;
+    /** Advisory ownership lookup without disk accounting; mutations revalidate. */
+    owner(destination: string): Promise<WorktreeOwner>;
+    /** One read-only discovery pass; paths retain the requested order. */
+    inspect(destinations: readonly string[]): Promise<WorktreeInspectionReport>;
     list(options: { allStates: true }): Promise<AllStatesWorktreeInventory>;
     list(options?: { allStates?: false }): Promise<WorktreeInventory>;
     /** Narrow schema_version when allStates is a runtime boolean. */

package/lib/client.js

@@ -29,7 +29,7 @@ const REPORTING = new Set([
 ]);
 
 class RiftriError extends Error {
-  constructor(exitCode, receipt, stderr, signal = null) {
+  constructor(exitCode, receipt, stderr, signal = null, report = null) {
     super(
       // JSON is not a guarantee of a valid receipt. Coercing an object here
       // can throw inside the child close handler instead of rejecting run().
@@ -43,6 +43,7 @@ class RiftriError extends Error {
     this.exitCode = exitCode;
     this.signal = signal;
     this.receipt = receipt ?? null;
+    this.report = report;
   }
 
   /** The process was killed rather than exiting on its own. */
@@ -52,7 +53,12 @@ class RiftriError extends Error {
 
   /** Riftri declined before touching anything. Falling back is safe. */
   get isPolicyRefusal() {
-    return this.exitCode === EXIT_POLICY;
+    // Hooks and `exec` children can return 3 after performing work. Only a
+    // native refusal receipt proves the operation stopped before mutation.
+    return this.exitCode === EXIT_POLICY && this.signal === null && this.report === null &&
+      this.receipt?.schemaVersion === 1 && this.receipt?.outcome === "failed" &&
+      this.receipt?.category === "policy" && this.receipt?.cleanup === "not-needed" &&
+      typeof this.receipt?.code === "string";
   }
 
   /** The request itself was malformed. Never retry unchanged. */
@@ -120,6 +126,8 @@ class Riftri {
     this.worktree = {
       add: this.#worktreeAdd.bind(this),
       list: this.#worktreeList.bind(this),
+      owner: this.#worktreeOwner.bind(this),
+      inspect: this.#worktreeInspect.bind(this),
       remove: this.#worktreeRemove.bind(this),
       move: this.#worktreeMove.bind(this),
       compact: this.#worktreeCompact.bind(this),
@@ -200,8 +208,11 @@ class Riftri {
         // child wrote there first (a hook's output, a Git warning) must not
         // cost the caller the receipt's code and category.
         let receipt = null;
-        const lines = stderr.trimEnd().split("\n");
-        for (const candidate of [lines.at(-1), stderr]) {
+        // Preserve the full diagnostic fallback without allocating an array
+        // and a string entry for every line of a verbose child's output.
+        const trimmed = stderr.trimEnd();
+        const lastLine = trimmed.slice(trimmed.lastIndexOf("\n") + 1);
+        for (const candidate of [lastLine, stderr]) {
           try {
             receipt = JSON.parse(candidate);
             break;
@@ -209,7 +220,18 @@ class Riftri {
             // Plain text, as from a binary that predates usage receipts.
           }
         }
-        reject(new RiftriError(exitCode, receipt, stderr));
+        let report = null;
+        if (json && stdout.trim()) {
+          // A failed post-checkout hook leaves a created worktree in place.
+          // Preserve that report even though the hook's status rejects run().
+          try {
+            report = JSON.parse(stdout);
+          } catch {
+            // Malformed output cannot prove that a fallback is safe either.
+          }
+          receipt = null;
+        }
+        reject(new RiftriError(exitCode, receipt, stderr, null, report));
       });
     });
   }
@@ -297,6 +319,15 @@ class Riftri {
     return this.run(["worktree", "list", ...flagsFor(options), ...state]);
   }
 
+  #worktreeOwner(destination) {
+    // Ownership always consults every registered state, not this.stateDir.
+    return this.run(["worktree", "owner", "--", destination]);
+  }
+
+  #worktreeInspect(destinations) {
+    return this.run(["worktree", "inspect", "--", ...destinations]);
+  }
+
   #worktreeRemove(destination, { force = false } = {}) {
     const args = ["worktree", "remove"];
     if (force) args.push("--force", "--yes");
@@ -319,6 +350,7 @@ class Riftri {
 module.exports = {
   Riftri,
   RiftriError,
+  resolveBinary,
   EXIT_SUCCESS,
   EXIT_OPERATIONAL,
   EXIT_USAGE,

package/lib/platform.js

@@ -3,6 +3,9 @@
 const fs = require("node:fs");
 const path = require("node:path");
 
+// Kept in step with the ELF release gate and standalone installer by tests.
+const GLIBC_FLOOR = "2.34";
+
 const PLATFORM_PACKAGES = Object.freeze({
   "darwin-arm64": "riftri-darwin-arm64",
   "darwin-x64": "riftri-darwin-x64",
@@ -20,7 +23,22 @@ function detectLinuxLibc(report = process.report) {
   }
 
   const header = report.getReport()?.header;
-  return header?.glibcVersionRuntime ? "gnu" : "musl";
+  const version = header?.glibcVersionRuntime;
+  if (!version) return "musl";
+  const parts = typeof version === "string" && /^(\d+)\.(\d+)(?:\.\d+)?$/.exec(version);
+  const [major, minor] = parts ? parts.slice(1, 3).map(Number) : [];
+  const [floorMajor, floorMinor] = GLIBC_FLOOR.split(".").map(Number);
+  if (!Number.isSafeInteger(major) || !Number.isSafeInteger(minor) ||
+      major < floorMajor || (major === floorMajor && minor < floorMinor)) {
+    // npm excludes musl optional dependencies on glibc hosts. Do not select
+    // an absent package or attempt to execute an incompatible GNU binary.
+    throw new Error(
+      `Riftri's GNU npm binary requires glibc ${GLIBC_FLOOR} or newer (detected ${version}); ` +
+      "use the standalone installer at https://riftri.dev/install.sh for the static musl binary, " +
+      "then set RIFTRI_BINARY to its absolute path when using the Node SDK",
+    );
+  }
+  return "gnu";
 }
 
 function platformKey(
@@ -44,6 +62,9 @@ function binaryName(platform = process.platform) {
 
 function assertUsableBinary(candidate, source) {
   try {
+    // Follow executable symlinks, but reject directories and special files
+    // that can pass an access check without being runnable binaries.
+    if (!fs.statSync(candidate).isFile()) throw new Error("not a regular file");
     fs.accessSync(
       candidate,
       process.platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK,
@@ -54,6 +75,17 @@ function assertUsableBinary(candidate, source) {
   return candidate;
 }
 
+function unpackedElectronBinary(candidate) {
+  if (!process.versions.electron) return candidate;
+  const segments = candidate.split(path.sep);
+  const archive = segments.findLastIndex((segment) => segment.endsWith(".asar"));
+  if (archive < 0) return candidate;
+  // Electron can read an archived executable, but the OS cannot spawn it.
+  // Validate the physical file below instead of relying on Electron's virtual fs.
+  segments[archive] += ".unpacked";
+  return segments.join(path.sep);
+}
+
 function launcherVersion() {
   for (const candidate of [
     path.join(__dirname, "..", "package.json"),
@@ -120,10 +152,11 @@ function resolveBinary(options = {}) {
   );
 
   const candidate = path.join(path.dirname(packageJson), "bin", binaryName(platform));
-  return assertUsableBinary(candidate, packageName);
+  return assertUsableBinary(unpackedElectronBinary(candidate), packageName);
 }
 
 module.exports = {
+  GLIBC_FLOOR,
   PLATFORM_PACKAGES,
   assertCompatiblePackageManifest,
   binaryName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "riftri",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Experimental lightweight Git workspaces for parallel development",
   "license": "MIT",
   "author": "Assistant UI contributors",
@@ -22,14 +22,14 @@
     "typescript": "5.9.3"
   },
   "optionalDependencies": {
-    "riftri-darwin-arm64": "0.6.1",
-    "riftri-darwin-x64": "0.6.1",
-    "riftri-linux-arm64-gnu": "0.6.1",
-    "riftri-linux-arm64-musl": "0.6.1",
-    "riftri-linux-x64-gnu": "0.6.1",
-    "riftri-linux-x64-musl": "0.6.1",
-    "riftri-win32-arm64": "0.6.1",
-    "riftri-win32-x64": "0.6.1"
+    "riftri-darwin-arm64": "0.6.3",
+    "riftri-darwin-x64": "0.6.3",
+    "riftri-linux-arm64-gnu": "0.6.3",
+    "riftri-linux-arm64-musl": "0.6.3",
+    "riftri-linux-x64-gnu": "0.6.3",
+    "riftri-linux-x64-musl": "0.6.3",
+    "riftri-win32-arm64": "0.6.3",
+    "riftri-win32-x64": "0.6.3"
   },
   "repository": {
     "type": "git",