looply-cli 0.5.7 → 0.5.9

package/dist/machine-settings.js

@@ -0,0 +1,658 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultWorkspacesBase = exports.USAGE_MAX_AGE_MS = exports.WORKSPACES_DIR = exports.CHECKOUTS_USAGE_FILE = exports.WORKSPACES_BASES_FILE = exports.REMOTE_MACHINE_SETTINGS_FILE = exports.MACHINE_SETTINGS_FILE = exports.DEFAULT_MIN_FREE_GB = void 0;
+exports.readLocalMachineSettings = readLocalMachineSettings;
+exports.readRemoteMachineSettings = readRemoteMachineSettings;
+exports.writeRemoteMachineSettings = writeRemoteMachineSettings;
+exports.nodeDriveKind = nodeDriveKind;
+exports.nodeProbeWritable = nodeProbeWritable;
+exports.checkoutFolderProblem = checkoutFolderProblem;
+exports.effectiveWorkspaces = effectiveWorkspaces;
+exports.rememberWorkspacesBase = rememberWorkspacesBase;
+exports.knownWorkspacesBases = knownWorkspacesBases;
+exports.freeGbAt = freeGbAt;
+exports.bytesUnder = bytesUnder;
+exports.measureCheckouts = measureCheckouts;
+exports.readCheckoutsUsage = readCheckoutsUsage;
+exports.refreshCheckoutsUsage = refreshCheckoutsUsage;
+exports.checkoutRoomProblem = checkoutRoomProblem;
+exports.workspacesReport = workspacesReport;
+exports.makeMachineSettingsPull = makeMachineSettingsPull;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const core_1 = require("@looply/core");
+Object.defineProperty(exports, "DEFAULT_MIN_FREE_GB", { enumerable: true, get: function () { return core_1.DEFAULT_MIN_FREE_GB; } });
+const server_client_1 = require("./server-client");
+const untrusted_exec_1 = require("./untrusted-exec");
+exports.MACHINE_SETTINGS_FILE = 'machine-settings.json';
+exports.REMOTE_MACHINE_SETTINGS_FILE = 'machine-settings-remote.json';
+exports.WORKSPACES_BASES_FILE = 'workspaces-bases.json';
+exports.CHECKOUTS_USAGE_FILE = 'checkouts-usage.json';
+exports.WORKSPACES_DIR = 'workspaces';
+/** How long a usage measurement is trusted before it is taken again. */
+exports.USAGE_MAX_AGE_MS = 10 * 60_000;
+/** How long a measurement in progress keeps other daemons from starting their own. */
+const USAGE_CLAIM_MS = 5 * 60_000;
+/** A refused remote folder is looked at again this often, so fixing the drive heals it. */
+const REFUSED_RECHECK_MS = 5 * 60_000;
+const GB = 1e9;
+const looplyHome = (home) => (0, node_path_1.join)(home, '.looply');
+const defaultWorkspacesBase = (home = (0, node_os_1.homedir)()) => (0, node_path_1.join)(looplyHome(home), exports.WORKSPACES_DIR);
+exports.defaultWorkspacesBase = defaultWorkspacesBase;
+/** Atomic: a reader never sees half a file, and many daemons may write the same answer. */
+function writeJson(file, value) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${Math.floor(Math.random() * 1e9).toString(36)}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(value, null, 2) + '\n', 'utf8');
+    try {
+        (0, node_fs_1.renameSync)(tmp, file);
+    }
+    catch (e) {
+        try {
+            (0, node_fs_1.unlinkSync)(tmp);
+        }
+        catch {
+            /* already gone */
+        }
+        throw e;
+    }
+}
+function readJson(file) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * `~/.looply/machine-settings.json`, checked. Absent is `{}`.
+ *
+ * ⚠️ AN UNUSABLE LOCAL SETTING THROWS, as it did in 0.5.7: falling back to the
+ * home drive silently is the exact outcome the setting exists to prevent, and a
+ * person wrote this file on this machine and can fix it.
+ */
+function readLocalMachineSettings(home = (0, node_os_1.homedir)()) {
+    const file = (0, node_path_1.join)(looplyHome(home), exports.MACHINE_SETTINGS_FILE);
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(file, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return {};
+        throw e;
+    }
+    let o;
+    try {
+        const parsed = JSON.parse(raw);
+        o = typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch {
+        throw new Error(`${file} is not valid JSON, so where checkouts go is unknown`);
+    }
+    const out = {};
+    if (o['workspacesRoot'] !== undefined) {
+        const v = o['workspacesRoot'];
+        if (typeof v !== 'string' || !(0, node_path_1.isAbsolute)(v))
+            throw new Error(`${file}: "workspacesRoot" must be an absolute path`);
+        out.workspacesRoot = v;
+    }
+    if (o['minFreeGb'] !== undefined) {
+        const v = o['minFreeGb'];
+        if (typeof v !== 'number' || !Number.isFinite(v) || v < 0) {
+            throw new Error(`${file}: "minFreeGb" must be a number of GB, 0 or more`);
+        }
+        out.minFreeGb = v;
+    }
+    if (o['checkoutsCapGb'] !== undefined && o['checkoutsCapGb'] !== null) {
+        const v = o['checkoutsCapGb'];
+        if (typeof v !== 'number' || !Number.isFinite(v) || v <= 0) {
+            throw new Error(`${file}: "checkoutsCapGb" must be a number of GB above 0`);
+        }
+        out.checkoutsCapGb = v;
+    }
+    return out;
+}
+function readRemoteMachineSettings(home = (0, node_os_1.homedir)()) {
+    const raw = readJson((0, node_path_1.join)(looplyHome(home), exports.REMOTE_MACHINE_SETTINGS_FILE));
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const r = raw;
+    // Re-validated on every read with the server's own rule, so a hand-edited
+    // or corrupted file cannot point checkouts somewhere the server would refuse.
+    const v = (0, core_1.validateMachineSettings)(r['settings']);
+    if (!v.ok)
+        return null;
+    const inEffect = typeof r['inEffect'] === 'string' && (0, core_1.folderShapeProblem)(r['inEffect']) === null ? r['inEffect'] : null;
+    const vr = r['verdict'];
+    const verdict = vr && typeof vr === 'object' && typeof vr['value'] === 'string' && typeof vr['ok'] === 'boolean'
+        ? {
+            value: vr['value'],
+            ok: vr['ok'],
+            because: typeof vr['because'] === 'string' ? vr['because'] : null,
+            checkedAt: typeof vr['checkedAt'] === 'string' ? vr['checkedAt'] : '',
+        }
+        : null;
+    return {
+        settings: v.settings,
+        updatedAt: typeof r['updatedAt'] === 'string' ? r['updatedAt'] : null,
+        fetchedAt: typeof r['fetchedAt'] === 'string' ? r['fetchedAt'] : '',
+        inEffect,
+        verdict,
+    };
+}
+function writeRemoteMachineSettings(home, value) {
+    writeJson((0, node_path_1.join)(looplyHome(home), exports.REMOTE_MACHINE_SETTINGS_FILE), value);
+}
+/**
+ * What kind of drive `path` is on. Windows only asks; elsewhere every local
+ * path is answered `fixed` (a POSIX machine has no drive letters to judge).
+ */
+function nodeDriveKind(path, platform = process.platform) {
+    if (platform !== 'win32')
+        return 'fixed';
+    const letter = /^([A-Za-z]):/.exec(path)?.[1];
+    if (letter === undefined)
+        return 'unknown';
+    try {
+        // By absolute path: a bare name would let the working directory supply it.
+        const out = (0, node_child_process_1.execFileSync)((0, untrusted_exec_1.powershellPath)(), [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            `$d = New-Object System.IO.DriveInfo '${letter.toUpperCase()}'; if ($d.IsReady -or $d.DriveType -ne 'NoRootDirectory') { $d.DriveType } else { 'Missing' }`,
+        ], { encoding: 'utf8', timeout: 15_000, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] }).trim().toLowerCase();
+        if (out === 'fixed')
+            return 'fixed';
+        if (out === 'removable')
+            return 'removable';
+        if (out === 'network')
+            return 'network';
+        if (out === 'cdrom')
+            return 'cdrom';
+        if (out === 'ram')
+            return 'ram';
+        if (out === 'missing' || out === 'norootdirectory')
+            return 'missing';
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function nodeProbeWritable(path) {
+    (0, node_fs_1.mkdirSync)(path, { recursive: true });
+    const probe = (0, node_path_1.join)(path, `.looply-write-check-${process.pid}`);
+    (0, node_fs_1.writeFileSync)(probe, 'ok', 'utf8');
+    (0, node_fs_1.unlinkSync)(probe);
+}
+/** Case-folded and resolved on Windows, so `d:\X` and `D:\x\` compare equal. */
+function norm(p, platform) {
+    const path = platform === 'win32' ? node_path_1.win32 : node_path_1.posix;
+    let r = path.resolve(p);
+    if (r.length > path.parse(r).root.length)
+        r = r.replace(/[\\/]+$/, '');
+    return platform === 'win32' ? r.toLowerCase() : r;
+}
+function within(parent, child, platform) {
+    const sep = platform === 'win32' ? '\\' : '/';
+    const p = norm(parent, platform);
+    const c = norm(child, platform);
+    return c === p || c.startsWith(p.endsWith(sep) ? p : p + sep);
+}
+/** Folders that belong to the operating system or to programs, never to checkouts. */
+function systemFolders(platform, env, home) {
+    if (platform === 'win32') {
+        const sysDrive = (env['SystemDrive'] ?? 'C:') + '\\';
+        return [
+            env['SystemRoot'] ?? env['windir'] ?? node_path_1.win32.join(sysDrive, 'Windows'),
+            env['ProgramFiles'] ?? node_path_1.win32.join(sysDrive, 'Program Files'),
+            env['ProgramFiles(x86)'] ?? node_path_1.win32.join(sysDrive, 'Program Files (x86)'),
+            env['ProgramW6432'] ?? node_path_1.win32.join(sysDrive, 'Program Files'),
+            env['ProgramData'] ?? node_path_1.win32.join(sysDrive, 'ProgramData'),
+            node_path_1.win32.join(sysDrive, '$Recycle.Bin'),
+            node_path_1.win32.join(sysDrive, 'System Volume Information'),
+            node_path_1.win32.join(sysDrive, 'Recovery'),
+            node_path_1.win32.join(home, 'AppData'),
+        ];
+    }
+    return ['/bin', '/boot', '/dev', '/etc', '/lib', '/lib64', '/proc', '/sbin', '/sys', '/usr', '/var', '/System', '/Library', '/Applications', '/private'];
+}
+/**
+ * Why `folder` may not hold this machine's checkouts, or null when it may.
+ * The answer is the sentence the console and the ticket show.
+ */
+function checkoutFolderProblem(folder, deps) {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const path = platform === 'win32' ? node_path_1.win32 : node_path_1.posix;
+    const shape = (0, core_1.folderShapeProblem)(folder);
+    if (shape !== null)
+        return `the checkout folder ${folder} ${shape}`;
+    if (!path.isAbsolute(folder) || (platform === 'win32' && !/^[A-Za-z]:[\\/]/.test(folder))) {
+        return `the checkout folder ${folder} is not an absolute path on this machine`;
+    }
+    const resolved = path.resolve(folder);
+    if (norm(resolved, platform) === norm(path.parse(resolved).root, platform)) {
+        return `the checkout folder ${folder} is a whole drive; choose a folder on it, like ${path.join(resolved, 'looply', 'workspaces')}`;
+    }
+    // The default folder is the one place inside ~/.looply a checkout may live.
+    const isDefault = norm(resolved, platform) === norm((0, exports.defaultWorkspacesBase)(deps.home), platform);
+    if (!isDefault && within(looplyHome(deps.home), resolved, platform)) {
+        return `the checkout folder ${folder} is inside Looply's own state (${looplyHome(deps.home)})`;
+    }
+    for (const sys of systemFolders(platform, env, deps.home)) {
+        if (within(sys, resolved, platform))
+            return `the checkout folder ${folder} is inside a system folder (${sys})`;
+    }
+    if (norm(resolved, platform) === norm(deps.home, platform) || norm(resolved, platform) === norm(path.dirname(deps.home), platform)) {
+        return `the checkout folder ${folder} is a home folder itself; choose a folder for checkouts only`;
+    }
+    for (const served of deps.servedPaths) {
+        if (within(served, resolved, platform)) {
+            return `the checkout folder ${folder} is inside ${served}, which this machine serves; checkouts there would be mistaken for its files`;
+        }
+        if (within(resolved, served, platform)) {
+            return `the checkout folder ${folder} contains ${served}, which this machine serves; choose a folder for checkouts only`;
+        }
+    }
+    const kind = (deps.driveKind ?? ((p) => nodeDriveKind(p, platform)))(resolved);
+    if (kind === 'missing')
+        return `the drive of ${folder} does not exist on this machine`;
+    if (kind !== 'fixed') {
+        return `the checkout folder ${folder} is on a ${kind === 'unknown' ? 'drive whose kind could not be read' : `${kind} drive`}; checkouts need a local fixed drive`;
+    }
+    try {
+        (deps.probeWritable ?? nodeProbeWritable)(resolved);
+    }
+    catch (e) {
+        return `the checkout folder ${folder} could not be created or written (${e.code ?? e.message})`;
+    }
+    return null;
+}
+/**
+ * What applies right now, from the three sources in order. Reads two small
+ * files; never asks the server and never checks a folder (the pull did that).
+ */
+function effectiveWorkspaces(home = (0, node_os_1.homedir)(), env = process.env) {
+    const local = readLocalMachineSettings(home);
+    const remote = readRemoteMachineSettings(home);
+    let base;
+    let source;
+    const fromEnv = env['LOOPLY_WORKSPACES_ROOT'];
+    if (fromEnv !== undefined && fromEnv !== '') {
+        if (!(0, node_path_1.isAbsolute)(fromEnv))
+            throw new Error('LOOPLY_WORKSPACES_ROOT must be an absolute path');
+        base = fromEnv;
+        source = 'local';
+    }
+    else if (local.workspacesRoot !== undefined) {
+        base = local.workspacesRoot;
+        source = 'local';
+    }
+    else if (remote?.inEffect) {
+        base = remote.inEffect;
+        source = 'remote';
+    }
+    else {
+        base = (0, exports.defaultWorkspacesBase)(home);
+        source = 'default';
+    }
+    // Said only while the remote folder is what WOULD apply: a local override
+    // makes the remote folder irrelevant, not refused.
+    let refused = null;
+    const wanted = remote?.settings.workspacesRoot ?? null;
+    if (source !== 'local' && wanted !== null && remote?.verdict?.value === wanted && !remote.verdict.ok) {
+        refused = `${remote.verdict.because ?? 'the remote checkout folder was refused'} — new checkouts stay in ${base}`;
+    }
+    return {
+        base,
+        source,
+        refused,
+        minFreeGb: local.minFreeGb ?? remote?.settings.minFreeGb ?? core_1.DEFAULT_MIN_FREE_GB,
+        capGb: local.checkoutsCapGb ?? remote?.settings.checkoutsCapGb ?? null,
+    };
+}
+/* ─────────────────────────────────────────────── every folder ever used ── */
+/**
+ * Remember that checkouts are being made under `base`, so a later change of
+ * folder does not hide them from the reaper. Idempotent; never throws.
+ */
+function rememberWorkspacesBase(base, home = (0, node_os_1.homedir)()) {
+    try {
+        const known = knownWorkspacesBases(home, false);
+        const key = norm(base, process.platform);
+        if (known.some((b) => norm(b, process.platform) === key))
+            return;
+        writeJson((0, node_path_1.join)(looplyHome(home), exports.WORKSPACES_BASES_FILE), { bases: [...known, (0, node_path_1.resolve)(base)] });
+    }
+    catch {
+        /* forgetting a base costs a manual reap later, never a checkout now */
+    }
+}
+/**
+ * Every folder checkouts may sit in: the current one first, then every one
+ * remembered, then the default. Only folders that exist are returned unless
+ * `existingOnly` is false.
+ */
+function knownWorkspacesBases(home = (0, node_os_1.homedir)(), includeCurrent = true) {
+    const out = [];
+    const seen = new Set();
+    const add = (b) => {
+        const key = norm(b, process.platform);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push(b);
+    };
+    if (includeCurrent) {
+        try {
+            add(effectiveWorkspaces(home).base);
+        }
+        catch {
+            /* an unusable current setting still leaves the remembered ones */
+        }
+    }
+    const raw = readJson((0, node_path_1.join)(looplyHome(home), exports.WORKSPACES_BASES_FILE));
+    if (raw && Array.isArray(raw.bases)) {
+        for (const b of raw.bases)
+            if (typeof b === 'string' && (0, node_path_1.isAbsolute)(b))
+                add(b);
+    }
+    if (includeCurrent)
+        add((0, exports.defaultWorkspacesBase)(home));
+    return out;
+}
+/** Free GB on the drive that holds `dir` (or its nearest existing parent). */
+function freeGbAt(dir) {
+    let at = (0, node_path_1.resolve)(dir);
+    for (;;) {
+        try {
+            const s = (0, node_fs_1.statfsSync)(at);
+            return (Number(s.bavail) * Number(s.bsize)) / GB;
+        }
+        catch {
+            const up = (0, node_path_1.dirname)(at);
+            if (up === at)
+                return null;
+            at = up;
+        }
+    }
+}
+/**
+ * Bytes under `dir`, walking without following links (a carried
+ * `node_modules` link must not count its target, and a junction must not walk
+ * the user's repository). Yields to the event loop as it goes, so a daemon's
+ * heartbeat is never held by a big tree.
+ */
+async function bytesUnder(dir) {
+    let total = 0;
+    const stack = [dir];
+    while (stack.length > 0) {
+        const d = stack.pop();
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(d, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const p = (0, node_path_1.join)(d, e.name);
+            if (e.isSymbolicLink())
+                continue;
+            if (e.isDirectory()) {
+                stack.push(p);
+                continue;
+            }
+            try {
+                total += (await (0, promises_1.lstat)(p)).size;
+            }
+            catch {
+                /* vanished */
+            }
+        }
+    }
+    return total;
+}
+/**
+ * Measure every checkout under every known folder: `<base>/<project key>/<checkout>`.
+ * Junction/symlink entries are not followed (see `bytesUnder`).
+ */
+async function measureCheckouts(bases, now = new Date()) {
+    let bytes = 0;
+    let checkouts = 0;
+    for (const base of bases) {
+        let projects;
+        try {
+            projects = await (0, promises_1.readdir)(base, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const p of projects) {
+            if (!p.isDirectory())
+                continue;
+            let names;
+            try {
+                names = await (0, promises_1.readdir)((0, node_path_1.join)(base, p.name), { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const n of names) {
+                if (!n.isDirectory())
+                    continue;
+                checkouts += 1;
+                bytes += await bytesUnder((0, node_path_1.join)(base, p.name, n.name));
+            }
+        }
+    }
+    return { usedGb: bytes / GB, checkouts, measuredAt: now.toISOString() };
+}
+function readCheckoutsUsage(home = (0, node_os_1.homedir)()) {
+    const raw = readJson((0, node_path_1.join)(looplyHome(home), exports.CHECKOUTS_USAGE_FILE));
+    if (!raw || typeof raw['usedGb'] !== 'number' || typeof raw['measuredAt'] !== 'string')
+        return null;
+    return {
+        usedGb: raw['usedGb'],
+        checkouts: typeof raw['checkouts'] === 'number' ? raw['checkouts'] : 0,
+        measuredAt: raw['measuredAt'],
+    };
+}
+/**
+ * Measure again when the last measurement is older than `maxAgeMs`. Many
+ * daemons share this machine, so one claims the measurement and the others
+ * use what is there. Never throws.
+ */
+async function refreshCheckoutsUsage(home = (0, node_os_1.homedir)(), opts = {}) {
+    const now = opts.now ?? (() => Date.now());
+    const maxAge = opts.maxAgeMs ?? exports.USAGE_MAX_AGE_MS;
+    const file = (0, node_path_1.join)(looplyHome(home), exports.CHECKOUTS_USAGE_FILE);
+    const current = readCheckoutsUsage(home);
+    if (current !== null && now() - Date.parse(current.measuredAt) < maxAge)
+        return current;
+    const raw = readJson(file);
+    const since = typeof raw?.measuringSince === 'string' ? Date.parse(raw.measuringSince) : NaN;
+    if (Number.isFinite(since) && now() - since < USAGE_CLAIM_MS)
+        return current;
+    try {
+        writeJson(file, { ...(current ?? {}), measuringSince: new Date(now()).toISOString() });
+        const measured = await (opts.measure ?? measureCheckouts)(knownWorkspacesBases(home));
+        writeJson(file, measured);
+        return measured;
+    }
+    catch {
+        return current;
+    }
+}
+/**
+ * Why no new checkout may be made under `root` right now, or null when one may.
+ * Minimum free space first (the drive), then the cap (Looply's share of it).
+ * The answer is a sentence a person can act on, because it is what the run and
+ * the ticket say.
+ */
+function checkoutRoomProblem(root, eff, deps = {}) {
+    if (eff.minFreeGb > 0) {
+        const free = (deps.freeGb ?? freeGbAt)(root);
+        if (free !== null && free < eff.minFreeGb) {
+            return (`not enough disk space for a new checkout: ${free.toFixed(1)} GB free where checkouts go (${root}), ` +
+                `and at least ${eff.minFreeGb} GB must stay free. Free some space, reap old checkouts ` +
+                '(`looply runs --reap`), or move checkouts to another drive in the machine settings.');
+        }
+    }
+    if (eff.capGb !== null) {
+        const usage = deps.usage;
+        if (usage) {
+            const next = usage.checkouts > 0 ? usage.usedGb / usage.checkouts : 0;
+            if (usage.usedGb >= eff.capGb || usage.usedGb + next > eff.capGb) {
+                return (`checkouts already use ${usage.usedGb.toFixed(1)} GB of the ${eff.capGb} GB cap set for this machine` +
+                    (next > 0 ? ` (a new one needs about ${next.toFixed(1)} GB)` : '') +
+                    '. Let running work finish and old checkouts be reaped (`looply runs --reap`), or raise the cap in the machine settings.');
+            }
+        }
+    }
+    return null;
+}
+/** What the heartbeat says about checkouts. Never throws: presence is worth more. */
+function workspacesReport(home = (0, node_os_1.homedir)(), deps = {}) {
+    let eff;
+    try {
+        eff = effectiveWorkspaces(home);
+    }
+    catch (e) {
+        // An unusable LOCAL setting: no checkout can be made, and the owner should hear why.
+        return {
+            root: (0, exports.defaultWorkspacesBase)(home),
+            source: 'local',
+            freeGb: null,
+            usedGb: null,
+            refused: null,
+            blocked: `no new checkout can be made: ${e.message}`,
+        };
+    }
+    try {
+        const free = (deps.freeGb ?? freeGbAt)(eff.base);
+        const usage = deps.usage !== undefined ? deps.usage : readCheckoutsUsage(home);
+        const blocked = checkoutRoomProblem(eff.base, eff, { freeGb: () => free, usage });
+        const round = (n) => typeof n === 'number' && Number.isFinite(n) ? Math.round(n * 10) / 10 : null;
+        return {
+            root: (0, node_path_1.resolve)(eff.base),
+            source: eff.source,
+            freeGb: round(free),
+            usedGb: round(usage?.usedGb),
+            refused: eff.refused,
+            blocked,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * One pull: ask the server for this machine's settings, check a new folder on
+ * this machine, and write the cache. A failure keeps what the cache holds.
+ */
+function makeMachineSettingsPull(deps) {
+    const home = deps.home ?? (0, node_os_1.homedir)();
+    const now = deps.now ?? (() => Date.now());
+    const check = deps.checkFolder ?? checkoutFolderProblem;
+    let failureReported = false;
+    const reportOnce = (why) => {
+        if (failureReported)
+            return;
+        failureReported = true;
+        deps.log(`disk    : could not refresh this machine's checkout settings — ${why}`);
+    };
+    return async () => {
+        try {
+            return await pull();
+        }
+        finally {
+            try {
+                await (deps.refreshUsage ?? (() => refreshCheckoutsUsage(home)))();
+            }
+            catch {
+                /* a measurement is never a stopped daemon */
+            }
+        }
+    };
+    async function pull() {
+        let body;
+        try {
+            body = await deps.fetch();
+        }
+        catch (e) {
+            if (!(e instanceof server_client_1.ServerError && (e.isOffline || e.isAuth || e.status === 404)))
+                reportOnce(e.message);
+            return 'failed';
+        }
+        const b = body;
+        if (typeof b !== 'object' || b === null || !('settings' in b)) {
+            reportOnce('the server answered with something that is not a settings envelope');
+            return 'failed';
+        }
+        const v = (0, core_1.validateMachineSettings)(b.settings);
+        if (!v.ok) {
+            reportOnce(`the server sent settings this build refuses (${v.key}: ${v.because})`);
+            return 'failed';
+        }
+        failureReported = false;
+        const settings = v.settings;
+        const updatedAt = typeof b.updatedAt === 'string' ? b.updatedAt : null;
+        const before = readRemoteMachineSettings(home);
+        let inEffect = before?.inEffect ?? null;
+        let verdict = before?.verdict ?? null;
+        const wanted = settings.workspacesRoot;
+        if (wanted === null) {
+            inEffect = null;
+            verdict = null;
+        }
+        else {
+            const judged = verdict !== null && verdict.value === wanted;
+            const stale = judged && !verdict.ok && now() - (Date.parse(verdict.checkedAt) || 0) >= REFUSED_RECHECK_MS;
+            if (!judged || stale) {
+                let because;
+                try {
+                    because = check(wanted, { home, servedPaths: deps.servedPaths() });
+                }
+                catch (e) {
+                    because = `the checkout folder ${wanted} could not be checked (${e.message})`;
+                }
+                verdict = { value: wanted, ok: because === null, because, checkedAt: new Date(now()).toISOString() };
+                if (because === null) {
+                    inEffect = wanted;
+                    deps.log(`disk    : new checkouts go to ${wanted} (machine setting); checkouts already made stay where they are`);
+                }
+                else {
+                    // 🔴 THE PREVIOUS FOLDER STAYS. A refused folder must not send checkouts back to the home drive.
+                    deps.log(`disk    : refused the checkout folder from the machine settings — ${because}. Keeping ${inEffect ?? (0, exports.defaultWorkspacesBase)(home)}`);
+                }
+            }
+        }
+        const next = {
+            settings,
+            updatedAt,
+            fetchedAt: new Date(now()).toISOString(),
+            inEffect,
+            verdict,
+        };
+        const same = before !== null &&
+            JSON.stringify({ ...before, fetchedAt: '' }) === JSON.stringify({ ...next, fetchedAt: '' });
+        if (same)
+            return 'unchanged';
+        try {
+            writeRemoteMachineSettings(home, next);
+        }
+        catch (e) {
+            reportOnce(`the cache could not be written (${e.message})`);
+            return 'failed';
+        }
+        return 'updated';
+    }
+}
+//# sourceMappingURL=machine-settings.js.map