@indigoai-us/hq-cli 5.345.35 → 5.345.36

package/dist/utils/package-use-lease.d.ts

@@ -50,5 +50,22 @@ export declare const __test__: {
     waitForUpdateRequest: typeof waitForUpdateRequest;
     setCurrentPackageUseLease(lease: PackageUseLease | null): void;
 };
+/**
+ * Run `wait` with this process's package-use lease DROPPED, then reacquire the
+ * lease before returning.
+ *
+ * `hq sync` runs under purpose `"command"`, and
+ * {@link releasePackageUseLeaseAfterCommandLoad} deliberately keeps that lease
+ * for the whole command. hq-cloud's per-root operation lock then waits — by
+ * default without a bound — for whichever process is already syncing, so an old
+ * `hq` install pinned `hq pkg update` for the entire length of somebody else's
+ * lock wait (HQ-DESKTOP-8H). Queuing is not using the package: drop the lease
+ * while this process is only waiting, and take it again once the wait is over.
+ *
+ * A reacquire that throws {@link PackageUseUpdatePendingError} is the correct
+ * outcome — an update landed while we queued — and propagates to the caller. On
+ * the failure path the original error wins and the reacquire is best-effort.
+ */
+export declare function withPackageUseLeaseReleasedDuring<T>(wait: () => Promise<T>, argv?: readonly string[], release?: () => void, reacquire?: (argv: readonly string[]) => unknown): Promise<T>;
 export {};
 //# sourceMappingURL=package-use-lease.d.ts.map

package/dist/utils/package-use-lease.js

@@ -413,4 +413,40 @@ export const __test__ = {
         currentPackageUseLease = lease;
     },
 };
+/**
+ * Run `wait` with this process's package-use lease DROPPED, then reacquire the
+ * lease before returning.
+ *
+ * `hq sync` runs under purpose `"command"`, and
+ * {@link releasePackageUseLeaseAfterCommandLoad} deliberately keeps that lease
+ * for the whole command. hq-cloud's per-root operation lock then waits — by
+ * default without a bound — for whichever process is already syncing, so an old
+ * `hq` install pinned `hq pkg update` for the entire length of somebody else's
+ * lock wait (HQ-DESKTOP-8H). Queuing is not using the package: drop the lease
+ * while this process is only waiting, and take it again once the wait is over.
+ *
+ * A reacquire that throws {@link PackageUseUpdatePendingError} is the correct
+ * outcome — an update landed while we queued — and propagates to the caller. On
+ * the failure path the original error wins and the reacquire is best-effort.
+ */
+export async function withPackageUseLeaseReleasedDuring(wait, argv = process.argv, release = releaseCurrentPackageUseLease, reacquire = acquireCurrentPackageUseLease) {
+    if (currentPackageUseLease === null)
+        return wait();
+    release();
+    let result;
+    try {
+        result = await wait();
+    }
+    catch (error) {
+        try {
+            reacquire(argv);
+        }
+        catch {
+            // The caller's error is the one worth reporting.
+        }
+        throw error;
+    }
+    reacquire(argv);
+    return result;
+}
 //# sourceMappingURL=package-use-lease.js.map

package/dist/utils/sync-operation-lock.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Take hq-cloud's per-root operation lock for a sync pass from hq-cli, so the
+ * wait for an existing holder happens OUTSIDE this process's package-use lease.
+ *
+ * `sync()` normally wraps itself in `withOperationLock`, which waits for a live
+ * holder with no bound unless `HQ_OP_LOCK_TIMEOUT` says otherwise. `hq sync`
+ * runs under package-use purpose `"command"`, whose lease is held for the whole
+ * command, so the queued process pinned the installed `hq` version — and
+ * therefore blocked `hq pkg update` — for the entire length of somebody else's
+ * sync (HQ-DESKTOP-8H).
+ *
+ * Acquiring the lock here instead lets the lease be dropped across the wait and
+ * retaken the moment the lock is held, before any sync work runs.
+ * `operationLockAlreadyHeld` is the seam hq-cloud exposes for a caller that owns
+ * the lock; the lock is NOT reentrant in-process, so the flag is required rather
+ * than optional.
+ */
+import { type SyncOptions, type SyncResult } from "@indigoai-us/hq-cloud";
+import { type LockHandle } from "@indigoai-us/hq-cloud/operation-lock";
+export interface SyncUnderOperationLockDeps<Options, Result> {
+    sync: (options: Options & {
+        operationLockAlreadyHeld: true;
+    }) => Promise<Result>;
+    /** Injected in tests; defaults to hq-cloud's wait-capable acquisition. */
+    acquireLock?: (hqRoot: string) => Promise<LockHandle>;
+    /** Injected in tests; defaults to the real lease drop/retake. */
+    withLeaseReleased?: <T>(wait: () => Promise<T>) => Promise<T>;
+}
+export declare function syncUnderOperationLock<Options extends {
+    hqRoot: string;
+}, Result>(options: Options, deps: SyncUnderOperationLockDeps<Options, Result>): Promise<Result>;
+/**
+ * The production sync leg: hq-cloud's `sync()` under a lock this process takes
+ * itself. Every `hq sync` path in `src/commands/cloud.ts` calls this.
+ */
+export declare function syncLeg(options: SyncOptions): Promise<SyncResult>;
+//# sourceMappingURL=sync-operation-lock.d.ts.map

package/dist/utils/sync-operation-lock.js

@@ -0,0 +1,40 @@
+/**
+ * Take hq-cloud's per-root operation lock for a sync pass from hq-cli, so the
+ * wait for an existing holder happens OUTSIDE this process's package-use lease.
+ *
+ * `sync()` normally wraps itself in `withOperationLock`, which waits for a live
+ * holder with no bound unless `HQ_OP_LOCK_TIMEOUT` says otherwise. `hq sync`
+ * runs under package-use purpose `"command"`, whose lease is held for the whole
+ * command, so the queued process pinned the installed `hq` version — and
+ * therefore blocked `hq pkg update` — for the entire length of somebody else's
+ * sync (HQ-DESKTOP-8H).
+ *
+ * Acquiring the lock here instead lets the lease be dropped across the wait and
+ * retaken the moment the lock is held, before any sync work runs.
+ * `operationLockAlreadyHeld` is the seam hq-cloud exposes for a caller that owns
+ * the lock; the lock is NOT reentrant in-process, so the flag is required rather
+ * than optional.
+ */
+import { sync } from "@indigoai-us/hq-cloud";
+import { acquireOperationLockAsync, } from "@indigoai-us/hq-cloud/operation-lock";
+import { withPackageUseLeaseReleasedDuring } from "./package-use-lease.js";
+export async function syncUnderOperationLock(options, deps) {
+    const acquireLock = deps.acquireLock ?? ((hqRoot) => acquireOperationLockAsync(hqRoot, "sync"));
+    const withLeaseReleased = deps.withLeaseReleased ??
+        ((wait) => withPackageUseLeaseReleasedDuring(wait));
+    const handle = await withLeaseReleased(() => acquireLock(options.hqRoot));
+    try {
+        return await deps.sync({ ...options, operationLockAlreadyHeld: true });
+    }
+    finally {
+        handle.release();
+    }
+}
+/**
+ * The production sync leg: hq-cloud's `sync()` under a lock this process takes
+ * itself. Every `hq sync` path in `src/commands/cloud.ts` calls this.
+ */
+export function syncLeg(options) {
+    return syncUnderOperationLock(options, { sync });
+}
+//# sourceMappingURL=sync-operation-lock.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.35",
+  "version": "5.345.36",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -48,7 +48,7 @@
     "@aws-sdk/client-iot-data-plane": "^3.1096.0",
     "@aws-sdk/client-s3": "^3.1049.0",
     "@aws-sdk/dsql-signer": "^3.1146.0",
-    "@indigoai-us/hq-cloud": "~6.18.33",
+    "@indigoai-us/hq-cloud": "~6.18.50",
     "@indigoai-us/hq-flags-client": "^0.1.2",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@sentry/node": "^10.49.0",