@indigoai-us/hq-cli 5.345.108 → 5.345.110

package/dist/hq-cloud-sync-runner/package.json

@@ -1 +1 @@
-{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.67","bundleSha256":"6d94ad9a9dbfa34fd81040eff69d68a1da68ab0d1318566832fe19393bffe589","formatVersion":1}
+{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.69","bundleSha256":"f061a19c14325b3ae076aa6277c2f60269976ef43ef7ce79be2140d0ba2927a6","formatVersion":1}

package/dist/index.d.ts

@@ -5,13 +5,21 @@ import { isVersionRequest } from "./version-request.js";
 import { isFastCoreRequest } from "./fast-scaffold.js";
 type PackageUseLeaseLoader = () => Promise<void>;
 type PackageUseUpdateProbe = () => Promise<boolean>;
+/** Resolves true once the command was re-run (exit code already set). */
+type PackageUseUpdateReexec = () => Promise<boolean>;
+/**
+ * Wait (bounded) for a live updater to finish, then re-run this command from
+ * the new install via the same bin path. Guarded against loops by an env flag.
+ */
+declare function waitForUpdateThenReexec(argv?: readonly string[], env?: NodeJS.ProcessEnv, waitForUpdate?: () => Promise<boolean>, run?: (command: string, args: string[], childEnv: NodeJS.ProcessEnv) => Promise<number>): Promise<boolean>;
 declare function isNpmPackageEntry(entryUrl: string): boolean;
-declare function dispatchWithPackageUseLease(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader, updateRequestPending?: PackageUseUpdateProbe): void | Promise<void>;
+declare function dispatchWithPackageUseLease(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader, updateRequestPending?: PackageUseUpdateProbe, waitThenReexec?: PackageUseUpdateReexec): void | Promise<void>;
 declare function runCliEntry(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader): void | Promise<void>;
 export declare const __test__: {
     isVersionRequest: typeof isVersionRequest;
     isFastCoreRequest: typeof isFastCoreRequest;
     dispatchWithPackageUseLease: typeof dispatchWithPackageUseLease;
+    waitForUpdateThenReexec: typeof waitForUpdateThenReexec;
     runCliEntry: typeof runCliEntry;
     isNpmPackageEntry: typeof isNpmPackageEntry;
     acquirePackageUseLease: (prefix: string, version: string, stateDirectory?: string) => Promise<import("./utils/package-use-lease.js").PackageUseLease>;

package/dist/index.js

@@ -230,6 +230,36 @@ function dispatchCliEntry() {
         void runMainWithInstallTreeRecovery();
     }
 }
+const REEXEC_ENV = "HQ_CLI_UPDATE_REEXEC";
+/**
+ * Wait (bounded) for a live updater to finish, then re-run this command from
+ * the new install via the same bin path. Guarded against loops by an env flag.
+ */
+async function waitForUpdateThenReexec(argv = process.argv, env = process.env, waitForUpdate = async () => {
+    const { waitForCurrentPackageUseUpdate } = await import("./utils/package-use-lease.js");
+    return waitForCurrentPackageUseUpdate();
+}, run = async (command, args, childEnv) => {
+    const { spawn } = await import("node:child_process");
+    return await new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: "inherit", env: childEnv });
+        child.on("error", () => resolve(1));
+        child.on("exit", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+    });
+}) {
+    if (env[REEXEC_ENV] === "1" || !argv[1])
+        return false;
+    let finished = false;
+    try {
+        finished = await waitForUpdate();
+    }
+    catch {
+        return false;
+    }
+    if (!finished)
+        return false;
+    process.exitCode = await run(process.execPath, argv.slice(1), { ...env, [REEXEC_ENV]: "1" });
+    return true;
+}
 function isNpmPackageEntry(entryUrl) {
     return /\/node_modules\/@indigoai-us\/hq-cli\/dist\/index\.js$/i.test(entryUrl);
 }
@@ -260,7 +290,7 @@ function dispatchWithPackageUseLease(entryUrl, dispatch, loadLease = async () =>
 }, updateRequestPending = async () => {
     const { currentPackageUseUpdatePending } = await import("./utils/package-use-lease.js");
     return currentPackageUseUpdatePending();
-}) {
+}, waitThenReexec = waitForUpdateThenReexec) {
     if (!isNpmPackageEntry(entryUrl)) {
         dispatch();
         return;
@@ -270,6 +300,12 @@ function dispatchWithPackageUseLease(entryUrl, dispatch, loadLease = async () =>
             throw error;
         try {
             if (await updateRequestPending()) {
+                // The install tree is being replaced under this process, so the lease
+                // module (or a dependency) failed to load. Wait for the updater, then
+                // run the command again from the freshly installed package instead of
+                // failing a running session's command outright.
+                if (await waitThenReexec())
+                    return;
                 const pending = new Error("The HQ CLI package is being updated; retry after the update finishes");
                 pending.name = "PackageUseUpdatePendingError";
                 throw pending;
@@ -311,6 +347,7 @@ export const __test__ = {
     isVersionRequest,
     isFastCoreRequest,
     dispatchWithPackageUseLease,
+    waitForUpdateThenReexec,
     runCliEntry,
     isNpmPackageEntry,
     acquirePackageUseLease: async (prefix, version, stateDirectory) => {