@indigoai-us/hq-cli 5.345.154 → 5.345.156

package/dist/utils/client-health.js

@@ -33,6 +33,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
 import { getStateDir, listJournals } from "@indigoai-us/hq-cloud";
 import { isExpiring, isMachineIdentity, loadCachedTokens, } from "./cognito-session.js";
 import { vaultApiFetch } from "./vault-api.js";
@@ -73,6 +76,17 @@ export const CLIENT_HEALTH_OBSERVATION_FILE = "cli-client-health.observation.jso
  * always re-observe — they have opened the store anyway, so it costs nothing.
  */
 export const JOURNAL_OBSERVATION_TTL_MS = 15 * 60_000;
+/**
+ * V8 old-space cap, in MB, for the child process that enumerates journals on
+ * behalf of a plain invocation. `listJournals()` materializes every area of
+ * the local sync state store; on a large store that took a short-lived
+ * command such as `hq secrets exec` to 2.5-4 GB RSS (feedback_d70e9d63). The
+ * child either finishes inside this cap or dies, and the command never holds
+ * that memory itself.
+ */
+export const JOURNAL_OBSERVER_HEAP_MB = 512;
+/** Wall-clock bound for the isolated journal observer. */
+export const JOURNAL_OBSERVER_TIMEOUT_MS = 20_000;
 /** An observation lock older than this is treated as abandoned. */
 const JOURNAL_OBSERVATION_LOCK_STALE_MS = 5 * 60_000;
 /**
@@ -234,6 +248,66 @@ export function latestJournalSyncTime(journals) {
     }
     return latest === null ? null : new Date(latest).toISOString();
 }
+/**
+ * The isolated observer could not produce a value (heap cap, timeout, crash or
+ * unreadable output). The caller stamps the observation so the next attempt
+ * waits a full TTL instead of re-running a read already known to fail here.
+ */
+export class JournalObservationUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "JournalObservationUnavailableError";
+    }
+}
+const JOURNAL_OBSERVER_SOURCE = [
+    "const engine = await import(process.argv[1]);",
+    "const out = [];",
+    "for (const entry of engine.listJournals()) {",
+    "  const value = entry && entry.journal ? entry.journal.lastSync : undefined;",
+    "  if (typeof value === 'string') out.push(value);",
+    "}",
+    "process.stdout.write(JSON.stringify(out));",
+].join("\n");
+function defaultJournalEngineUrl() {
+    return pathToFileURL(createRequire(import.meta.url).resolve("@indigoai-us/hq-cloud")).href;
+}
+/**
+ * Run `listJournals()` in a heap-capped child process and return only the
+ * `lastSync` values. Used for plain invocations so the full store
+ * materialization never lands in the invoking command's own memory.
+ */
+export function observeJournalsIsolated(opts = {}) {
+    const engineUrl = opts.engineUrl ?? defaultJournalEngineUrl();
+    const result = spawnSync(process.execPath, [
+        `--max-old-space-size=${opts.heapMb ?? JOURNAL_OBSERVER_HEAP_MB}`,
+        "--input-type=module",
+        "-e",
+        JOURNAL_OBSERVER_SOURCE,
+        engineUrl,
+    ], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: opts.timeoutMs ?? JOURNAL_OBSERVER_TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+        windowsHide: true,
+    });
+    if (result.error || result.status !== 0 || result.signal) {
+        throw new JournalObservationUnavailableError(`journal observer failed (status ${String(result.status)}, signal ${String(result.signal)})`);
+    }
+    let values;
+    try {
+        values = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new JournalObservationUnavailableError("journal observer output was not JSON");
+    }
+    if (!Array.isArray(values)) {
+        throw new JournalObservationUnavailableError("journal observer output was not a list");
+    }
+    return values
+        .filter((value) => typeof value === "string")
+        .map((lastSync) => ({ journal: { lastSync } }));
+}
 /**
  * True when this event kind must pay for a fresh `listJournals()` read.
  *
@@ -527,7 +601,14 @@ async function contributeClientHealthUnbounded(kind, deps, failureReason) {
             }
             else {
                 try {
-                    const observed = latestJournalSyncTime((deps.journals ?? listJournals)());
+                    // A plain invocation (any command, `hq secrets exec` included) reads
+                    // the store in a heap-capped child. Sync commands have the store open
+                    // already and read in-process.
+                    const source = deps.journals ??
+                        (kind === "invocation"
+                            ? (deps.isolatedJournals ?? observeJournalsIsolated)
+                            : listJournals);
+                    const observed = latestJournalSyncTime(source());
                     if (observed !== null) {
                         journalLastSyncAt = observed;
                         observation.lastSyncAt = observed;
@@ -543,8 +624,20 @@ async function contributeClientHealthUnbounded(kind, deps, failureReason) {
                     observation.observedAt = now.toISOString();
                     persistJournalObservation(stateDir, observation);
                 }
-                catch {
-                    // Journal enumeration is best effort.
+                catch (error) {
+                    // Journal enumeration is best effort. When the isolated observer hit
+                    // its heap or time cap, keep the previous value but stamp the attempt
+                    // so the next invocation waits a full TTL instead of retrying a read
+                    // already known to fail on this machine.
+                    if (error instanceof JournalObservationUnavailableError) {
+                        observation.observedAt = now.toISOString();
+                        try {
+                            persistJournalObservation(stateDir, observation);
+                        }
+                        catch {
+                            // Best effort.
+                        }
+                    }
                 }
                 finally {
                     release();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.154",
+  "version": "5.345.156",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -114,11 +114,11 @@
     "*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}": "eslint --cache --no-error-on-unmatched-pattern"
   },
   "optionalDependencies": {
-    "@indigoai-us/hq-hook-win32-x64": "5.345.154",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.154",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.154",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.154",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.154",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.154"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.156",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.156",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.156",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.156",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.156",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.156"
   }
 }