@indigoai-us/hq-cloud 6.18.31 → 6.18.32

package/dist/cli/rescue-core.js

@@ -733,7 +733,7 @@ export function runRescue(argv, opts = {}) {
             tmpdir = d;
         }, () => {
             retainTmpdir = true;
-        }, opts.gitReachabilityProbeTimeoutMs ?? GIT_REACHABILITY_PROBE_TIMEOUT_MS, opts.coreSourceStampWriter, opts.restoreOnRsyncFailure === true, opts.backupCapacityStatfsSync ?? fs.statfsSync, opts.backupCapacityCloneProbe ?? probeCopyOnWriteClone, opts.backupCapacityStatSync ?? fs.statSync);
+        }, opts.gitReachabilityProbeTimeoutMs ?? GIT_REACHABILITY_PROBE_TIMEOUT_MS, opts.coreSourceStampWriter, opts.restoreOnRsyncFailure === true, opts.setupPathSettingsLocal === true, opts.backupCapacityStatfsSync ?? fs.statfsSync, opts.backupCapacityCloneProbe ?? probeCopyOnWriteClone, opts.backupCapacityStatSync ?? fs.statSync);
     }
     catch (e) {
         if (e instanceof ExitError)
@@ -1536,7 +1536,7 @@ function recoveryProof(unresolved, cfg, hqRoot, srcDir, srcSha, rsyncLauncher, r
     }
     return { eligible: !hasSkippedSnapshotEntries(newest.entry.manifest), failures };
 }
-function doRescue(cfg, env, out, err, setTmp, retainTmp, gitReachabilityProbeTimeoutMs = GIT_REACHABILITY_PROBE_TIMEOUT_MS, stampWriter = writeCoreSourceStamp, restoreOnRsyncFailure = false, backupCapacityStatfsSync = fs.statfsSync, backupCapacityCloneProbe = probeCopyOnWriteClone, backupCapacityStatSync = fs.statSync) {
+function doRescue(cfg, env, out, err, setTmp, retainTmp, gitReachabilityProbeTimeoutMs = GIT_REACHABILITY_PROBE_TIMEOUT_MS, stampWriter = writeCoreSourceStamp, restoreOnRsyncFailure = false, setupPathSettingsLocal = false, backupCapacityStatfsSync = fs.statfsSync, backupCapacityCloneProbe = probeCopyOnWriteClone, backupCapacityStatSync = fs.statSync) {
     const hqRoot = resolveHqRoot(cfg, err);
     const RUN_TS = utcStamp(new Date(), "dash");
     // Both the release overlay and a restorable snapshot require rsync.  A shim
@@ -2280,8 +2280,8 @@ function doRescue(cfg, env, out, err, setTmp, retainTmp, gitReachabilityProbeTim
         // Runs AFTER the overlay (which re-laid the release template, wiring in any
         // newly-released hook registrations) and AFTER the preserve-subpath restore
         // (which brought back the user's .claude/settings.local.json). Re-composes the
-        // machine env.PATH onto the release baseline and relocates genuine user drift
-        // (vs the last-sync floor) into settings.local.json so the effective merged
+        // machine env.PATH into the flag-selected settings file and relocates genuine
+        // user drift (vs the last-sync floor) into settings.local.json so the effective merged
         // settings are preserved. No-op in narrow mode that excludes .claude.
         if (claudeSettingsInScope && !isSkippedSnapshotPath(ctx, claudeSettingsRel)) {
             reconcileClaudeSettings({
@@ -2291,6 +2291,7 @@ function doRescue(cfg, env, out, err, setTmp, retainTmp, gitReachabilityProbeTim
                 historyFloor,
                 baselineMode,
                 preserveSubpaths: cfg.preserveSubpaths,
+                setupPathSettingsLocal,
             }, preRescueSettingsJson, out, err);
         }
         else if (claudeSettingsInScope) {
@@ -3020,7 +3021,7 @@ function jsonParseOrNull(text) {
  *  - scalar / type-mismatch: drift = ours's value when not deep-equal.
  *
  * `excludePath` names dotted key paths that are NEVER drift (env.PATH — a
- * machine-local value re-composed onto the release baseline, not relocated).
+ * machine-local value composed into the flag-selected settings file, not relocated).
  * Returns `undefined` when there is no drift at this node.
  */
 export function settingsDrift(ours, base, excludePath = ["env.PATH"], pathPrefix = "") {
@@ -3130,6 +3131,8 @@ export function applyArrayRemovals(theirs, ours, base) {
  * falls back to the overlaid one; if neither runs, carries `basePath` verbatim.
  */
 function composeSettingsPath(srcDir, hqRoot, basePath, env) {
+    const baseEntries = mergeUsablePathEntries(basePath, env);
+    const cleanBase = baseEntries.join(path.delimiter);
     const candidates = [
         path.join(srcDir, "core", "scripts", "compose-settings-path.sh"),
         path.join(hqRoot, "core", "scripts", "compose-settings-path.sh"),
@@ -3137,12 +3140,76 @@ function composeSettingsPath(srcDir, hqRoot, basePath, env) {
     for (const script of candidates) {
         if (!isFileFollow(script))
             continue;
-        const r = run("bash", [script, basePath], { env });
+        const r = run("bash", [script, cleanBase], { env });
         const composed = r.stdout.replace(/\n+$/, "");
-        if (r.status === 0 && composed)
-            return composed;
+        if (r.status === 0 && composed) {
+            // Composer versions bundled in older releases may prepend toolchain
+            // paths. Preserve the user's established order and append only clean,
+            // newly discovered paths from the composer.
+            return mergeUsablePathEntries(cleanBase, composed, env).join(path.delimiter);
+        }
+    }
+    return cleanBase;
+}
+function mergeUsablePathEntries(...pathsAndEnv) {
+    const env = pathsAndEnv.find((value) => typeof value !== "string") ?? process.env;
+    const values = pathsAndEnv.filter((value) => typeof value === "string");
+    const home = env.HOME ?? env.USERPROFILE;
+    const homePath = home ? path.resolve(home) : undefined;
+    const temporaryRoots = [
+        os.tmpdir(),
+        env.TMPDIR,
+        env.TMP,
+        env.TEMP,
+        "/tmp",
+        "/var/tmp",
+        "/private/tmp",
+        "/private/var/folders",
+    ]
+        .filter((value) => Boolean(value))
+        .map((root) => path.resolve(root))
+        .filter((root) => {
+        // A malformed temp setting such as TMPDIR=/ (or /home when HOME=/home/u)
+        // must not classify every usable PATH entry as temporary.
+        if (root === path.parse(root).root)
+            return false;
+        if (homePath) {
+            const homeRelative = path.relative(root, homePath);
+            if (homeRelative === "" ||
+                (!homeRelative.startsWith(`..${path.sep}`) && homeRelative !== "..")) {
+                return false;
+            }
+        }
+        return true;
+    });
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        for (const rawEntry of value.split(path.delimiter)) {
+            const entry = rawEntry.trim();
+            if (!entry)
+                continue;
+            const normalized = path.normalize(entry);
+            const parts = normalized.split(/[\\/]+/);
+            if (parts.some((part) => {
+                const lower = part.toLowerCase();
+                return lower === "_npx";
+            }))
+                continue;
+            const absolute = path.resolve(entry);
+            if (temporaryRoots.some((root) => {
+                const relative = path.relative(path.resolve(root), absolute);
+                return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== "..");
+            }))
+                continue;
+            const key = process.platform === "win32" ? normalized.toLowerCase() : normalized;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            result.push(entry);
+        }
     }
-    return basePath;
+    return result;
 }
 /** True when `.claude/settings.json` is covered by an EXPLICIT preserve subpath
  *  (the caller asked rescue to keep it, so the reconcile must not rewrite it).
@@ -3163,7 +3230,7 @@ function settingsExplicitlyPreserved(preserveSubpaths) {
  * At entry the overlay has already re-laid the release template (theirs) over
  * settings.json, and the user's settings.local.json has been restored from the
  * preserve shuttle. This function:
- *   1. re-composes env.PATH onto theirs (machine-specific; deliverable 3), and
+ *   1. composes env.PATH into the flag-selected settings file (machine-specific), and
  *   2. extracts ours's drift versus the last-sync floor (base) — excluding
  *      env.PATH — and merges it into settings.local.json (deliverable 2),
  * so the EFFECTIVE merged settings (Project ⊕ Local, per Claude Code's rules)
@@ -3175,7 +3242,7 @@ function settingsExplicitlyPreserved(preserveSubpaths) {
  * rescue's posture elsewhere.
  */
 export function reconcileClaudeSettings(ctx, preRescueSettingsJson, out, err) {
-    const { hqRoot, srcDir, env, historyFloor, baselineMode, preserveSubpaths } = ctx;
+    const { hqRoot, srcDir, env, historyFloor, baselineMode, preserveSubpaths, setupPathSettingsLocal = false, } = ctx;
     const settingsPath = path.join(hqRoot, ".claude", "settings.json");
     const localPath = path.join(hqRoot, ".claude", "settings.local.json");
     // The caller explicitly asked to keep settings.json (via `--preserve-subpath
@@ -3238,18 +3305,34 @@ export function reconcileClaudeSettings(ctx, preRescueSettingsJson, out, err) {
     const oursEnvPath = oursIsValid && isPlainObject(ours.env) && typeof ours.env.PATH === "string"
         ? ours.env.PATH
         : undefined;
-    // 1) Re-compose env.PATH onto the release baseline. Base = the machine's own
-    //    prior PATH snapshot when present, else this process's PATH.
-    const basePath = oursEnvPath ?? envValue(env, "PATH") ?? "";
+    const existingLocalForPath = jsonParseOrNull((() => {
+        try {
+            return isFileFollow(localPath) ? fs.readFileSync(localPath, "utf-8") : null;
+        }
+        catch {
+            return null;
+        }
+    })());
+    const localEnvPath = isPlainObject(existingLocalForPath) &&
+        isPlainObject(existingLocalForPath.env) &&
+        typeof existingLocalForPath.env.PATH === "string"
+        ? existingLocalForPath.env.PATH
+        : undefined;
+    // Keep user-local entries first, followed by the prior project PATH and the
+    // current process PATH. Re-compose only after removing npx/temp paths.
+    const basePath = [localEnvPath, oursEnvPath, envValue(env, "PATH")]
+        .filter((value) => typeof value === "string")
+        .join(path.delimiter);
     const composedPath = composeSettingsPath(srcDir, hqRoot, basePath, env);
-    if (composedPath) {
+    const writePathLocally = setupPathSettingsLocal && Boolean(composedPath);
+    const releaseBaseline = structuredClone(theirs);
+    if (composedPath && !setupPathSettingsLocal) {
         const envObj = isPlainObject(theirs.env) ? theirs.env : (theirs.env = {});
         envObj.PATH = composedPath;
     }
-    // 2) Relocate genuine user drift (ours vs floor baseline) into settings.local,
-    //    and apply user array removals to the Project baseline.
-    let driftKeys = 0;
-    let relocationFailed = false;
+    // Relocate genuine user drift into settings.local, and apply user array
+    // removals to the release baseline.
+    let drift;
     if (oursIsValid) {
         // realBase = settings.json at the last-sync floor (only trustworthy in
         // history_floor mode). Removals require it; additions fall back to theirs.
@@ -3272,21 +3355,46 @@ export function reconcileClaudeSettings(ctx, preRescueSettingsJson, out, err) {
         const additionsBase = isPlainObject(realBase)
             ? realBase
             : theirs;
-        const drift = settingsDrift(ours, additionsBase);
-        if (isPlainObject(drift) && Object.keys(drift).length > 0) {
-            const existingLocal = jsonParseOrNull((() => {
-                try {
-                    return isFileFollow(localPath)
-                        ? fs.readFileSync(localPath, "utf-8")
-                        : null;
-                }
-                catch {
-                    return null;
-                }
-            })());
+        drift = settingsDrift(ours, additionsBase);
+    }
+    let driftKeys = 0;
+    let relocationFailed = false;
+    const hasDrift = isPlainObject(drift) && Object.keys(drift).length > 0;
+    if (hasDrift || writePathLocally) {
+        let existingLocalRaw = null;
+        let existingLocalReadable = true;
+        if (isFileFollow(localPath)) {
+            try {
+                existingLocalRaw = fs.readFileSync(localPath, "utf-8");
+            }
+            catch {
+                existingLocalReadable = false;
+            }
+        }
+        const existingLocal = jsonParseOrNull(existingLocalRaw);
+        const localShapeInvalid = writePathLocally &&
+            (!existingLocalReadable ||
+                (existingLocalRaw !== null && !isPlainObject(existingLocal)) ||
+                (isPlainObject(existingLocal) &&
+                    existingLocal.env !== undefined &&
+                    existingLocal.env !== null &&
+                    !isPlainObject(existingLocal.env)));
+        if (localShapeInvalid) {
+            relocationFailed = true;
+            err("    WARN: could not write .claude/settings.local.json during settings reconcile\n");
+        }
+        else {
             const localObj = isPlainObject(existingLocal) ? existingLocal : {};
-            deepMergeSettings(localObj, drift);
-            driftKeys = Object.keys(drift).length;
+            if (writePathLocally && composedPath) {
+                const localEnv = isPlainObject(localObj.env)
+                    ? localObj.env
+                    : (localObj.env = {});
+                localEnv.PATH = composedPath;
+            }
+            if (hasDrift && isPlainObject(drift)) {
+                deepMergeSettings(localObj, drift);
+                driftKeys = Object.keys(drift).length;
+            }
             try {
                 fs.mkdirSync(path.dirname(localPath), { recursive: true });
                 fs.writeFileSync(localPath, JSON.stringify(localObj, null, 2) + "\n");
@@ -3314,20 +3422,27 @@ export function reconcileClaudeSettings(ctx, preRescueSettingsJson, out, err) {
         err("    WARN: kept your original .claude/settings.json (settings update not applied — settings.local.json was unwritable)\n");
         return;
     }
-    // Write the re-composed release baseline back to settings.json.
+    // In local-flag mode, leave the release blob byte-for-byte intact unless
+    // preserving an intentional user array removal changed its content.
+    const releasedSettingsUnchanged = setupPathSettingsLocal && jsonDeepEqual(theirs, releaseBaseline);
     try {
-        fs.writeFileSync(settingsPath, JSON.stringify(theirs, null, 2) + "\n");
+        if (!releasedSettingsUnchanged) {
+            fs.writeFileSync(settingsPath, JSON.stringify(theirs, null, 2) + "\n");
+        }
     }
     catch {
         err("    WARN: could not write re-composed .claude/settings.json during reconcile\n");
         return;
     }
+    const pathTarget = setupPathSettingsLocal
+        ? ".claude/settings.local.json"
+        : ".claude/settings.json";
     if (driftKeys > 0) {
-        out(`==> Reconciled .claude/settings.json to release baseline (env.PATH re-composed; ` +
+        out(`==> Reconciled .claude/settings.json to release baseline (env.PATH composed into ${pathTarget}; ` +
             `relocated ${driftKeys} drift key(s) -> .claude/settings.local.json)\n`);
     }
     else {
-        out("==> Reconciled .claude/settings.json to release baseline (env.PATH re-composed; no local drift to relocate)\n");
+        out(`==> Reconciled .claude/settings.json to release baseline (env.PATH composed into ${pathTarget}; no local drift to relocate)\n`);
     }
 }
 /**