@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/utils/staged-install.d.ts

@@ -1,34 +0,0 @@
-/**
- * Staged npm self-update: install the new hq-cli beside the running package,
- * check that it starts, then swap it in with two renames.
- *
- * The in-place update moves the live package aside for the whole
- * `npm install -g`, so anything that starts `hq` during the install finds no
- * CLI on disk ("hq: command not found", MODULE_NOT_FOUND; outposts primary and
- * 2, 5.290.0 -> 5.291.0). Here the live package stays in place until the new
- * one is complete and has answered `--version`.
- *
- * Only a plain npm global layout is staged: `<prefix>/lib/node_modules/<pkg>`
- * as a real directory, with bin links in `<prefix>/bin`. pnpm, Bun, Windows
- * and linked checkouts keep the in-place update.
- */
-import * as fs from "node:fs";
-import { type RunningInstall, type UpdateResult } from "./version-gate.js";
-/** Set for the staging install; hq-cli's own postinstall skips itself on it. */
-export declare const STAGED_INSTALL_ENV = "HQ_STAGED_INSTALL";
-export interface StagedInstallDeps {
-    /** Runs the package manager. Defaults to {@link runUpdateCommand}. */
-    run?: (cmd: string, args: string[], env?: NodeJS.ProcessEnv) => UpdateResult;
-    env?: NodeJS.ProcessEnv;
-    /** The version the staged package's `hq --version` reports, or null. */
-    probeVersion?: (packageRoot: string) => string | null;
-    /** The package's postinstall, run from the live path after the swap. */
-    runPostinstall?: (packageRoot: string) => void;
-    rename?: typeof fs.renameSync;
-    /** Removes the staging and backup directories. */
-    remove?: (target: string) => void;
-    platform?: NodeJS.Platform;
-}
-export declare function canStageInstall(install: RunningInstall, platform?: NodeJS.Platform): boolean;
-export declare function stagedNpmInstall(install: RunningInstall, version: string, deps?: StagedInstallDeps): UpdateResult;
-//# sourceMappingURL=staged-install.d.ts.map

package/dist/utils/staged-install.js

@@ -1,346 +0,0 @@
-/**
- * Staged npm self-update: install the new hq-cli beside the running package,
- * check that it starts, then swap it in with two renames.
- *
- * The in-place update moves the live package aside for the whole
- * `npm install -g`, so anything that starts `hq` during the install finds no
- * CLI on disk ("hq: command not found", MODULE_NOT_FOUND; outposts primary and
- * 2, 5.290.0 -> 5.291.0). Here the live package stays in place until the new
- * one is complete and has answered `--version`.
- *
- * Only a plain npm global layout is staged: `<prefix>/lib/node_modules/<pkg>`
- * as a real directory, with bin links in `<prefix>/bin`. pnpm, Bun, Windows
- * and linked checkouts keep the in-place update.
- */
-import { spawnSync } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { CLI_NAME } from "../cli-version.js";
-import { runUpdateCommand } from "./version-gate.js";
-/** Set for the staging install; hq-cli's own postinstall skips itself on it. */
-export const STAGED_INSTALL_ENV = "HQ_STAGED_INSTALL";
-const PROBE_TIMEOUT_MS = 60_000;
-const POSTINSTALL_TIMEOUT_MS = 120_000;
-export function canStageInstall(install, platform = process.platform) {
-    if (platform === "win32" || install.manager !== "npm")
-        return false;
-    if (!install.prefix || !install.packageRoot)
-        return false;
-    if (path.resolve(install.packageRoot) !== path.resolve(install.prefix, "lib", "node_modules", CLI_NAME)) {
-        return false;
-    }
-    try {
-        const entry = fs.lstatSync(install.packageRoot);
-        return entry.isDirectory() && !entry.isSymbolicLink();
-    }
-    catch {
-        return false;
-    }
-}
-export function stagedNpmInstall(install, version, deps = {}) {
-    if (!canStageInstall(install, deps.platform)) {
-        return { ok: false, detail: "this hq-cli install is not a plain npm global install" };
-    }
-    const prefix = install.prefix;
-    const live = install.packageRoot;
-    const env = deps.env ?? process.env;
-    const run = deps.run ?? runUpdateCommand;
-    const rename = deps.rename ?? fs.renameSync;
-    const remove = deps.remove ?? ((target) => fs.rmSync(target, { recursive: true, force: true }));
-    const probe = deps.probeVersion ?? ((root) => probeHqVersion(root, env));
-    const postinstall = deps.runPostinstall ?? ((root) => runPackagePostinstall(root, env));
-    // Beside the live package, so both renames stay on one filesystem.
-    const tag = `${process.pid}-${randomBytes(8).toString("hex")}`;
-    const staging = path.join(path.dirname(live), `.hq-cli-staging-${tag}`);
-    const staged = path.join(staging, "lib", "node_modules", CLI_NAME);
-    const backup = path.join(path.dirname(live), `.hq-cli-backup-${tag}`);
-    let keepBackup = false;
-    try {
-        const result = run("npm", ["install", "-g", "--prefix", staging, `${CLI_NAME}@${version}`], { ...env, [STAGED_INSTALL_ENV]: "1" });
-        if (!result.ok)
-            return result;
-        const reported = probe(staged);
-        if (reported !== version) {
-            return {
-                ok: false,
-                detail: `the staged hq-cli reported ${reported ?? "no version"} instead of ${version}`,
-            };
-        }
-        try {
-            rename(live, backup);
-        }
-        catch (error) {
-            return { ok: false, detail: `could not move the running hq-cli aside: ${message(error)}` };
-        }
-        try {
-            rename(staged, live);
-        }
-        catch (error) {
-            try {
-                rename(backup, live);
-            }
-            catch (restoreError) {
-                keepBackup = true;
-                return {
-                    ok: false,
-                    detail: `could not move hq-cli ${version} into place (${message(error)}) or restore the previous install from ${backup} (${message(restoreError)})`,
-                };
-            }
-            return { ok: false, detail: `could not move hq-cli ${version} into place: ${message(error)}` };
-        }
-        if (!linkBins(prefix, live, readBins(backup), tag, rename)) {
-            // `hq` does not reach the new package, so put the old one back.
-            try {
-                rename(live, staged);
-                rename(backup, live);
-            }
-            catch (error) {
-                keepBackup = true;
-                return {
-                    ok: false,
-                    detail: `could not verify or relink every declared hq-cli bin for ${version}, or restore the previous install from ${backup} (${message(error)})`,
-                };
-            }
-            return { ok: false, detail: `could not verify or relink every declared hq-cli bin for ${version}` };
-        }
-        try {
-            postinstall(live);
-        }
-        catch {
-            // npm runs this script as `... || true`; it never fails an install.
-        }
-        return { ok: true };
-    }
-    finally {
-        // Leftovers are hidden siblings npm ignores; they never change the result.
-        try {
-            remove(staging);
-        }
-        catch {
-            // best effort
-        }
-        if (!keepBackup) {
-            try {
-                remove(backup);
-            }
-            catch {
-                // best effort
-            }
-        }
-    }
-}
-/**
- * Points `<prefix>/bin/<name>` at the live package for each bin it declares
- * and removes hq-cli's links for bins the new version dropped. Existing npm
- * links already point at the live path. A link into another package, or a
- * regular file (someone's wrapper), is left alone.
- *
- * `hq` must resolve into the live package or the caller restores the old
- * package. Other declared bins owned by another tool are left alone and warned
- * about; bins we own or need to create must resolve into the live package.
- */
-function linkBins(prefix, live, previousBins, tag, rename) {
-    const binDir = path.join(prefix, "bin");
-    const ownedByHqCli = (link) => {
-        try {
-            const target = path.resolve(binDir, fs.readlinkSync(link));
-            return target.startsWith(`${live}${path.sep}`);
-        }
-        catch {
-            return false;
-        }
-    };
-    const pointAt = (link, want) => {
-        const temporary = `${link}.hq-cli-${tag}`;
-        try {
-            fs.mkdirSync(binDir, { recursive: true });
-            fs.symlinkSync(want, temporary);
-            rename(temporary, link);
-        }
-        catch {
-            try {
-                fs.rmSync(temporary, { force: true });
-            }
-            catch {
-                // A stray temporary link is harmless.
-            }
-        }
-    };
-    const linkBin = (name, target) => {
-        const link = path.join(binDir, name);
-        const want = path.relative(binDir, path.join(live, target));
-        try {
-            const existing = fs.lstatSync(link, { throwIfNoEntry: false });
-            if (existing && !existing.isSymbolicLink())
-                return;
-            if (existing && fs.readlinkSync(link) === want)
-                return;
-            if (existing && !ownedByHqCli(link))
-                return;
-        }
-        catch {
-            return;
-        }
-        pointAt(link, want);
-    };
-    const bins = readBins(live);
-    if (typeof bins.hq !== "string" || bins.hq.length === 0)
-        return false;
-    const foreignBins = new Set();
-    for (const [name, target] of Object.entries(bins)) {
-        if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\\"))
-            return false;
-        const targetPath = path.resolve(live, target);
-        if (!targetPath.startsWith(`${path.resolve(live)}${path.sep}`) || !resolvesToFile(targetPath))
-            return false;
-        const link = path.join(binDir, name);
-        try {
-            const existing = fs.lstatSync(link, { throwIfNoEntry: false });
-            if (existing && (!existing.isSymbolicLink() || !ownedByHqCli(link))) {
-                if (name === "hq")
-                    return false;
-                foreignBins.add(name);
-                console.error(`⚠ Leaving hq-cli bin entry at ${link} untouched; another tool owns it.`);
-            }
-        }
-        catch {
-            return false;
-        }
-    }
-    const changedBins = [];
-    const linkAndRecord = (name, target) => {
-        const link = path.join(binDir, name);
-        const before = symlinkTarget(link);
-        linkBin(name, target);
-        const after = symlinkTarget(link);
-        if (after !== before)
-            changedBins.push({ link, before });
-    };
-    const rollbackBinChanges = () => {
-        for (const change of changedBins.reverse()) {
-            const current = symlinkTarget(change.link);
-            if (current === null || !ownedByHqCli(change.link))
-                continue;
-            if (change.before === null) {
-                try {
-                    fs.unlinkSync(change.link);
-                }
-                catch {
-                    // The staged update still fails; preserve the best-effort rollback result.
-                }
-            }
-            else {
-                pointAt(change.link, change.before);
-            }
-        }
-    };
-    const hqLink = path.join(binDir, "hq");
-    linkAndRecord("hq", bins.hq);
-    if (!resolvesToPackageBin(hqLink, live, bins.hq)) {
-        rollbackBinChanges();
-        return false;
-    }
-    for (const [name, target] of Object.entries(bins)) {
-        if (name === "hq" || foreignBins.has(name))
-            continue;
-        linkAndRecord(name, target);
-        if (!resolvesToPackageBin(path.join(binDir, name), live, target)) {
-            rollbackBinChanges();
-            return false;
-        }
-    }
-    for (const name of Object.keys(previousBins)) {
-        if (name in bins)
-            continue;
-        const link = path.join(binDir, name);
-        try {
-            if (fs.lstatSync(link).isSymbolicLink() && ownedByHqCli(link))
-                fs.unlinkSync(link);
-        }
-        catch {
-            // Already gone, or not ours to remove.
-        }
-    }
-    return true;
-}
-function symlinkTarget(link) {
-    try {
-        return fs.lstatSync(link).isSymbolicLink() ? fs.readlinkSync(link) : null;
-    }
-    catch {
-        return null;
-    }
-}
-function resolvesToFile(link) {
-    try {
-        return fs.statSync(link).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function resolvesToPackageBin(link, packageRoot, target) {
-    try {
-        return fs.lstatSync(link).isSymbolicLink() &&
-            fs.realpathSync(link) === fs.realpathSync(path.resolve(packageRoot, target)) &&
-            fs.statSync(link).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function readBins(packageRoot) {
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
-        if (typeof pkg.bin === "string")
-            return { hq: pkg.bin };
-        if (pkg.bin && typeof pkg.bin === "object") {
-            return Object.fromEntries(Object.entries(pkg.bin).filter(([, target]) => typeof target === "string"));
-        }
-    }
-    catch {
-        // An unreadable manifest declares no bins.
-    }
-    return {};
-}
-function probeHqVersion(packageRoot, env) {
-    const bin = readBins(packageRoot).hq ?? "dist/index.js";
-    const result = spawnSync(process.execPath, [path.join(packageRoot, bin), "--version"], {
-        encoding: "utf8",
-        env: { ...env, HQ_NO_UPDATE_CHECK: "1" },
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: PROBE_TIMEOUT_MS,
-        windowsHide: true,
-    });
-    if (result.status !== 0)
-        return null;
-    const lines = (result.stdout ?? "").trim().split(/\r?\n/);
-    return lines[lines.length - 1]?.trim() || null;
-}
-function runPackagePostinstall(packageRoot, env) {
-    let script;
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
-        script = pkg.scripts?.postinstall;
-    }
-    catch {
-        return;
-    }
-    if (typeof script !== "string" || script.trim() === "")
-        return;
-    const childEnv = { ...env };
-    delete childEnv[STAGED_INSTALL_ENV];
-    spawnSync(script, {
-        cwd: packageRoot,
-        env: childEnv,
-        shell: true,
-        stdio: "ignore",
-        timeout: POSTINSTALL_TIMEOUT_MS,
-        windowsHide: true,
-    });
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-//# sourceMappingURL=staged-install.js.map

package/dist/utils/staged-npm-install.d.ts

@@ -1,16 +0,0 @@
-export type StagedInstallResult = {
-    ok: boolean;
-    detail?: string;
-    code?: string;
-};
-export type StagedInstallRunner = (command: string, args: string[], env?: NodeJS.ProcessEnv) => StagedInstallResult;
-/**
- * Build hq-cli in a space-free temporary npm prefix, then replace the package
- * and its executable links under the real prefix only after npm succeeds.
- * Existing files are held beside their destinations until activation completes,
- * so failed installs and failed activation restore the prior working tree.
- */
-export declare function installNpmPackageStaged(prefix: string, packageSpec: string, runner: StagedInstallRunner, platform?: NodeJS.Platform, activate?: typeof activateStagedNpmPackage): StagedInstallResult;
-/** Atomically replace a package already built under a temporary npm prefix. */
-export declare function activateStagedNpmPackage(prefix: string, stagePrefix: string, platform?: NodeJS.Platform): StagedInstallResult;
-//# sourceMappingURL=staged-npm-install.d.ts.map

package/dist/utils/staged-npm-install.js

@@ -1,264 +0,0 @@
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, symlinkSync, writeFileSync, } from "node:fs";
-import { randomBytes } from "node:crypto";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const PACKAGE_NAME = "@indigoai-us/hq-cli";
-const RANDOM_HEX_BYTES = 6;
-function packageRoot(prefix, platform) {
-    const modules = platform === "win32"
-        ? path.join(prefix, "node_modules")
-        : path.join(prefix, "lib", "node_modules");
-    return path.join(modules, "@indigoai-us", "hq-cli");
-}
-function binsFromPackageJson(packageDir) {
-    const parsed = JSON.parse(readFileSync(path.join(packageDir, "package.json"), "utf8"));
-    if (parsed.name !== PACKAGE_NAME)
-        throw new Error("staged npm package name did not match hq-cli");
-    const bins = typeof parsed.bin === "string"
-        ? { hq: parsed.bin }
-        : parsed.bin && typeof parsed.bin === "object" && !Array.isArray(parsed.bin)
-            ? parsed.bin
-            : {};
-    for (const [name, target] of Object.entries(bins)) {
-        if (!name || name === "." || name === ".." || /[\\/]/.test(name)) {
-            throw new Error(`invalid executable name in staged package: ${name}`);
-        }
-        if (typeof target !== "string" || path.isAbsolute(target)) {
-            throw new Error(`invalid executable target in staged package: ${name}`);
-        }
-        const resolved = path.resolve(packageDir, target);
-        if (resolved !== packageDir && !resolved.startsWith(`${packageDir}${path.sep}`)) {
-            throw new Error(`executable target escapes staged package: ${name}`);
-        }
-    }
-    return bins;
-}
-function oldBinNames(packageDir) {
-    try {
-        return Object.keys(binsFromPackageJson(packageDir));
-    }
-    catch {
-        return [];
-    }
-}
-function temporaryRoot() {
-    const candidates = [os.tmpdir(), process.platform === "win32" ? `${process.env.SystemDrive ?? "C:"}\\Temp` : "/tmp"];
-    const root = candidates.find((candidate) => !/\s/.test(candidate) && existsSync(candidate));
-    if (!root)
-        throw new Error("no writable temporary directory without spaces is available");
-    return mkdtempSync(path.join(root, "hq-cli-update-"));
-}
-function randomSuffix() {
-    return randomBytes(RANDOM_HEX_BYTES).toString("hex");
-}
-function bestEffortRemove(target) {
-    if (!target)
-        return;
-    try {
-        rmSync(target, { recursive: true, force: true });
-    }
-    catch (error) {
-        console.warn("[hq-cli-update] could not remove staged install artifact", {
-            path: target,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-/**
- * Build hq-cli in a space-free temporary npm prefix, then replace the package
- * and its executable links under the real prefix only after npm succeeds.
- * Existing files are held beside their destinations until activation completes,
- * so failed installs and failed activation restore the prior working tree.
- */
-export function installNpmPackageStaged(prefix, packageSpec, runner, platform = process.platform, activate = activateStagedNpmPackage) {
-    let stagePrefix;
-    try {
-        stagePrefix = temporaryRoot();
-        const npmResult = runner("npm", ["install", "-g", "--prefix", stagePrefix, packageSpec], { ...process.env, HQ_STAGED_INSTALL: "1" });
-        if (!npmResult.ok)
-            return npmResult;
-        const activation = activate(prefix, stagePrefix, platform);
-        if (activation.ok || activation.code !== "EACCES" || platform === "win32")
-            return activation;
-        // A spaced, root-owned npm prefix must still be buildable without passing
-        // that prefix to npm/node-gyp. Re-run only the filesystem activation as
-        // root; the package build remains in the space-free user-owned temp path.
-        const elevated = runner("sudo", [
-            "-n",
-            "npm",
-            "exec",
-            "--",
-            process.execPath,
-            fileURLToPath(import.meta.url),
-            "--activate",
-            prefix,
-            stagePrefix,
-            platform,
-        ]);
-        return elevated.ok
-            ? { ok: true }
-            : {
-                ...elevated,
-                detail: elevated.detail ?? "could not activate the staged npm install with sudo",
-            };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            detail: error instanceof Error ? error.message : String(error),
-            code: error?.code,
-        };
-    }
-    finally {
-        bestEffortRemove(stagePrefix);
-    }
-}
-/** Atomically replace a package already built under a temporary npm prefix. */
-export function activateStagedNpmPackage(prefix, stagePrefix, platform = process.platform) {
-    let candidatePackage;
-    let stagedBins;
-    let backupBins;
-    let backupPackage;
-    let packageBackedUp = false;
-    let packageActivated = false;
-    const backedUpBins = [];
-    const activatedBins = [];
-    try {
-        const stagedPackage = packageRoot(stagePrefix, platform);
-        const targetPackage = packageRoot(prefix, platform);
-        const stageBinDir = platform === "win32" ? stagePrefix : path.join(stagePrefix, "bin");
-        const targetBinDir = platform === "win32" ? prefix : path.join(prefix, "bin");
-        const bins = binsFromPackageJson(stagedPackage);
-        const suffix = randomSuffix();
-        const targetScopeDir = path.dirname(targetPackage);
-        mkdirSync(targetScopeDir, { recursive: true });
-        mkdirSync(targetBinDir, { recursive: true });
-        candidatePackage = path.join(targetScopeDir, `.hq-cli-next-${suffix}`);
-        cpSync(stagedPackage, candidatePackage, { recursive: true, verbatimSymlinks: true });
-        stagedBins = path.join(targetBinDir, `.hq-cli-bins-next-${suffix}`);
-        backupBins = path.join(targetBinDir, `.hq-cli-bins-backup-${suffix}`);
-        mkdirSync(stagedBins);
-        mkdirSync(backupBins);
-        backupPackage = path.join(targetScopeDir, `.hq-cli-backup-${suffix}`);
-        const names = new Set([...Object.keys(bins), ...oldBinNames(targetPackage)]);
-        for (const name of names) {
-            const entry = bins[name];
-            if (entry === undefined)
-                continue;
-            const executable = path.join(targetPackage, entry);
-            if (platform === "win32") {
-                for (const extension of ["", ".cmd", ".ps1"]) {
-                    const stagedFile = path.join(stageBinDir, `${name}${extension}`);
-                    if (!existsSync(stagedFile))
-                        continue;
-                    const stagedText = readFileSync(stagedFile, "utf8");
-                    const relocated = stagedText
-                        .split(stagePrefix).join(prefix)
-                        .split(stagePrefix.replace(/\\/g, "/")).join(prefix.replace(/\\/g, "/"));
-                    writeFileSync(path.join(stagedBins, `${name}${extension}`), relocated, {
-                        mode: extension === ".cmd" || extension === "" ? 0o755 : 0o644,
-                    });
-                }
-            }
-            else {
-                const stagedFile = path.join(stageBinDir, name);
-                if (!existsSync(stagedFile))
-                    throw new Error(`npm did not create the ${name} executable link`);
-                if (!existsSync(executable))
-                    throw new Error(`staged executable target is missing for ${name}`);
-                symlinkSync(path.relative(targetBinDir, executable), path.join(stagedBins, name));
-            }
-        }
-        if (existsSync(targetPackage)) {
-            renameSync(targetPackage, backupPackage);
-            packageBackedUp = true;
-        }
-        renameSync(candidatePackage, targetPackage);
-        packageActivated = true;
-        for (const name of names) {
-            for (const extension of platform === "win32" ? ["", ".cmd", ".ps1"] : [""]) {
-                const filename = `${name}${extension}`;
-                const target = path.join(targetBinDir, filename);
-                const staged = path.join(stagedBins, filename);
-                if (existsSync(target) || lstatExists(target)) {
-                    const backup = path.join(backupBins, filename);
-                    renameSync(target, backup);
-                    backedUpBins.push({ target, backup });
-                }
-                if (existsSync(staged) || lstatExists(staged)) {
-                    renameSync(staged, target);
-                    activatedBins.push(target);
-                }
-            }
-        }
-        bestEffortRemove(packageBackedUp ? backupPackage : undefined);
-        bestEffortRemove(backupBins);
-        return { ok: true };
-    }
-    catch (error) {
-        for (const target of activatedBins.reverse())
-            bestEffortRemove(target);
-        for (const item of backedUpBins.reverse()) {
-            if (existsSync(item.backup) || lstatExists(item.backup)) {
-                try {
-                    renameSync(item.backup, item.target);
-                }
-                catch (restoreError) {
-                    console.error("[hq-cli-update] could not restore previous executable link", {
-                        path: item.target,
-                        error: restoreError instanceof Error ? restoreError.message : String(restoreError),
-                    });
-                }
-            }
-        }
-        if (packageActivated)
-            bestEffortRemove(packageRoot(prefix, platform));
-        if (packageBackedUp && backupPackage && existsSync(backupPackage)) {
-            try {
-                renameSync(backupPackage, packageRoot(prefix, platform));
-            }
-            catch (restoreError) {
-                console.error("[hq-cli-update] could not restore previous package", {
-                    path: packageRoot(prefix, platform),
-                    error: restoreError instanceof Error ? restoreError.message : String(restoreError),
-                });
-            }
-        }
-        return {
-            ok: false,
-            detail: error instanceof Error ? error.message : String(error),
-            code: error?.code,
-        };
-    }
-    finally {
-        bestEffortRemove(candidatePackage);
-        bestEffortRemove(stagedBins);
-        bestEffortRemove(backupBins);
-        if (!packageBackedUp)
-            bestEffortRemove(backupPackage);
-    }
-}
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url) && process.argv[2] === "--activate") {
-    const [prefix, stagePrefix, platform] = process.argv.slice(3);
-    if (!prefix || !stagePrefix) {
-        console.error("usage: staged-npm-install.js --activate <prefix> <stage-prefix> [platform]");
-        process.exit(2);
-    }
-    else {
-        const result = activateStagedNpmPackage(prefix, stagePrefix, platform || process.platform);
-        if (!result.ok)
-            console.error(result.detail ?? "staged npm activation failed");
-        process.exit(result.ok ? 0 : 1);
-    }
-}
-function lstatExists(target) {
-    try {
-        lstatSync(target);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=staged-npm-install.js.map

package/dist/utils/sync-log-sources.d.ts

@@ -1,15 +0,0 @@
-/** Stable relative names used for feedback attachments. */
-export declare const SYNC_LOG_RELATIVE_PATHS: {
-    readonly desktop: "logs/hq-sync.log";
-    readonly daemon: "daemon/logs/sync.log";
-};
-export type SyncLogFamily = keyof typeof SYNC_LOG_RELATIVE_PATHS;
-/** Read the active file plus the three retained rotations. */
-export declare const SYNC_LOG_GENERATIONS = 4;
-/** Resolve both sync-log families, honoring the daemon's configured root. */
-export declare function syncLogBasePaths(hqDir: string, env?: NodeJS.ProcessEnv): Record<SyncLogFamily, string>;
-export declare function syncLogGenerationPath(basePath: string, generation: number): string;
-export declare function syncLogFamilyForRelativePath(name: string): SyncLogFamily | null;
-/** Choose the most recently written family; desktop wins a timestamp tie. */
-export declare function currentSyncLogFamily(desktopModifiedMs: number | null, daemonModifiedMs: number | null): SyncLogFamily | null;
-//# sourceMappingURL=sync-log-sources.d.ts.map