@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/utils/staged-install.js

@@ -0,0 +1,346 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,264 @@
+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

@@ -0,0 +1,15 @@
+/** 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

package/dist/utils/sync-log-sources.js

@@ -0,0 +1,36 @@
+import * as path from "node:path";
+import { daemonPaths } from "../lib/daemon/paths.js";
+/** Stable relative names used for feedback attachments. */
+export const SYNC_LOG_RELATIVE_PATHS = {
+    desktop: "logs/hq-sync.log",
+    daemon: "daemon/logs/sync.log",
+};
+/** Read the active file plus the three retained rotations. */
+export const SYNC_LOG_GENERATIONS = 4;
+/** Resolve both sync-log families, honoring the daemon's configured root. */
+export function syncLogBasePaths(hqDir, env = process.env) {
+    const daemonLogDir = daemonPaths(path.dirname(hqDir), env).logsDir;
+    return {
+        desktop: path.join(hqDir, SYNC_LOG_RELATIVE_PATHS.desktop),
+        daemon: path.join(daemonLogDir, "sync.log"),
+    };
+}
+export function syncLogGenerationPath(basePath, generation) {
+    return generation === 0 ? basePath : `${basePath}.${generation}`;
+}
+export function syncLogFamilyForRelativePath(name) {
+    if (/^logs\/hq-sync\.log(?:\.\d+)?$/.test(name))
+        return "desktop";
+    if (/^daemon\/logs\/sync\.log(?:\.\d+)?$/.test(name))
+        return "daemon";
+    return null;
+}
+/** Choose the most recently written family; desktop wins a timestamp tie. */
+export function currentSyncLogFamily(desktopModifiedMs, daemonModifiedMs) {
+    if (desktopModifiedMs === null)
+        return daemonModifiedMs === null ? null : "daemon";
+    if (daemonModifiedMs === null)
+        return "desktop";
+    return daemonModifiedMs > desktopModifiedMs ? "daemon" : "desktop";
+}
+//# sourceMappingURL=sync-log-sources.js.map

package/dist/utils/table-width.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Return the largest measured cell length without passing an unbounded number
+ * of values as function arguments. Large vault tables can contain hundreds of
+ * thousands of rows, beyond the argument limit of Math.max(...values).
+ */
+export declare function maxLength<T>(values: Iterable<T>, measure: (value: T) => number, floor: number): number;
+//# sourceMappingURL=table-width.d.ts.map