@indigoai-us/hq-cli 5.345.156 → 5.345.160

package/dist/lib/daemon/unit-holds.js

@@ -0,0 +1,86 @@
+/**
+ * Host-side storage for the supervisor's unit holds and the per-run output
+ * read used to classify a unit's exit.
+ *
+ * holds.json (`DaemonPaths.holdsPath`, ~/.hq/daemon/holds.json) maps a unit id
+ * to its UnitHold. The daemon rewrites it whenever a hold starts or clears; a
+ * missing or unreadable file means no holds.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ensurePrivateDir } from "./paths.js";
+/** How much of a run's output the exit classifier sees. */
+export const EXIT_OUTPUT_TAIL_BYTES = 16 * 1024;
+function isHold(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const h = value;
+    return ((h.kind === "permanent" || h.kind === "exhausted")
+        && typeof h.cause === "string"
+        && typeof h.detail === "string"
+        && typeof h.since === "number"
+        && typeof h.failures === "number"
+        && typeof h.keyHash === "string");
+}
+export function readUnitHolds(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return {};
+        throw err;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+    const holds = {};
+    for (const [id, hold] of Object.entries(parsed))
+        if (isHold(hold))
+            holds[id] = hold;
+    return holds;
+}
+export function writeUnitHolds(file, holds) {
+    ensurePrivateDir(path.dirname(file));
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(holds, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+/** The size of a log file now, so a later read sees only what was written after. */
+export function logOffset(file) {
+    try {
+        return fs.statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * What was appended to `file` since `offset`, at most the last `maxBytes`.
+ * A file smaller than `offset` was rotated (copy-and-truncate), so it is read
+ * from the start.
+ */
+export function readLogSince(file, offset, maxBytes = EXIT_OUTPUT_TAIL_BYTES) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch {
+        return "";
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const from = Math.max(size < offset ? 0 : offset, size - maxBytes);
+        const length = size - from;
+        if (length <= 0)
+            return "";
+        const buf = Buffer.alloc(length);
+        const read = fs.readSync(fd, buf, 0, length, from);
+        return buf.subarray(0, read).toString("utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+//# sourceMappingURL=unit-holds.js.map

package/dist/lib/db/control-plane.d.ts

@@ -1,3 +1,4 @@
+import { type UsagePause } from "../billing/usage-pause.js";
 /**
  * Control-plane client for remote vault DB (US-009).
  * Injectable fetch for tests — never logs response bodies that might hold secrets.
@@ -167,5 +168,9 @@ export type ControlPlaneHttpError = Error & {
     status?: number;
     code?: string;
     reason?: string;
+    /** The 402 usage pause (hq-pro `usagePause`), when the server sent one. */
+    usagePause?: UsagePause;
+    /** The body's customer sentence (`message`), when it sent one. */
+    serverMessage?: string;
 };
 //# sourceMappingURL=control-plane.d.ts.map

package/dist/lib/db/control-plane.js

@@ -1,4 +1,5 @@
 import { planGateErrorFromPayload } from "../../utils/plan-gate-error.js";
+import { usagePauseFromBody } from "../billing/usage-pause.js";
 // Provision may allocate remote resources, so allow two minutes and never retry.
 const DB_PROVISION_TIMEOUT_MS = 120_000;
 // Status is a read-only probe; 15 seconds is longer than its normal response time.
@@ -195,6 +196,8 @@ function httpError(label, status, text) {
     let msg = `${label} failed (${status})`;
     let code;
     let reason;
+    let usagePause = null;
+    let serverMessage;
     try {
         const j = JSON.parse(text);
         if (typeof j.error === "string")
@@ -203,6 +206,9 @@ function httpError(label, status, text) {
             code = j.code;
         if (typeof j.reason === "string")
             reason = j.reason;
+        if (typeof j.message === "string" && j.message.trim())
+            serverMessage = j.message.trim();
+        usagePause = usagePauseFromBody(j);
     }
     catch {
         /* keep */
@@ -213,6 +219,10 @@ function httpError(label, status, text) {
         err.code = code;
     if (reason)
         err.reason = reason;
+    if (usagePause)
+        err.usagePause = usagePause;
+    if (serverMessage)
+        err.serverMessage = serverMessage;
     return err;
 }
 function personalHttpError(label, status, text) {