riftri 0.6.0 → 0.6.2

package/lib/client.d.ts

@@ -102,18 +102,74 @@ export interface ManagedWorktree {
 }
 
 export interface WorktreeInventory {
-  schema_version: number;
+  schema_version: 1;
   state_directory: string;
+  state_directory_native_hex: string;
   worktrees: ManagedWorktree[];
+  diagnostic_issues: StateDiagnosticIssue[];
   native_path_encoding: string;
 }
 
+export interface StateDiagnosticIssue {
+  path: string;
+  path_native_hex: string;
+  reason: string;
+  may_hide_base_reference: boolean;
+}
+
+export interface AllStatesManagedWorktree extends ManagedWorktree {
+  state_directory: string;
+  state_directory_native_hex: string;
+}
+
+export interface AllStatesDiagnosticIssue extends StateDiagnosticIssue {
+  /** Null for a registration issue that belongs to no usable state directory. */
+  state_directory: string | null;
+  state_directory_native_hex: string | null;
+}
+
+export interface AllStatesWorktreeInventory {
+  schema_version: 2;
+  scope: "all-registered-states";
+  state_directories: {
+    path: string;
+    path_native_hex: string;
+    source: "default" | "registered";
+  }[];
+  worktrees: AllStatesManagedWorktree[];
+  diagnostic_issues: AllStatesDiagnosticIssue[];
+  native_path_encoding: string;
+}
+
+/** Lifecycle counters; lower bounds when StatusReport.counts_complete is false. */
+export interface StatusOperations {
+  active_views: number;
+  pending_adds: number;
+  completed_removals: number;
+  cancelled_removals: number;
+  pending_removals: number;
+  completed_moves: number;
+  cancelled_moves: number;
+  pending_moves: number;
+  completed_compactions: number;
+  cancelled_compactions: number;
+  pending_compactions: number;
+  completed_prunes: number;
+  pending_prunes: number;
+  completed_collections: number;
+  cancelled_collections: number;
+  pending_collections: number;
+  coordination_locks: number;
+}
+
 export interface StatusReport {
   schema_version: number;
   state_directory: string;
   bases: unknown[];
   worktrees: unknown[];
-  operations: unknown[];
+  /** False when unreadable journals make operation counts lower bounds. */
+  counts_complete: boolean;
+  operations: StatusOperations;
   diagnostic_issues: unknown[];
   total_allocated_bytes: number;
   total_logical_bytes: number;
@@ -183,7 +239,10 @@ export class Riftri {
 
   readonly worktree: {
     add(destination: string, options?: AddOptions): Promise<AddReport>;
-    list(options?: { allStates?: boolean }): Promise<WorktreeInventory>;
+    list(options: { allStates: true }): Promise<AllStatesWorktreeInventory>;
+    list(options?: { allStates?: false }): Promise<WorktreeInventory>;
+    /** Narrow schema_version when allStates is a runtime boolean. */
+    list(options?: { allStates?: boolean }): Promise<WorktreeInventory | AllStatesWorktreeInventory>;
     /** Refuses a dirty worktree unless `force` is set. */
     remove(destination: string, options?: { force?: boolean }): Promise<unknown>;
     move(source: string, destination: string): Promise<unknown>;

package/lib/client.js

@@ -31,7 +31,9 @@ const REPORTING = new Set([
 class RiftriError extends Error {
   constructor(exitCode, receipt, stderr, signal = null) {
     super(
-      receipt?.message ||
+      // JSON is not a guarantee of a valid receipt. Coercing an object here
+      // can throw inside the child close handler instead of rejecting run().
+      (typeof receipt?.message === "string" ? receipt.message : "") ||
         stderr.trim() ||
         (signal ? `riftri terminated by ${signal}` : `riftri exited ${exitCode}`),
     );
@@ -151,7 +153,18 @@ class Riftri {
       }
       let stdout = "";
       let stderr = "";
-      child.stdout.on("data", (chunk) => (stdout += chunk));
+      // Pipe chunks need not end on a UTF-8 character boundary. Let each
+      // stream retain incomplete bytes between chunks (and flush at EOF).
+      if (json) {
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => (stdout += chunk));
+      } else {
+        // The API returns null for non-reporting commands. Drain their output
+        // without decoding or retaining it, so verbose children cannot grow
+        // the host heap in proportion to output that will be discarded.
+        child.stdout.resume();
+      }
+      child.stderr.setEncoding("utf8");
       child.stderr.on("data", (chunk) => (stderr += chunk));
       child.on("error", reject);
       child.on("close", (exitCode, signal) => {
@@ -163,7 +176,7 @@ class Riftri {
           return;
         }
         if (exitCode === EXIT_SUCCESS) {
-          if (!json || !stdout.trim()) {
+          if (!json) {
             resolve(null);
             return;
           }
@@ -187,8 +200,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;

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,
@@ -124,6 +145,7 @@ function resolveBinary(options = {}) {
 }
 
 module.exports = {
+  GLIBC_FLOOR,
   PLATFORM_PACKAGES,
   assertCompatiblePackageManifest,
   binaryName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "riftri",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Experimental lightweight Git workspaces for parallel development",
   "license": "MIT",
   "author": "Assistant UI contributors",
@@ -17,15 +17,19 @@
   "engines": {
     "node": ">=18.18"
   },
+  "devDependencies": {
+    "@types/node": "18.19.130",
+    "typescript": "5.9.3"
+  },
   "optionalDependencies": {
-    "riftri-darwin-arm64": "0.6.0",
-    "riftri-darwin-x64": "0.6.0",
-    "riftri-linux-arm64-gnu": "0.6.0",
-    "riftri-linux-arm64-musl": "0.6.0",
-    "riftri-linux-x64-gnu": "0.6.0",
-    "riftri-linux-x64-musl": "0.6.0",
-    "riftri-win32-arm64": "0.6.0",
-    "riftri-win32-x64": "0.6.0"
+    "riftri-darwin-arm64": "0.6.2",
+    "riftri-darwin-x64": "0.6.2",
+    "riftri-linux-arm64-gnu": "0.6.2",
+    "riftri-linux-arm64-musl": "0.6.2",
+    "riftri-linux-x64-gnu": "0.6.2",
+    "riftri-linux-x64-musl": "0.6.2",
+    "riftri-win32-arm64": "0.6.2",
+    "riftri-win32-x64": "0.6.2"
   },
   "repository": {
     "type": "git",