@join-pantheon/cli 0.32.1 → 0.33.0-rc.2

package/dist/store.js

@@ -8,13 +8,27 @@ export function ensurePrivateDir(dir) {
     }
     catch { }
 }
+let waitForDisk = true;
+let slowestWaitMs = 0;
+export function setWaitForDisk(on) { waitForDisk = on; }
+export function waitsForDisk() { return waitForDisk; }
+export function takeSlowestDiskWait() { const w = slowestWaitMs; slowestWaitMs = 0; return w; }
+export function syncFd(fd) {
+    if (!waitForDisk)
+        return;
+    const t = Date.now();
+    fsyncSync(fd);
+    const took = Date.now() - t;
+    if (took > slowestWaitMs)
+        slowestWaitMs = took;
+}
 export function writeFileAtomic(file, data, mode = 0o600) {
     mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
     const tmp = `${file}.tmp`;
     const fd = openSync(tmp, "w", mode);
     try {
         writeSync(fd, typeof data === "string" ? Buffer.from(data) : data);
-        fsyncSync(fd);
+        syncFd(fd);
     }
     finally {
         closeSync(fd);
@@ -42,10 +56,12 @@ export function renameRetrying(from, to, o = {}) {
     }
 }
 export function fsyncDir(dir) {
+    if (!waitForDisk)
+        return;
     let fd = null;
     try {
         fd = openSync(dir, "r");
-        fsyncSync(fd);
+        syncFd(fd);
     }
     catch { }
     finally {

package/dist/uninstall.js

@@ -5,7 +5,7 @@ import { posix, win32 } from "node:path";
 import { expectedLauncher } from "./managed.js";
 export const BEGIN_MARK = "# >>> pantheon >>>";
 export const END_MARK = "# <<< pantheon <<<";
-export const PROFILES = [".profile", ".bash_profile", ".bashrc", ".zshrc", ".zprofile"];
+export const PROFILES = [".profile", ".bash_profile", ".bash_login", ".bashrc", ".zshrc", ".zprofile"];
 export const FISH_CONF = ".config/fish/conf.d/pantheon.fish";
 export function withoutPathBlock(text) {
     const lines = text.match(/[^\n]*\n|[^\n]+$/g) ?? [];

package/dist/upgrade.js

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { installForUser } from "./install.js";
@@ -7,7 +7,8 @@ import { npmSpawn } from "./which.js";
 import { proxyEnvFor } from "./network.js";
 import { relayProc, workerProc, notifierProc, menubarProc } from "./machine.js";
 import { load } from "./config.js";
-import { childNodeFlags, installerLineHere, managedLayout, nodeSatisfies, nodeTooOldSentence, runtimeNodeVersion } from "./managed.js";
+import { compareVersions, INSTALLER_MIN_CLI, isVersion } from "./installer.js";
+import { childNodeFlags, installerLineHere, launcherWithRepair, managedLayout, nodeSatisfies, nodeTooOldSentence, runtimeNodeVersion } from "./managed.js";
 export function repoRoot() {
     return join(dirname(fileURLToPath(import.meta.url)), "..");
 }
@@ -86,6 +87,7 @@ export function defaultDeps() {
             return up;
         },
         npmUpgrade: (version) => npm(npmInstallArgs(version), { stdio: ["ignore", "pipe", "pipe"] }),
+        stagedUpgrade: (m, spec) => { stagedManagedUpgrade(m, spec); },
         npmLatest: () => {
             try {
                 return npm(["view", `${PKG_NAME}`, "version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 4000 }).trim() || null;
@@ -113,13 +115,16 @@ export function defaultDeps() {
     };
 }
 export function upgrade(deps = defaultDeps(), opts = {}) {
-    const spec = opts.version && /^\d+\.\d+\.\d+$/.test(opts.version) ? opts.version : "latest";
+    const spec = opts.version && isVersion(opts.version) ? opts.version : "latest";
     const { root } = deps;
     const from = deps.version(root);
     const steps = [];
     const stop = (name, detail) => ({ root, from, to: from, steps: [...steps, { name, ok: false, detail }], ok: false, alreadyCurrent: false, restart: [] });
     if (!deps.isGit(root)) {
         const managed = deps.managed === undefined ? managedLayout() : deps.managed;
+        if (managed && spec !== "latest" && compareVersions(spec, INSTALLER_MIN_CLI) < 0) {
+            return stop("check", `${spec} is older than this install supports (${INSTALLER_MIN_CLI} or newer): it could not upgrade itself again. Nothing was changed.`);
+        }
         if (managed && deps.engines) {
             const range = deps.engines(spec);
             const node = deps.runtimeNode ? deps.runtimeNode() : runtimeNodeVersion(managed);
@@ -129,10 +134,16 @@ export function upgrade(deps = defaultDeps(), opts = {}) {
             }
         }
         try {
-            deps.npmUpgrade(spec === "latest" ? undefined : spec);
+            if (managed && deps.stagedUpgrade)
+                deps.stagedUpgrade(managed, spec);
+            else
+                deps.npmUpgrade(spec === "latest" ? undefined : spec);
             steps.push({ name: "npm", ok: true, detail: `installed ${PKG_NAME}@${spec}` });
         }
         catch (e) {
+            if (e instanceof UpgradeBusy) {
+                return { root, from, to: from, steps: [...steps, { name: "npm", ok: true, detail: e.message }], ok: true, alreadyCurrent: true, restart: [] };
+            }
             if (spec !== "latest" && /ETARGET|No matching version|notarget/i.test(String(e.stderr ?? "") + e.message)) {
                 return { root, from, to: from, steps: [...steps, { name: "npm", ok: true, detail: `${PKG_NAME}@${spec} is not on npm yet` }], ok: true, alreadyCurrent: true, restart: [] };
             }
@@ -154,6 +165,9 @@ export function upgrade(deps = defaultDeps(), opts = {}) {
         const restart = [...deps.running(), "your agent session"];
         return { root, from, to, steps, ok: true, alreadyCurrent: false, restart };
     }
+    if (opts.exact) {
+        return stop("check", `this is a git checkout, which upgrades by pulling commits, not to a version. Check out the release you want (git checkout v${spec}), or run \`pantheon upgrade\` for the latest commit.`);
+    }
     const dirty = deps.dirty(root);
     if (dirty.length) {
         return stop("check", `the checkout has uncommitted changes (${dirty.slice(0, 4).join(", ")}${dirty.length > 4 ? ", …" : ""}). Commit or \`git stash\` them first — upgrade will not overwrite your work.`);
@@ -194,4 +208,235 @@ export function upgrade(deps = defaultDeps(), opts = {}) {
     const restart = [...deps.running(), "your agent session"];
     return { root, from, to, steps, ok: true, alreadyCurrent: false, restart };
 }
+const pidAlive = (pid) => {
+    if (!(pid > 0))
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+};
+const realSwapIo = (m) => ({
+    npm: (args) => {
+        const sp = npmSpawn(args, undefined, undefined, proxyEnvFor(), m);
+        execFileSync(sp.command, sp.args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 600_000, ...sp.options });
+    },
+    run: (cmd, args) => {
+        try {
+            return { status: 0, out: execFileSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 60_000 }) };
+        }
+        catch (e) {
+            const x = e;
+            return { status: x.status ?? null, out: `${x.stdout ?? ""}${x.stderr ?? ""}` || x.message };
+        }
+    },
+    exists: (p) => existsSync(p),
+    rename: (a, b) => renameSync(a, b),
+    remove: (p) => rmSync(p, { recursive: true, force: true }),
+    read: (p) => readFileSync(p, "utf8"),
+    write: (p, text) => { const tmp = `${p}.new-${process.pid}`; writeFileSync(tmp, text, { mode: 0o755 }); renameSync(tmp, p); },
+    list: (dir) => { try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    } },
+    unlock: (dir) => {
+        try {
+            if (Number(readFileSync(join(dir, "pid"), "utf8").trim()) === process.pid)
+                rmSync(dir, { recursive: true, force: true });
+        }
+        catch { }
+    },
+    alive: (pid) => pidAlive(pid),
+    holdSignals: () => {
+        const hold = () => { };
+        const sigs = ["SIGINT", "SIGTERM", "SIGHUP", "SIGBREAK"].filter((x) => x !== "SIGBREAK" || process.platform === "win32");
+        for (const x of sigs)
+            process.on(x, hold);
+        return () => { for (const x of sigs)
+            process.off(x, hold); };
+    },
+    sleep: (ms) => { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); },
+    lock: (dir) => {
+        for (let i = 0; i < 3; i++) {
+            try {
+                mkdirSync(dir);
+                writeFileSync(join(dir, "pid"), String(process.pid));
+                return true;
+            }
+            catch (e) {
+                if (e.code !== "EEXIST")
+                    throw e;
+                let pid = 0, age = 0;
+                try {
+                    pid = Number(readFileSync(join(dir, "pid"), "utf8").trim());
+                }
+                catch { }
+                try {
+                    age = Date.now() - statSync(dir).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                if (pidAlive(pid) ? age < 20 * 60_000 : !pid && age < 10_000)
+                    return false;
+                const gone = `${dir}.stale-${process.pid}`;
+                try {
+                    renameSync(dir, gone);
+                }
+                catch {
+                    continue;
+                }
+                rmSync(gone, { recursive: true, force: true });
+            }
+        }
+        return false;
+    },
+});
+export const realSwapIoForTest = realSwapIo;
+export class UpgradeBusy extends Error {
+    constructor() { super("another pantheon upgrade is running on this machine; nothing was changed, and the next check tries again"); }
+}
+export function stagedManagedUpgrade(m, spec, io = realSwapIo(m)) {
+    const win = /\.exe$/i.test(m.node);
+    const P = win ? win32 : posix;
+    const runtime = P.dirname(m.nodeDir);
+    const staging = P.join(runtime, `.upgrade-${process.pid}`);
+    const stagedPkg = win ? P.join(staging, "node_modules", "@join-pantheon", "cli") : P.join(staging, "lib", "node_modules", "@join-pantheon", "cli");
+    const prev = m.prevDir;
+    const failed = P.join(runtime, "cli.failed");
+    const startsAs = (entry) => {
+        const r = io.run(m.node, ["--use-system-ca", entry, "--version"]);
+        const line = r.out.replace(/\u001b\[[0-9;]*m/g, "").trim().split(/\r?\n/).pop()?.trim() ?? "";
+        return r.status === 0 && /^\d+\.\d+\.\d+/.test(line) ? line.replace(/^pantheon\s+/, "") : null;
+    };
+    const rename = (a, b, waitMs = 1000) => {
+        for (let i = 0; i < 6; i++) {
+            try {
+                io.rename(a, b);
+                return true;
+            }
+            catch {
+                if (i < 5)
+                    io.sleep(waitMs);
+            }
+        }
+        return false;
+    };
+    const ready = `${staging}-ready`;
+    const whole = (d) => ["package.json", P.join("bin", "pantheon.js"), P.join("dist", "cli.js")].every((f) => io.exists(P.join(d, f)));
+    const inPlace = () => whole(m.pkgDir);
+    const tidy = (p) => { try {
+        io.remove(p);
+    }
+    catch { } };
+    const held = (fn) => { const release = io.holdSignals(); try {
+        return fn();
+    }
+    finally {
+        release();
+    } };
+    const repairHint = () => io.exists(P.join(prev, "bin", "pantheon.js")) ? `The pantheon command puts ${prev} back the next time it runs; or run the installer again` : "Run the installer again to repair it";
+    const unnest = (inside) => {
+        const nested = P.join(inside, "cli.prev");
+        if (!io.exists(nested))
+            return;
+        if (io.exists(prev))
+            tidy(nested);
+        else
+            rename(nested, prev, 200);
+    };
+    const lock = P.join(runtime, ".upgrade.lock");
+    if (!io.lock(lock))
+        throw new UpgradeBusy();
+    try {
+        if (!io.exists(m.pkgDir)) {
+            const from = [prev, ...io.list(runtime).filter((n) => /^\.upgrade-\d+-ready$/.test(n)).map((n) => P.join(runtime, n)), P.join(failed, "cli.prev")]
+                .find(whole);
+            if (from)
+                rename(from, m.pkgDir);
+        }
+        if (!inPlace()) {
+            throw new Error(`the pantheon in place (${m.pkgDir}) is missing and could not be put back yet (a file is in use); nothing was changed. ${repairHint()}`);
+        }
+        unnest(m.pkgDir);
+        unnest(failed);
+        if (whole(prev) && !startsAs(m.entry) && startsAs(P.join(prev, "bin", "pantheon.js"))) {
+            held(() => { if (rename(m.pkgDir, failed, 500))
+                rename(prev, m.pkgDir, 500); });
+            if (!inPlace())
+                throw new Error(`the pantheon in place did not start, and the previous version could not be put back yet (a file is in use); nothing else was changed. ${repairHint()}`);
+        }
+        for (const n of io.list(runtime)) {
+            const pid = /^\.upgrade-(\d+)(?:-ready)?$/.exec(n)?.[1];
+            if ((pid && (Number(pid) === process.pid || !io.alive(Number(pid)))) || (n === "cli.failed" && !io.exists(P.join(failed, "cli.prev"))))
+                tidy(P.join(runtime, n));
+        }
+        if (!win) {
+            try {
+                const healed = launcherWithRepair(io.read(m.launcher), m, "linux");
+                if (healed !== null)
+                    io.write(m.launcher, healed);
+            }
+            catch { }
+        }
+        io.npm(["install", "-g", "--prefix", staging, "--cache", P.join(runtime, "npm-cache"), "--fetch-timeout=60000", "--fetch-retries=2",
+            `${PKG_NAME}@${spec}`, "--no-audit", "--no-fund", "--loglevel=error"]);
+        let version = "";
+        try {
+            version = JSON.parse(io.read(P.join(stagedPkg, "package.json"))).version ?? "";
+        }
+        catch { }
+        if (!version || (spec !== "latest" && version !== spec))
+            throw new Error(`npm installed ${version || "nothing readable"} into the staging folder, not ${spec}; nothing was changed`);
+        const staged = startsAs(P.join(stagedPkg, "bin", "pantheon.js"));
+        if (staged !== version)
+            throw new Error(`the new pantheon ${version} did not start (it answered ${staged ?? "nothing"}); the working version was kept`);
+        if (!rename(stagedPkg, ready))
+            throw new Error("the new pantheon's files are still held by another program (a virus scan); nothing was changed, and the next check tries again");
+        if (!inPlace())
+            throw new Error(`the pantheon in place (${m.pkgDir}) went missing during the upgrade; nothing was swapped. ${repairHint()}`);
+        tidy(prev);
+        if (io.exists(prev)) {
+            tidy(ready);
+            throw new Error(`the kept previous version (${prev}) could not be removed to make room (a file is in use); nothing was changed, and the next check tries again`);
+        }
+        held(() => {
+            if (io.exists(m.pkgDir) && !rename(m.pkgDir, prev, 500)) {
+                throw new Error(`could not move the working pantheon aside (a file in ${m.pkgDir} is in use); it was kept, and the next check tries again`);
+            }
+            if (!rename(ready, m.pkgDir, 500)) {
+                if (!io.exists(m.pkgDir) && io.exists(prev))
+                    rename(prev, m.pkgDir, 500);
+                throw new Error(inPlace()
+                    ? `could not put the new pantheon in place (a file is in use); the working version was put back`
+                    : `could not put the new pantheon in place, nor the working one back: ${m.pkgDir} is missing. The pantheon command puts ${prev} back the next time it runs; or run the installer again`);
+            }
+        });
+        unnest(m.pkgDir);
+        const placed = startsAs(m.entry);
+        if (placed !== version) {
+            const back = whole(prev) && held(() => rename(m.pkgDir, failed, 500) && (rename(prev, m.pkgDir, 500) || inPlace()));
+            if (back)
+                tidy(failed);
+            throw new Error(back
+                ? `pantheon ${version} did not start once in place (it answered ${placed ?? "nothing"}); the previous version was put back`
+                : `pantheon ${version} did not start once in place, and the previous version could not be put back yet. ${inPlace() ? `It is kept at ${prev}; the next upgrade puts it back, or run the installer again` : repairHint()}`);
+        }
+        return { version };
+    }
+    finally {
+        tidy(staging);
+        if (inPlace())
+            tidy(ready);
+        try {
+            io.unlock(lock);
+        }
+        catch { }
+    }
+}
 //# sourceMappingURL=upgrade.js.map