bare-agent 0.26.0 → 0.26.2

package/bareagent.context.md

@@ -1,7 +1,7 @@
 # bareagent — Integration Guide
 
 > For AI assistants and developers wiring bareagent into a project.
-> v0.26.0 | Node.js >= 18 | zero required deps (`bareguard ^0.9.0` optional peer for governance) | Apache 2.0
+> v0.26.2 | Node.js >= 18 | zero required deps (`bareguard >=0.9.0 <0.13.0` optional peer for governance) | Apache 2.0
 >
 > Full human guide with composition examples, design philosophy, and recipes: [Usage Guide](docs/02-features/usage-guide.md)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-agent",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "files": [
     "index.js",
     "index.d.ts",
@@ -80,7 +80,7 @@
     "cron-parser": "^4.9.0"
   },
   "peerDependencies": {
-    "bareguard": "^0.9.0",
+    "bareguard": ">=0.9.0 <0.13.0",
     "better-sqlite3": ">=9.0.0"
   },
   "peerDependenciesMeta": {
@@ -101,7 +101,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.19.19",
-    "bareguard": "^0.9.0",
+    "bareguard": ">=0.9.0 <0.13.0",
     "litectx": "^0.26.0",
     "typescript": "^5.7.0"
   }

package/src/bareguard-adapter.d.ts

@@ -27,9 +27,9 @@ export type GateDecision = {
      */
     rule?: string | undefined;
     /**
-     * - Human-readable reason.
+     * - Human-readable reason (bareguard's Decision emits null when absent).
      */
-    reason?: string | undefined;
+    reason?: string | null | undefined;
     /**
      * - Arbitrary structured context.
      */

package/src/bareguard-adapter.js

@@ -21,7 +21,7 @@ const { HaltError } = require('./errors');
  * @property {string} [outcome] - 'allow' when permitted.
  * @property {string} [severity] - 'halt' for halt-severity denials.
  * @property {string} [rule] - The matched rule name.
- * @property {string} [reason] - Human-readable reason.
+ * @property {string | null} [reason] - Human-readable reason (bareguard's Decision emits null when absent).
  * @property {Record<string, any>} [context] - Arbitrary structured context.
  */
 

package/src/provider-clipipe.js

@@ -165,39 +165,65 @@ class CLIPipeProvider {
 
       let stdout = '';
       let stderr = '';
-      let killed = false;
 
-      child.stdout.on('data', d => { stdout += d; this.onChunk?.(d.toString()); });
-      child.stderr.on('data', d => { stderr += d; });
-
-      child.on('error', err => {
-        reject(new ProviderError(`[CLIPipeProvider] failed to spawn "${this.command}": ${err.message}`, /** @type {any} */ ({ status: 0 })));
-      });
+      // Settle exactly once, no matter which combination of events fires. 'close' can be
+      // withheld indefinitely when the CLI spawns a grandchild that inherits its stdio pipes
+      // (the child exits, but the pipes stay open) — observed live as a generate() promise
+      // that never settled. Every path below funnels through settle().
+      let settled = false;
+      /** @type {NodeJS.Timeout[]} */
+      const timers = [];
+      const later = (fn, ms) => { timers.push(setTimeout(fn, ms)); };
+      const settle = (/** @type {Error|null} */ err, text = '') => {
+        if (settled) return;
+        settled = true;
+        for (const t of timers) clearTimeout(t);
+        if (err) reject(err); else resolve(text);
+      };
 
-      child.on('close', code => {
-        if (killed) return; // timeout already rejected
+      const finish = (/** @type {number|null} */ code) => {
         if (code !== 0) {
-          return reject(new ProviderError(`[CLIPipeProvider] process exited with code ${code}: ${stderr.trim()}`, /** @type {any} */ ({ status: code })));
+          // The claude CLI reports errors on STDOUT (a JSON envelope) with stderr often
+          // empty — fall back to a stdout tail so the operator never sees a blank reason.
+          const detail = stderr.trim() || (stdout.trim() ? `(stderr empty) stdout: ${stdout.trim().slice(-400)}` : '');
+          return settle(new ProviderError(`[CLIPipeProvider] process exited with code ${code}: ${detail}`, /** @type {any} */ ({ status: code })));
         }
         const text = stdout.trim();
         if (!text) {
-          return reject(new ProviderError('[CLIPipeProvider] process produced no output', /** @type {any} */ ({ status: 0 })));
+          return settle(new ProviderError('[CLIPipeProvider] process produced no output', /** @type {any} */ ({ status: 0 })));
+        }
+        settle(null, text);
+      };
+
+      child.stdout.on('data', d => {
+        stdout += d;
+        try {
+          this.onChunk?.(d.toString());
+        } catch (err) {
+          // an observer callback must fail the call loudly, never crash the host process
+          settle(new ProviderError(`[CLIPipeProvider] onChunk callback threw: ${/** @type {Error} */ (err).message}`, /** @type {any} */ ({ status: 0 })));
         }
-        resolve(text);
+      });
+      child.stderr.on('data', d => { stderr += d; });
+
+      child.on('error', err => {
+        settle(new ProviderError(`[CLIPipeProvider] failed to spawn "${this.command}": ${err.message}`, /** @type {any} */ ({ status: 0 })));
       });
 
-      // Timeout handling
-      const timer = setTimeout(() => {
-        killed = true;
+      // Primary completion path: all stdio drained.
+      child.on('close', code => finish(code));
+
+      // Fallback: the process exited but 'close' is being held open by inherited pipes.
+      // Give real drainage a short grace, then finish with what has arrived — a bounded
+      // wait, never a hang.
+      child.on('exit', code => later(() => finish(code), 2000));
+
+      later(() => {
         child.kill('SIGTERM');
-        setTimeout(() => {
-          try { child.kill('SIGKILL'); } catch (_) {}
-        }, 1000);
-        reject(new ProviderError(`[CLIPipeProvider] timed out after ${this.timeout}ms`, /** @type {any} */ ({ status: 0 })));
+        setTimeout(() => { try { child.kill('SIGKILL'); } catch (_) {} }, 1000).unref?.();
+        settle(new ProviderError(`[CLIPipeProvider] timed out after ${this.timeout}ms`, /** @type {any} */ ({ status: 0 })));
       }, this.timeout);
 
-      child.on('close', () => clearTimeout(timer));
-
       // Write prompt to stdin — catch errors silently (process may exit early)
       child.stdin.on('error', () => {});
       child.stdin.end(prompt);