@indigoai-us/hq-cli 5.132.0 → 5.134.0

package/dist/lib/mesh/live/daemon/legacy-listen.js

@@ -0,0 +1,89 @@
+/**
+ * Retire the pack-era work-mesh listen unit so only `hq mesh daemon` subscribes.
+ *
+ * macOS: ~/Library/LaunchAgents/ai.getindigo.hq-work-mesh-listen.plist
+ * Linux: ~/.config/systemd/user/hq-work-mesh-listen.service
+ * Windows: Scheduled Task ai.getindigo.hq-work-mesh-listen
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+export const LEGACY_LISTEN_LABEL = "ai.getindigo.hq-work-mesh-listen";
+export const LEGACY_LISTEN_SYSTEMD_UNIT = "hq-work-mesh-listen.service";
+export const LEGACY_LISTEN_TASK = LEGACY_LISTEN_LABEL;
+export const LEGACY_LISTENER_DOCTOR_LINE = "legacy listener still installed";
+export function legacyListenPlistPath(home) {
+    return path.join(home, "Library", "LaunchAgents", `${LEGACY_LISTEN_LABEL}.plist`);
+}
+export function legacyListenSystemdPath(home) {
+    return path.join(home, ".config", "systemd", "user", LEGACY_LISTEN_SYSTEMD_UNIT);
+}
+const defaultRunner = (cmd, args) => {
+    const r = spawnSync(cmd, args, { encoding: "utf8" });
+    return {
+        status: r.status,
+        stdout: r.stdout ?? "",
+        stderr: r.error ? r.error.message : (r.stderr ?? ""),
+    };
+};
+export function legacyListenInstalled(opts) {
+    const exists = opts.existsSync ?? fs.existsSync;
+    if (opts.platform === "darwin")
+        return exists(legacyListenPlistPath(opts.home));
+    if (opts.platform === "linux")
+        return exists(legacyListenSystemdPath(opts.home));
+    if (opts.platform === "win32")
+        return false;
+    return false;
+}
+/**
+ * Unload and delete the legacy listen unit when it is present.
+ * On-disk unit files are removed on every host. launchctl, systemctl, and
+ * schtasks run only for the matching platform, and only through `run` when
+ * the caller injected one (tests never hit a real service manager).
+ * Missing unit is a no-op.
+ */
+export function retireLegacyListen(opts) {
+    const run = opts.run ?? (opts.platform === "other" ? undefined : defaultRunner);
+    let removed = false;
+    const plist = legacyListenPlistPath(opts.home);
+    if (fs.existsSync(plist)) {
+        if (opts.platform === "darwin" && run) {
+            const uid = opts.uid ?? (typeof process.getuid === "function" ? process.getuid() : undefined);
+            if (uid !== undefined) {
+                run("launchctl", ["bootout", `gui/${uid}/${LEGACY_LISTEN_LABEL}`]);
+            }
+            run("launchctl", ["unload", plist]);
+        }
+        try {
+            fs.unlinkSync(plist);
+            removed = true;
+        }
+        catch {
+            // leave removed false for this file
+        }
+    }
+    const unitPath = legacyListenSystemdPath(opts.home);
+    if (fs.existsSync(unitPath)) {
+        if (opts.platform === "linux" && run) {
+            run("systemctl", ["--user", "disable", "--now", LEGACY_LISTEN_SYSTEMD_UNIT]);
+        }
+        try {
+            fs.unlinkSync(unitPath);
+            removed = true;
+            if (opts.platform === "linux" && run) {
+                run("systemctl", ["--user", "daemon-reload"]);
+            }
+        }
+        catch {
+            // leave prior removed state
+        }
+    }
+    if (opts.platform === "win32" && opts.windowsTaskPresent && run) {
+        const result = run("schtasks.exe", ["/Delete", "/TN", LEGACY_LISTEN_TASK, "/F"]);
+        if (result.status === 0)
+            removed = true;
+    }
+    return { removed };
+}
+//# sourceMappingURL=legacy-listen.js.map

package/dist/lib/mesh/live/daemon/live-cache.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Daemon-owned work-mesh live cache.
+ *
+ * ~/.hq/work-mesh/live-cache.json plus live-cache.json.cursor-v2.json.
+ * A project-view push updates the project row and bumps the cursor once.
+ * The same company/project/boardVersion (or eventId) does not bump again.
+ */
+export declare function liveCacheFile(meshRoot: string): string;
+export declare function liveCacheCursorFile(meshRoot: string): string;
+export interface ProjectViewPush {
+    companyUid: string;
+    projectId: string;
+    boardVersion?: string;
+    eventId?: string;
+}
+/** Parse a board wake. Returns null for every other payload. */
+export declare function parseProjectViewPush(payload: unknown): ProjectViewPush | null;
+/**
+ * Apply one project-view push. Cursor increases by exactly one on first sight
+ * of the key, and is left unchanged when the same push is applied again.
+ */
+export declare function applyProjectViewPush(meshRoot: string, push: ProjectViewPush, nowIso?: string): {
+    applied: boolean;
+    cursor: number;
+};
+//# sourceMappingURL=live-cache.d.ts.map

package/dist/lib/mesh/live/daemon/live-cache.js

@@ -0,0 +1,116 @@
+/**
+ * Daemon-owned work-mesh live cache.
+ *
+ * ~/.hq/work-mesh/live-cache.json plus live-cache.json.cursor-v2.json.
+ * A project-view push updates the project row and bumps the cursor once.
+ * The same company/project/boardVersion (or eventId) does not bump again.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function liveCacheFile(meshRoot) {
+    return path.join(meshRoot, "live-cache.json");
+}
+export function liveCacheCursorFile(meshRoot) {
+    return path.join(meshRoot, "live-cache.json.cursor-v2.json");
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const tmp = `${file}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function pushKey(push) {
+    if (push.eventId && push.eventId.trim())
+        return `id:${push.eventId.trim()}`;
+    return `pv:${push.companyUid}:${push.projectId}:${push.boardVersion ?? ""}`;
+}
+/** Parse a board wake. Returns null for every other payload. */
+export function parseProjectViewPush(payload) {
+    let value = payload;
+    if (Buffer.isBuffer(value))
+        value = value.toString("utf8");
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const rec = value;
+    if (rec.kind !== "board" || rec.mutation !== "project-view")
+        return null;
+    if (typeof rec.companyUid !== "string" || typeof rec.projectId !== "string")
+        return null;
+    if (!rec.companyUid || !rec.projectId)
+        return null;
+    return {
+        companyUid: rec.companyUid,
+        projectId: rec.projectId,
+        boardVersion: typeof rec.boardVersion === "string" ? rec.boardVersion : undefined,
+        eventId: typeof rec.eventId === "string" ? rec.eventId : undefined,
+    };
+}
+/**
+ * Apply one project-view push. Cursor increases by exactly one on first sight
+ * of the key, and is left unchanged when the same push is applied again.
+ */
+export function applyProjectViewPush(meshRoot, push, nowIso = new Date().toISOString()) {
+    const key = pushKey(push);
+    const stored = readJson(liveCacheCursorFile(meshRoot));
+    const previous = stored &&
+        typeof stored === "object" &&
+        !Array.isArray(stored) &&
+        stored.version === 1 &&
+        typeof stored.cursor === "number"
+        ? {
+            version: 1,
+            cursor: stored.cursor,
+            seen: Array.isArray(stored.seen)
+                ? stored.seen.filter((s) => typeof s === "string").slice(-200)
+                : [],
+        }
+        : { version: 1, cursor: 0, seen: [] };
+    if (previous.seen.includes(key)) {
+        return { applied: false, cursor: previous.cursor };
+    }
+    const cursor = previous.cursor + 1;
+    const cacheRaw = readJson(liveCacheFile(meshRoot));
+    const cache = cacheRaw && typeof cacheRaw === "object" && !Array.isArray(cacheRaw)
+        ? cacheRaw
+        : {};
+    const projects = cache.projects && typeof cache.projects === "object" && !Array.isArray(cache.projects)
+        ? { ...cache.projects }
+        : {};
+    const rowKey = `${push.companyUid}/${push.projectId}`;
+    projects[rowKey] = {
+        companyUid: push.companyUid,
+        projectId: push.projectId,
+        mutation: "project-view",
+        boardVersion: push.boardVersion,
+        updatedAt: nowIso,
+    };
+    writeJson(liveCacheFile(meshRoot), {
+        ...cache,
+        updatedAt: nowIso,
+        cursor,
+        projects,
+    });
+    writeJson(liveCacheCursorFile(meshRoot), {
+        version: 1,
+        cursor,
+        seen: [...previous.seen, key].slice(-200),
+    });
+    return { applied: true, cursor };
+}
+//# sourceMappingURL=live-cache.js.map

package/dist/lib/mesh/live/daemon/presence.d.ts

@@ -34,7 +34,11 @@ export declare const CONNECT_STABLE_GRACE_MS = 5000;
  * waits at least this long regardless of the backoff/grace-reset state.
  */
 export declare const RECONNECT_MIN_DELAY_MS = 1000;
-/** Always emit the first N close info lines, then at most one per interval. */
+/**
+ * Close/reconnect info is one line per transition into reconnecting.
+ * Repeated `close` events while already reconnecting do not log again.
+ * Kept so older imports still resolve; they no longer gate the log.
+ */
 export declare const CLOSE_LOG_ALWAYS_COUNT = 3;
 export declare const CLOSE_LOG_INTERVAL_MS = 60000;
 export interface PresencePayload {
@@ -111,8 +115,8 @@ export declare class PresenceClient {
     private reconnectHandle;
     private stableHandle;
     private connectedAtMs;
-    private closeLogCount;
-    private lastCloseLogAtMs;
+    /** One close log per transition into reconnecting, until the next connect. */
+    private reconnectLogged;
     private stopped;
     private generation;
     private publishedTopics;

package/dist/lib/mesh/live/daemon/presence.js

@@ -34,7 +34,11 @@ export const CONNECT_STABLE_GRACE_MS = 5_000;
  * waits at least this long regardless of the backoff/grace-reset state.
  */
 export const RECONNECT_MIN_DELAY_MS = 1_000;
-/** Always emit the first N close info lines, then at most one per interval. */
+/**
+ * Close/reconnect info is one line per transition into reconnecting.
+ * Repeated `close` events while already reconnecting do not log again.
+ * Kept so older imports still resolve; they no longer gate the log.
+ */
 export const CLOSE_LOG_ALWAYS_COUNT = 3;
 export const CLOSE_LOG_INTERVAL_MS = 60_000;
 /**
@@ -81,8 +85,8 @@ export class PresenceClient {
     reconnectHandle = null;
     stableHandle = null;
     connectedAtMs = null;
-    closeLogCount = 0;
-    lastCloseLogAtMs = Number.NEGATIVE_INFINITY;
+    /** One close log per transition into reconnecting, until the next connect. */
+    reconnectLogged = false;
     stopped = false;
     generation = 0;
     publishedTopics = [];
@@ -281,6 +285,7 @@ export class PresenceClient {
                     this.attempt = 0;
                     this.lastBackoffMs = 0;
                 }, CONNECT_STABLE_GRACE_MS);
+                this.reconnectLogged = false;
                 this.setState("connected");
                 void this.publishAll("online").then(() => {
                     this.options.onOnline?.(bundle.companies.map((c) => c.companyUid));
@@ -383,13 +388,9 @@ export class PresenceClient {
         return delay;
     }
     maybeLogClose(elapsedMs, delayMs) {
-        const now = this.timers.now();
-        const withinAlways = this.closeLogCount < CLOSE_LOG_ALWAYS_COUNT;
-        const intervalElapsed = now - this.lastCloseLogAtMs >= CLOSE_LOG_INTERVAL_MS;
-        if (!withinAlways && !intervalElapsed)
+        if (this.reconnectLogged)
             return;
-        this.closeLogCount += 1;
-        this.lastCloseLogAtMs = now;
+        this.reconnectLogged = true;
         this.options.onInfo?.(`presence mqtt closed after ${elapsedMs}ms; reconnect in ${delayMs}ms`);
     }
     clearReconnect() {

package/dist/lib/mesh/live/daemon/run.d.ts

@@ -18,6 +18,7 @@ import { type PidLockDeps } from "./pid-lock.js";
 import { PresenceClient, type MqttConnectFn } from "./presence.js";
 import { TranscriptWatcher, type TranscriptFs } from "./transcript-watch.js";
 import { type MeshEmitMode } from "./mode.js";
+import { type CommandRunner, type LegacyListenPlatform } from "./legacy-listen.js";
 export declare const SPOOL_DEBOUNCE_MS = 2000;
 export declare const FLUSH_INTERVAL_MS = 10000;
 /** Keep startup recovery bounded: the next daemon start continues the backlog. */
@@ -102,10 +103,22 @@ export interface DaemonRunDeps {
     runForMs?: number;
     /** CLI version loaded by this daemon. Defaults to this package's version. */
     daemonVersion?: string;
+    /**
+     * Subscribe to the personal work topic and write live-cache.json.
+     * The `hq mesh daemon run` command turns this on. Tests leave it off
+     * unless they inject credentials.
+     */
+    enableWorkCache?: boolean;
+    fetchPersonalCredentials?: import("./credentials.js").PersonalCredentialsFetcher;
     /** Read the currently installed CLI version behind the launch entrypoint. */
     readInstalledCliVersion?: () => string | null;
     random?: () => number;
     now?: () => Date;
+    /** Host for legacy listen retirement. Tests inject this; default is process.platform. */
+    legacyListenPlatform?: LegacyListenPlatform;
+    /** Service-manager runner for legacy listen retirement (tests inject). */
+    legacyListenRun?: CommandRunner;
+    windowsLegacyTaskPresent?: boolean;
 }
 export interface DaemonHandle {
     stop: () => Promise<void>;

package/dist/lib/mesh/live/daemon/run.js

@@ -26,17 +26,19 @@ import { backfillHeldSessions, } from "../backfill-held.js";
 import { reconcileObservation } from "../../../work-context/reconcile.js";
 import { workMeshRoot, workMeshSpoolPath } from "../paths.js";
 import { createVaultBoardReader, refreshBoundSessionBoards, BOARD_REFRESH_INTERVAL_MS, } from "./board-refresh.js";
-import { createContract3Fetcher, realTimerHost, } from "./credentials.js";
+import { createContract3Fetcher, createPersonalRealtimeFetcher, realTimerHost, } from "./credentials.js";
 import { appendDaemonLog, daemonLogLine, ensureDaemonLog } from "./log.js";
 import { acquirePidLock, defaultPidLockDeps, releasePidLock, } from "./pid-lock.js";
 import { daemonDir } from "./paths.js";
-import { PresenceClient, } from "./presence.js";
+import { PresenceClient, defaultMqttConnect, } from "./presence.js";
 import { defaultDaemonState, patchDaemonState, readDaemonState, writeDaemonState, } from "./state.js";
 import { workMeshHeldPath } from "../paths.js";
 import { noteHookSessionsFromSpoolFile, TRANSCRIPT_WATCH_INTERVAL_MS, TranscriptWatcher, } from "./transcript-watch.js";
 import { resolveMeshEmitMode, runsEmitPath, } from "./mode.js";
 import { hasCliVersionDrift, readInstalledCliVersion } from "./version-drift.js";
 import { readDaemonConfig } from "./config.js";
+import { retireLegacyListen } from "./legacy-listen.js";
+import { startWorkCacheSubscriber } from "./work-subscribe.js";
 export const SPOOL_DEBOUNCE_MS = 2_000;
 export const FLUSH_INTERVAL_MS = 10_000;
 /** Keep startup recovery bounded: the next daemon start continues the backlog. */
@@ -112,6 +114,15 @@ export async function runMeshDaemon(deps = {}) {
     const daemonVersion = deps.daemonVersion ?? CLI_VERSION;
     const installedCliVersion = deps.readInstalledCliVersion ?? readInstalledCliVersion;
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const hostPlatform = process.platform === "darwin" || process.platform === "linux" || process.platform === "win32"
+        ? process.platform
+        : "other";
+    const retiredListen = retireLegacyListen({
+        home,
+        platform: deps.legacyListenPlatform ?? hostPlatform,
+        run: deps.legacyListenRun,
+        windowsTaskPresent: deps.windowsLegacyTaskPresent,
+    });
     const configuredRoots = readDaemonConfig(dir).trustedHqRoots;
     const trustedRoots = [...new Set([
             ...(deps.hqRoot ? [deps.hqRoot] : []),
@@ -119,6 +130,9 @@ export async function runMeshDaemon(deps = {}) {
             ...configuredRoots,
         ])];
     ensureDaemonLog(dir);
+    if (retiredListen.removed) {
+        log(dir, "retired legacy listener ai.getindigo.hq-work-mesh-listen");
+    }
     const lockDeps = deps.pidLock ?? defaultPidLockDeps({ isProcessAlive: alive });
     const lock = acquirePidLock(dir, lockDeps);
     if (!lock.ok) {
@@ -369,6 +383,7 @@ export async function runMeshDaemon(deps = {}) {
             });
         });
     let presence = null;
+    let workCache = null;
     if (deps.enablePresence !== false) {
         const fetchCredentialsRaw = deps.fetchCredentials ??
             (async () => {
@@ -430,6 +445,31 @@ export async function runMeshDaemon(deps = {}) {
             // Continue draining spool even if MQTT is down.
         }
     }
+    if (deps.enableWorkCache) {
+        try {
+            workCache = await startWorkCacheSubscriber({
+                meshRoot,
+                fetchCredentials: deps.fetchPersonalCredentials ?? (async () => {
+                    const t = await getToken();
+                    return createPersonalRealtimeFetcher({
+                        token: t,
+                        baseUrl: resolveVaultApiBase(env),
+                    })();
+                }),
+                mqttConnect: (url, options) => {
+                    const connect = deps.mqttConnect ?? defaultMqttConnect;
+                    return connect(url, options);
+                },
+                now,
+                onInfo: (message) => log(dir, message.slice(0, 200)),
+                random: deps.random,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(dir, `work cache subscribe failed: ${msg.slice(0, 200)}`);
+        }
+    }
     let stopped = false;
     let restartRequested = false;
     let flushInFlight = null;
@@ -708,6 +748,15 @@ export async function runMeshDaemon(deps = {}) {
         // Final flush, then clean MQTT DISCONNECT so the broker emits the
         // lifecycle event; offline is published server-side only.
         await doFlushCycle("shutdown", { force: true });
+        if (workCache) {
+            try {
+                await workCache.stop();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(dir, `work cache stop error: ${msg.slice(0, 120)}`);
+            }
+        }
         if (presence) {
             try {
                 await presence.stop();

package/dist/lib/mesh/live/daemon/work-subscribe.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Contract-2 subscriber for the personal work topic.
+ * Owns live-cache.json writes. Presence publish stays on PresenceClient.
+ */
+import type { IClientOptions } from "mqtt";
+import { type PersonalCredentialsFetcher } from "./credentials.js";
+export interface WorkCacheMqtt {
+    on(event: string, handler: (...args: any[]) => void): unknown;
+    subscribe(topic: string, opts: {
+        qos: 0 | 1;
+    }, cb?: (err?: Error | null) => void): unknown;
+    end(force?: boolean, cb?: () => void): unknown;
+}
+export interface WorkCacheSubscriber {
+    stop: () => Promise<void>;
+}
+export declare function startWorkCacheSubscriber(opts: {
+    meshRoot: string;
+    fetchCredentials?: PersonalCredentialsFetcher;
+    token?: () => Promise<string>;
+    baseUrl?: string;
+    mqttConnect: (url: string, options: IClientOptions) => WorkCacheMqtt;
+    now?: () => Date;
+    timers?: {
+        setTimeout: (fn: () => void, ms: number) => unknown;
+        clearTimeout: (handle: unknown) => void;
+    };
+    onInfo?: (message: string) => void;
+    random?: () => number;
+}): Promise<WorkCacheSubscriber>;
+//# sourceMappingURL=work-subscribe.d.ts.map

package/dist/lib/mesh/live/daemon/work-subscribe.js

@@ -0,0 +1,124 @@
+/**
+ * Contract-2 subscriber for the personal work topic.
+ * Owns live-cache.json writes. Presence publish stays on PresenceClient.
+ */
+import { createPersonalRealtimeFetcher, } from "./credentials.js";
+import { presignIotWssUrl } from "./presign.js";
+import { applyProjectViewPush, parseProjectViewPush } from "./live-cache.js";
+import { backoffDelayMs, RECONNECT_MIN_DELAY_MS } from "./presence.js";
+export async function startWorkCacheSubscriber(opts) {
+    const fetchCredentials = opts.fetchCredentials ??
+        (opts.token
+            ? createPersonalRealtimeFetcher({
+                token: await opts.token(),
+                baseUrl: opts.baseUrl,
+            })
+            : null);
+    if (!fetchCredentials) {
+        throw new Error("work cache subscriber needs credentials");
+    }
+    const now = opts.now ?? (() => new Date());
+    const timers = opts.timers ?? {
+        setTimeout: (fn, ms) => setTimeout(fn, ms),
+        clearTimeout: (handle) => clearTimeout(handle),
+    };
+    const random = opts.random ?? Math.random;
+    let stopped = false;
+    let client = null;
+    let reconnectLogged = false;
+    let attempt = 0;
+    let timer = null;
+    let generation = 0;
+    const connect = async () => {
+        if (stopped)
+            return;
+        const gen = ++generation;
+        let bundle;
+        try {
+            bundle = await fetchCredentials();
+        }
+        catch (err) {
+            schedule(err);
+            return;
+        }
+        if (stopped || gen !== generation)
+            return;
+        const topic = bundle.topics.work;
+        if (!topic) {
+            opts.onInfo?.("work cache subscribe skipped: credentials have no work topic");
+            return;
+        }
+        const url = presignIotWssUrl(bundle.credentials, bundle.iotEndpoint, bundle.region, now());
+        const next = opts.mqttConnect(url, {
+            clientId: `${bundle.clientId}-work`,
+            clean: true,
+            reconnectPeriod: 0,
+            protocolVersion: 4,
+        });
+        client = next;
+        next.on("connect", () => {
+            if (stopped || gen !== generation)
+                return;
+            reconnectLogged = false;
+            attempt = 0;
+            next.subscribe(topic, { qos: 1 }, () => undefined);
+        });
+        next.on("message", (_topic, payload) => {
+            if (stopped || gen !== generation)
+                return;
+            if (_topic !== topic)
+                return;
+            const push = parseProjectViewPush(payload);
+            if (!push)
+                return;
+            const result = applyProjectViewPush(opts.meshRoot, push, now().toISOString());
+            if (result.applied) {
+                opts.onInfo?.(`project-view cache cursor=${result.cursor} ${push.companyUid}/${push.projectId}`);
+            }
+        });
+        next.on("close", () => {
+            if (stopped || gen !== generation)
+                return;
+            schedule();
+        });
+    };
+    const schedule = (err) => {
+        if (stopped)
+            return;
+        if (!reconnectLogged) {
+            reconnectLogged = true;
+            const detail = err instanceof Error ? `: ${err.message}` : "";
+            opts.onInfo?.(`work cache mqtt reconnecting${detail}`.slice(0, 200));
+        }
+        if (timer !== null)
+            timers.clearTimeout(timer);
+        const delay = backoffDelayMs(attempt, 1000, 60_000, random, 0, RECONNECT_MIN_DELAY_MS);
+        attempt += 1;
+        timer = timers.setTimeout(() => {
+            timer = null;
+            void connect();
+        }, delay);
+    };
+    await connect();
+    return {
+        stop: async () => {
+            stopped = true;
+            generation += 1;
+            if (timer !== null)
+                timers.clearTimeout(timer);
+            const current = client;
+            client = null;
+            if (!current)
+                return;
+            await new Promise((resolve) => {
+                try {
+                    current.end(true, () => resolve());
+                }
+                catch {
+                    resolve();
+                }
+            });
+        },
+    };
+}
+//# sourceMappingURL=work-subscribe.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.132.0",
+  "version": "5.134.0",
   "description": "HQ by Indigo management CLI \u2014 modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -39,7 +39,7 @@
   "dependencies": {
     "@aws-sdk/client-iot-data-plane": "^3.1096.0",
     "@aws-sdk/client-s3": "^3.1049.0",
-    "@indigoai-us/hq-cloud": "~6.16.60",
+    "@indigoai-us/hq-cloud": "~6.16.74",
     "@indigoai-us/hq-flags-client": "^0.1.2",
     "@sentry/node": "^10.49.0",
     "@tobilu/qmd": "2.5.3",