@nanhara/hara 0.122.1 → 0.122.3

package/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.122.3 — 2026-07-14 — standalone runtime recovery
+
+- **Bun-compiled standalone binaries no longer assume `SharedArrayBuffer` exists at module startup.**
+  The short synchronous waits used by cross-process stores now prefer `Bun.sleepSync`, lazily use
+  `Atomics.wait` only on Node when its primitives exist, and retain a bounded last-resort delay. This
+  fixes the macOS arm64 `ReferenceError` that could make the 0.122.2 standalone binary exit before
+  even printing `--version`; npm/Node and GHCR users were unaffected. CI now compiles and executes a
+  native standalone binary on Linux and macOS, and the release job executes its native Linux asset
+  before publishing, so a merely successful cross-compile is no longer accepted as runtime proof.
+
+## 0.122.2 — 2026-07-14 — reproducible container release
+
+- **The Docker build now includes the guarded runtime entry before normalizing package modes.** This fixes the
+  `runtime-bootstrap.cjs` `ENOENT` that affected only the `v0.122.1` GHCR image job; its npm package and
+  standalone binaries were already published and remain valid. CI now builds and starts the complete runtime
+  image before a tag can be released, while old Node installations continue to receive the explicit 22.12+
+  upgrade instruction.
+
 ## 0.122.1 — 2026-07-14 — protected files and explicit extension trust
 
 - **The npm CLI now requires Node.js 22.12+.** Node 20 is end-of-life, so Hara no longer makes a security or

package/dist/gateway/flows-pending.js

@@ -23,9 +23,9 @@ import { getValidQwenAuth } from "../providers/qwen-oauth.js";
 import { resolvePlatform } from "../providers/registry.js";
 import { validateAgainstSchema } from "../agent/structured.js";
 import { terminateSubprocessTree } from "../security/subprocess-env.js";
+import { sleepSync } from "../sync-sleep.js";
 const FILE = () => join(homedir(), ".hara", "flows-pending.json");
 const LOCK = () => FILE() + ".lock";
-const sleepCell = new Int32Array(new SharedArrayBuffer(4));
 const STORE_LOCK_ATTEMPTS = 500;
 const STORE_LOCK_WAIT_MS = 10;
 const PENDING_STATUSES = new Set(["pending", "executing", "done", "rejected", "failed", "expired"]);
@@ -151,7 +151,7 @@ function withStoreLock(fn) {
                     continue;
                 }
             }
-            Atomics.wait(sleepCell, 0, 0, STORE_LOCK_WAIT_MS);
+            sleepSync(STORE_LOCK_WAIT_MS);
             continue;
         }
         const candidate = { pid: process.pid, token: randomUUID() };
@@ -190,7 +190,7 @@ function withStoreLock(fn) {
                 }
             }
         }
-        Atomics.wait(sleepCell, 0, 0, STORE_LOCK_WAIT_MS);
+        sleepSync(STORE_LOCK_WAIT_MS);
     }
     if (!claim)
         throw new Error("flows pending store is busy");

package/dist/gateway/sessions.js

@@ -8,6 +8,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { sleepSync } from "../sync-sleep.js";
 /** Idle window before a chat auto-rotates to a FRESH session (hours). A WeChat/Feishu chat is one
  *  endless surface — without this, days-old context piles onto every new ask and the agent answers
  *  from stale state (the "gateway answers with old context" report). Default 8h: overnight gaps start
@@ -23,7 +24,6 @@ const dir = () => join(haraDir(), "gateway");
 const file = () => join(dir(), "chats.json");
 const lockFile = () => `${file()}.lock`;
 const reclaimFile = () => `${lockFile()}.reclaim`;
-const waitCell = new Int32Array(new SharedArrayBuffer(4));
 const LOCK_WAIT_MS = 5_000;
 function errorCode(error) {
     return typeof error === "object" && error !== null && "code" in error
@@ -114,7 +114,7 @@ function acquireLock() {
             }
             if (Date.now() >= deadline)
                 throw new Error(`Timed out waiting for gateway session store lock: ${lockFile()}`);
-            Atomics.wait(waitCell, 0, 0, 10);
+            sleepSync(10);
             continue;
         }
         try {
@@ -157,7 +157,7 @@ function acquireLock() {
             if (Date.now() >= deadline) {
                 throw new Error(`Timed out waiting for gateway session store lock: ${lockFile()}`);
             }
-            Atomics.wait(waitCell, 0, 0, 10);
+            sleepSync(10);
         }
     }
 }

package/dist/org/projects.js

@@ -5,8 +5,8 @@ import { isAbsolute, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { loadRoles, loadGlobalRoles } from "./roles.js";
+import { sleepSync } from "../sync-sleep.js";
 const PROJECT_NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/;
-const sleepCell = new Int32Array(new SharedArrayBuffer(4));
 const LOCK_ATTEMPTS = 500;
 const LOCK_WAIT_MS = 10;
 function haraDir() {
@@ -101,7 +101,7 @@ function withProjectsLock(fn) {
                     continue;
                 }
             }
-            Atomics.wait(sleepCell, 0, 0, LOCK_WAIT_MS);
+            sleepSync(LOCK_WAIT_MS);
             continue;
         }
         const candidate = { pid: process.pid, token: randomUUID() };
@@ -132,7 +132,7 @@ function withProjectsLock(fn) {
                     rmSync(reclaim, { force: true });
             }
         }
-        Atomics.wait(sleepCell, 0, 0, LOCK_WAIT_MS);
+        sleepSync(LOCK_WAIT_MS);
     }
     if (!claim)
         throw new Error("projects registry is busy; retry the operation");

package/dist/sync-sleep.js

@@ -0,0 +1,46 @@
+// Cross-runtime synchronous short wait for the tiny retry delays used by file locks.
+//
+// Bun standalone binaries do not guarantee that SharedArrayBuffer exists, so never construct one at
+// module evaluation time. Prefer Bun's native primitive, use Atomics only in Node, and retain a bounded
+// last resort so a missing/disabled runtime primitive cannot make lock acquisition crash or spin forever.
+const MAX_SHORT_WAIT_MS = 100;
+const MAX_FALLBACK_SPINS = 5_000_000;
+let nodeWaitCell;
+function boundedDelay(milliseconds) {
+    if (!Number.isFinite(milliseconds) || milliseconds <= 0)
+        return 0;
+    return Math.min(MAX_SHORT_WAIT_MS, Math.ceil(milliseconds));
+}
+/** Block for a small, bounded retry delay without assuming SharedArrayBuffer is available. */
+export function sleepSync(milliseconds) {
+    const delay = boundedDelay(milliseconds);
+    if (delay === 0)
+        return;
+    const runtime = globalThis;
+    if (typeof runtime.Bun?.sleepSync === "function") {
+        try {
+            runtime.Bun.sleepSync(delay);
+            return;
+        }
+        catch {
+            // A partially implemented Bun runtime still gets the bounded fallback below.
+        }
+    }
+    // Atomics.wait is a dependable synchronous sleep on Node's main thread. Do not use this branch in
+    // Bun: a compiled Bun executable may expose part of the Node compatibility surface without SAB.
+    if (!runtime.Bun && typeof runtime.SharedArrayBuffer === "function" && typeof runtime.Atomics?.wait === "function") {
+        try {
+            nodeWaitCell ??= new Int32Array(new runtime.SharedArrayBuffer(4));
+            runtime.Atomics.wait(nodeWaitCell, 0, 0, delay);
+            return;
+        }
+        catch {
+            nodeWaitCell = undefined;
+            // Some embedders disable blocking Atomics even when the globals exist. Fall through safely.
+        }
+    }
+    const deadline = Date.now() + delay;
+    for (let spins = 0; spins < MAX_FALLBACK_SPINS && Date.now() < deadline; spins++) {
+        // Intentionally empty: both time and iteration ceilings bound this compatibility fallback.
+    }
+}

package/dist/tools/task.js

@@ -6,9 +6,9 @@ import { basename, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 import { registerTool } from "./registry.js";
+import { sleepSync } from "../sync-sleep.js";
 const TASK_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const TASK_STATUSES = new Set(["pending", "in_progress", "done"]);
-const sleepCell = new Int32Array(new SharedArrayBuffer(4));
 const LOCK_ATTEMPTS = 500;
 const LOCK_WAIT_MS = 10;
 /** Resolve aliases/symlinks before deriving the key. A missing path still gets a stable absolute key so
@@ -113,7 +113,7 @@ function withTaskLock(cwd, fn) {
                     continue;
                 }
             }
-            Atomics.wait(sleepCell, 0, 0, LOCK_WAIT_MS);
+            sleepSync(LOCK_WAIT_MS);
             continue;
         }
         const candidate = { pid: process.pid, token: randomUUID() };
@@ -144,7 +144,7 @@ function withTaskLock(cwd, fn) {
                     rmSync(reclaim, { force: true });
             }
         }
-        Atomics.wait(sleepCell, 0, 0, LOCK_WAIT_MS);
+        sleepSync(LOCK_WAIT_MS);
     }
     if (!claim)
         throw new Error("task store is busy; retry the operation");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.122.1",
+  "version": "0.122.3",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "runtime-bootstrap.cjs"