@join-pantheon/cli 0.32.0 → 0.33.0-rc.1

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/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

package/dist/uri-handler.js

@@ -0,0 +1,335 @@
+import { spawnSync } from "node:child_process";
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { appendFileSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join, win32 } from "node:path";
+export const URI_SCHEME = "pantheon";
+export const URI_HOSTS = ["board", "done", "explain", "details"];
+const FORMS = {
+    board: { required: [], optional: [] },
+    done: { required: ["decision", "k"], optional: ["act", "space"] },
+    explain: { required: ["decision", "k"], optional: ["act", "space"] },
+    details: { required: ["act", "k"], optional: ["decision", "space"] },
+};
+export const URI_VALUE = {
+    decision: /^o_[a-z0-9]{6,48}$/,
+    act: /^a_[A-Za-z0-9]{6,48}$/,
+    space: /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/,
+    k: /^[0-9a-f]{32}$/,
+};
+export const MAX_URI = 400;
+function canonical(host, params) {
+    return `${host}?${Object.keys(params).filter((k) => k !== "k").sort().map((k) => `${k}=${params[k]}`).join("&")}`;
+}
+export function uriCode(key, host, params) {
+    return createHmac("sha256", key).update(canonical(host, params)).digest("hex").slice(0, 32);
+}
+export function buildUri(host, params, key) {
+    const form = FORMS[host];
+    const kept = {};
+    for (const name of [...form.required, ...form.optional]) {
+        if (name === "k")
+            continue;
+        const v = params[name];
+        if (v === undefined || v === "") {
+            if (form.required.includes(name))
+                return null;
+            continue;
+        }
+        if (!URI_VALUE[name].test(v)) {
+            if (form.required.includes(name))
+                return null;
+            continue;
+        }
+        kept[name] = v;
+    }
+    if (form.required.includes("k")) {
+        if (!key)
+            return null;
+        kept.k = uriCode(key, host, kept);
+    }
+    const q = Object.entries(kept).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+    return `${URI_SCHEME}://${host}${q ? `?${q}` : ""}`;
+}
+export function parseUri(raw) {
+    if (typeof raw !== "string" || !raw)
+        return { ok: false, why: "no link given" };
+    if (raw.length > MAX_URI)
+        return { ok: false, why: `the link is ${raw.length} characters long; a Pantheon link is under ${MAX_URI}` };
+    if (/^pantheons?:\/\/[^/?#\s]+\/[^/?#\s]+#\S+$/i.test(raw))
+        return { ok: false, why: "this looks like a team invite, not an alert's link — to join, copy the link and run in a terminal: pantheon join \"<the link>\"" };
+    if (!/^[A-Za-z0-9:/?&=%._~-]+$/.test(raw))
+        return { ok: false, why: "the link holds characters a Pantheon link never has" };
+    const m = /^pantheon:\/\/([A-Za-z]+)\/?(?:\?(.*))?$/i.exec(raw);
+    if (!m)
+        return { ok: false, why: "not a Pantheon alert link (expected pantheon://board, done, explain or details)" };
+    const host = m[1].toLowerCase();
+    if (!URI_HOSTS.includes(host))
+        return { ok: false, why: `"${m[1]}" is not something a Pantheon link can do (board, done, explain or details)` };
+    const form = FORMS[host];
+    const params = {};
+    const query = m[2];
+    if (query !== undefined && query !== "") {
+        for (const part of query.split("&")) {
+            const eq = part.indexOf("=");
+            if (eq <= 0)
+                return { ok: false, why: "a parameter in the link has no value" };
+            const name = part.slice(0, eq);
+            if (!/^[a-z]{1,16}$/.test(name))
+                return { ok: false, why: "the link has a parameter Pantheon never writes" };
+            if (![...form.required, ...form.optional].includes(name))
+                return { ok: false, why: `"${name}" is not a parameter of pantheon://${host}` };
+            if (Object.prototype.hasOwnProperty.call(params, name))
+                return { ok: false, why: `"${name}" appears twice in the link` };
+            let value;
+            try {
+                value = decodeURIComponent(part.slice(eq + 1));
+            }
+            catch {
+                return { ok: false, why: `"${name}" is not encoded correctly` };
+            }
+            if (!URI_VALUE[name].test(value))
+                return { ok: false, why: `"${name}" is not in the form Pantheon writes it` };
+            params[name] = value;
+        }
+    }
+    else if (query === "")
+        return { ok: false, why: "the link ends in an empty query" };
+    for (const r of form.required)
+        if (!(r in params))
+            return { ok: false, why: `pantheon://${host} needs "${r}"` };
+    return { ok: true, host, params };
+}
+export function verifyUri(p, key) {
+    if (!FORMS[p.host].required.includes("k"))
+        return true;
+    if (!key || !p.params.k)
+        return false;
+    const want = Buffer.from(uriCode(key, p.host, p.params), "utf8");
+    const got = Buffer.from(p.params.k, "utf8");
+    return want.length === got.length && timingSafeEqual(want, got);
+}
+export function hudActionFor(p) {
+    const { decision, act, space } = p.params;
+    const extra = { ...(space ? { space } : {}) };
+    if (p.host === "done")
+        return { action: "done", decision: decision, ...(act ? { act } : {}), ...extra };
+    if (p.host === "explain")
+        return { action: "open", decision: decision, ...(act ? { act } : {}), ...extra };
+    if (p.host === "details")
+        return { action: "details", act: act, ...(decision ? { decision } : {}), ...extra };
+    return null;
+}
+export const uriKeyPath = (home) => join(home, "uri-key");
+export function uriKey(home, create = true) {
+    const f = uriKeyPath(home);
+    const read = () => { try {
+        const k = readFileSync(f, "utf8").trim();
+        return /^[0-9a-f]{64}$/.test(k) ? k : null;
+    }
+    catch {
+        return null;
+    } };
+    const have = read();
+    if (have || !create)
+        return have;
+    try {
+        mkdirSync(home, { recursive: true });
+        writeFileSync(f, randomBytes(32).toString("hex"), { mode: 0o600, flag: "wx" });
+    }
+    catch {
+        if (!read()) {
+            try {
+                const tmp = `${f}.${randomBytes(6).toString("hex")}.tmp`;
+                writeFileSync(tmp, randomBytes(32).toString("hex"), { mode: 0o600, flag: "wx" });
+                renameSync(tmp, f);
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return read();
+}
+export const hudActionPath = (home) => join(home, "bin", ".hud-action.json");
+export function writeHudAction(home, action) {
+    const f = hudActionPath(home);
+    mkdirSync(join(home, "bin"), { recursive: true });
+    const tmp = `${f}.${randomBytes(8).toString("hex")}.tmp`;
+    try {
+        writeFileSync(tmp, JSON.stringify(action), { mode: 0o600, flag: "wx" });
+        renameSync(tmp, f);
+    }
+    catch (e) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch { }
+        throw e;
+    }
+    return f;
+}
+export function logUri(home, line, now = new Date()) {
+    try {
+        mkdirSync(join(home, "logs"), { recursive: true });
+        appendFileSync(join(home, "logs", "uri.log"), `${now.toISOString()} ${line}\n`, { mode: 0o600 });
+    }
+    catch { }
+}
+export function describeUri(p) {
+    const shown = Object.entries(p.params).filter(([k]) => k !== "k").map(([k, v]) => `${k}=${v}`).join(" ");
+    return `${p.host}${shown ? ` ${shown}` : ""}`;
+}
+export async function handleUri(args, d) {
+    const now = d.now ?? (() => new Date());
+    const refuse = async (why, logged) => {
+        d.print(`Pantheon did not act on this link: ${why}`);
+        logUri(d.home, `refused ${logged}: ${why}`, now());
+        await d.pause();
+        return 2;
+    };
+    if (args.length !== 1)
+        return refuse("it expects exactly one link", `(${args.length} arguments)`);
+    if (d.wokenRun)
+        return refuse("a woken run cannot act for the person — a person has to click it", "(inside a woken run)");
+    const p = parseUri(args[0]);
+    if (!p.ok)
+        return refuse(p.why, "(a link that is not one of Pantheon's)");
+    if (!verifyUri(p, uriKey(d.home, false))) {
+        return refuse("this link was not made by Pantheon on this machine (it acts only on links from its own alerts)", describeUri(p));
+    }
+    if (p.host === "board") {
+        if (d.openBoard) {
+            let ok = false;
+            try {
+                ok = await d.openBoard();
+            }
+            catch {
+                ok = false;
+            }
+            if (ok) {
+                logUri(d.home, "board: opened", now());
+                return 0;
+            }
+            logUri(d.home, "board: could not start; showing the brief instead", now());
+        }
+        else
+            logUri(d.home, "board: this build has none; showing the brief instead", now());
+        const code = await d.runBrief();
+        await d.pause();
+        return code;
+    }
+    const action = { ...hudActionFor(p), nonce: randomBytes(16).toString("hex") };
+    try {
+        writeHudAction(d.home, action);
+    }
+    catch (e) {
+        return refuse(`could not queue the action (${e.message.split("\n")[0]})`, describeUri(p));
+    }
+    logUri(d.home, `${describeUri(p)}: queued ${action.action}`, now());
+    const code = await d.runQueued(action.nonce);
+    logUri(d.home, `${describeUri(p)}: explain --queued exited ${code}`, now());
+    if (code !== 0 || p.host === "details")
+        await d.pause();
+    return code;
+}
+export const PROTOCOL_KEY = "HKCU\\Software\\Classes\\pantheon";
+export const COMMAND_KEY = `${PROTOCOL_KEY}\\shell\\open\\command`;
+export const PANTHEON_AUMID = "JoinPantheon.Pantheon";
+export const AUMID_KEY = `HKCU\\Software\\Classes\\AppUserModelId\\${PANTHEON_AUMID}`;
+export function handlerCommand(entry, home = null) {
+    const words = [entry.command, ...entry.args];
+    if (!words.length || /\.(cmd|bat)$/i.test(entry.command))
+        return null;
+    if ([...words, ...(home ? [home] : [])].some((w) => w.includes('"') || /[\r\n%]/.test(w)))
+        return null;
+    const q = (w) => (/^[A-Za-z0-9_.:\\/-]+$/.test(w) && !/[\\/]/.test(w) ? w : `"${w}"`);
+    return `${words.map(q).join(" ")} handle-uri${home ? ` --home "${home}"` : ""} "%1"`;
+}
+export function handlerEntry(entry, flags = []) {
+    const args = entry.args[entry.args.length - 1] === "mcp" ? entry.args.slice(0, -1) : entry.args;
+    return { command: entry.command, args: [...flags.filter((f) => !args.includes(f)), ...args] };
+}
+export function parseHandleUriArgs(args, isAbsolute = (p) => win32.isAbsolute(p) || p.startsWith("/"), normalize = (p) => p) {
+    if (args[0] !== "--home")
+        return { home: null, rest: [...args] };
+    if (args.length !== 3)
+        return { error: "it expects --home <folder> and then exactly one link" };
+    const dir = args[1];
+    if (!dir || /[\r\n"%]/.test(dir) || !isAbsolute(dir) || normalize(dir) !== dir || /(^|[\\/])\.\.([\\/]|$)/.test(dir))
+        return { error: "its --home is not a full path to a folder" };
+    return { home: dir, rest: [args[2]] };
+}
+export function regDefault(stdout) {
+    for (const line of stdout.split(/\r?\n/)) {
+        const m = /^\s+\S.*?\s{2,}REG_(?:EXPAND_)?SZ(?:\s{2,}(.*))?\s*$/.exec(line);
+        if (m)
+            return (m[1] ?? "").trimEnd();
+    }
+    return null;
+}
+const isOurs = (command) => !!command && / handle-uri(?: --home "[^"%\r\n]+")? "%1"$/.test(command);
+export function registerUriHandler(command, io, icon) {
+    const now = io.reg(["query", COMMAND_KEY, "/ve"]);
+    const current = now.status === 0 ? regDefault(now.stdout) : null;
+    if (current !== null && !isOurs(current)) {
+        return { changed: false, ok: false, line: `the pantheon: links are registered to another program (${current}) — left alone, so alert buttons will not work here` };
+    }
+    if (current === command) {
+        const url = io.reg(["query", PROTOCOL_KEY, "/v", "URL Protocol"]);
+        if (url.status === 0)
+            return { changed: false, ok: true, line: "pantheon: links already open Pantheon" };
+    }
+    const adds = [
+        ["add", PROTOCOL_KEY, "/ve", "/d", "URL:Pantheon", "/f"],
+        ["add", PROTOCOL_KEY, "/v", "URL Protocol", "/d", "", "/f"],
+        ...(icon ? [["add", `${PROTOCOL_KEY}\\DefaultIcon`, "/ve", "/d", icon, "/f"]] : []),
+        ["add", COMMAND_KEY, "/ve", "/d", command, "/f"],
+        ["add", AUMID_KEY, "/v", "DisplayName", "/d", "Pantheon", "/f"],
+        ...(icon ? [["add", AUMID_KEY, "/v", "IconUri", "/d", icon, "/f"]] : []),
+    ];
+    for (const a of adds) {
+        const r = io.reg(a);
+        if (r.refused)
+            return { changed: false, ok: false, line: `pantheon: links not registered — ${r.refused}` };
+        if (r.status !== 0)
+            return { changed: true, ok: false, line: `could not register pantheon: links (reg ${a.slice(0, 2).join(" ")} exited ${r.status ?? "on a signal"})` };
+    }
+    return { changed: true, ok: true, line: `pantheon: links now open Pantheon (${PROTOCOL_KEY})` };
+}
+export function aumidRegistered(io) {
+    return io.reg(["query", AUMID_KEY, "/v", "DisplayName"]).status === 0;
+}
+export function unregisterUriHandler(io) {
+    const removed = [], left = [];
+    const now = io.reg(["query", COMMAND_KEY, "/ve"]);
+    const current = now.status === 0 ? regDefault(now.stdout) : null;
+    if (current !== null && !isOurs(current))
+        left.push(`the pantheon: link handler (${PROTOCOL_KEY}) — it belongs to another program, so it was left alone`);
+    else if (now.status === 0) {
+        const r = io.reg(["delete", PROTOCOL_KEY, "/f"]);
+        if (r.status === 0)
+            removed.push(`the pantheon: link handler (${PROTOCOL_KEY})`);
+        else
+            left.push(r.refused ? `the pantheon: link handler (${PROTOCOL_KEY}) — ${r.refused}` : `the pantheon: link handler (${PROTOCOL_KEY}) — remove it with: reg delete ${PROTOCOL_KEY} /f`);
+    }
+    if (io.reg(["query", AUMID_KEY]).status === 0) {
+        const r = io.reg(["delete", AUMID_KEY, "/f"]);
+        if (r.status === 0)
+            removed.push(`Pantheon's notification app id (${AUMID_KEY})`);
+        else
+            left.push(r.refused ? `Pantheon's notification app id — ${r.refused}` : `Pantheon's notification app id — remove it with: reg delete "${AUMID_KEY}" /f`);
+    }
+    return { removed, left };
+}
+export function realRegIo(borrowed, env = process.env) {
+    const exe = win32.join(env.SystemRoot || env.windir || "C:\\Windows", "System32", "reg.exe");
+    return {
+        reg: (args) => {
+            if (args[0] !== "query" && borrowed())
+                return { status: 1, stdout: "", refused: "this Pantheon home, HOME or USERPROFILE is not your own Windows profile (a test or a sandbox), so the registry was not changed" };
+            const r = spawnSync(exe, args, { encoding: "utf8", windowsHide: true, timeout: 10_000, stdio: ["ignore", "pipe", "pipe"] });
+            return { status: r.error ? null : r.status, stdout: r.stdout ?? "" };
+        },
+    };
+}
+//# sourceMappingURL=uri-handler.js.map