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

package/dist/machine.js

@@ -3,7 +3,8 @@ import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, re
 import { homedir, hostname, networkInterfaces, platform } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { CONFIG_DIR } from "./config.js";
-import { borrowedHome, disableService, existingUnitPath, plistPath, serviceInstalled, serviceLogFile, unitPath, unitPaths, uninstallService } from "./service.js";
+import { borrowedHome, disableService, existingUnitPath, plistPath, serviceInstalled, serviceLogFile, stopWindowsHost, unitPath, unitPaths, uninstallService } from "./service.js";
+import { LEGACY_TASK_NAME, hostAlive, hostChildRunning, hostFiles, isHostKind, readHostState, recordedTaskName } from "./win-host.js";
 import { copilotMcpConfigFile, vsCodeUserDir, kiroMcpConfigFile, kiroDir } from "./install.js";
 const sh = (cmd) => {
     try {
@@ -100,7 +101,33 @@ function fromSystemd(kind) {
         ...(s.lastExit ? { lastExit: s.lastExit } : {}),
     };
 }
+export function elapsed(ms) {
+    const s = Math.max(0, Math.floor(ms / 1000));
+    const d = Math.floor(s / 86400), h = Math.floor((s % 86400) / 3600), m = Math.floor((s % 3600) / 60), sec = s % 60;
+    const two = (n) => String(n).padStart(2, "0");
+    return `${d ? `${d}-` : ""}${d || h ? `${two(h)}:` : ""}${two(m)}:${two(sec)}`;
+}
+export function hostProc(kind, o = {}) {
+    if ((o.platform ?? platform()) !== "win32" || !isHostKind(kind))
+        return {};
+    const home = o.home ?? CONFIG_DIR;
+    if (!existsSync(hostFiles(home).definition(kind)))
+        return {};
+    const now = o.now ?? Date.now();
+    const st = readHostState(home);
+    const up = hostAlive(st, now, o.alive);
+    const run = hostChildRunning(kind, home, now, o.alive);
+    const r = up ? st.children[kind] : undefined;
+    return {
+        managedBy: "host", label: `task ${recordedTaskName(home) ?? LEGACY_TASK_NAME}`, logPath: hostFiles(home).childLog(kind),
+        ...(run ? { running: true, pid: run.pid, ...(run.since ? { since: elapsed(now - run.since) } : {}) } : { running: false }),
+        ...(r?.lastExit && r.lastExit !== "0" ? { lastExit: r.lastExit } : {}),
+    };
+}
 const fromManager = (kind) => {
+    const h = hostProc(kind);
+    if (h.managedBy)
+        return h;
     const l = fromLaunchd(kind);
     return l.managedBy ? l : fromSystemd(kind);
 };
@@ -438,6 +465,7 @@ const defaultStopIo = (port = 8787) => ({
     borrowed: () => borrowedHome(),
     loadedFrom: (kind) => managerDefinitionPath(kind),
     kill: killPid,
+    ...(platform() === "win32" ? { stopHost: () => stopWindowsHost() } : {}),
 });
 export const borrowedHomeLine = (kind) => `${kind === "services" ? "services" : `${kind}:`} left alone — HOME (${homedir()}) is not your own home (a test, a sandbox or another account's folder), so the service manager's jobs here are the real user's, not this home's. Nothing was stopped; run this from your own login to stop your services`;
 export const isPantheonCommand = (cmd) => /pantheon/i.test(cmd) || /\bcli\.js\s+(relay|start)\b/.test(cmd);
@@ -500,7 +528,9 @@ export function stopProcResult(kind, io = defaultStopIo()) {
             else {
                 const how = platform() === "darwin"
                     ? `launchctl disable gui/${process.getuid?.() ?? 0}/dev.pantheon.${kind}`
-                    : `systemctl --user disable --now pantheon-${kind}`;
+                    : platform() === "win32"
+                        ? `pantheon service uninstall ${kind}`
+                        : `systemctl --user disable --now pantheon-${kind}`;
                 lines.push(`${kind}: could not disable the service (${e.message.split("\n")[0]}) — it may start again at login; try: ${how}`);
             }
         }
@@ -511,7 +541,7 @@ export function stopProcResult(kind, io = defaultStopIo()) {
         const stillUp = !!after.running && !k?.killed;
         if (disabled) {
             lines.unshift(`${kind}: ${stillUp ? "disabled, but a process is still running (see below)" : p.running || k?.killed ? "stopped, and will not start again at login" : "was not running; disabled, and will not start again at login"}`);
-            lines.push(`        start it again with: pantheon service install ${kind}`);
+            lines.push(`        start it again with: pantheon service ${p.managedBy === "host" ? "start" : "install"} ${kind}`);
         }
         return { lines, stopped: (p.running && disabled && !stillUp) || !!k?.killed };
     }
@@ -576,6 +606,11 @@ export function stopMachine(what, opts, io = defaultStopIo(opts.port), hosts = h
                 lines.push(`worker: ${k}`);
         }
     }
+    if (what === "all" && io.stopHost) {
+        const h = io.stopHost();
+        if (h.length)
+            lines.push(...h.map((l) => `host: ${l.trim().replace(/^the Pantheon host /, "")}`), "        it starts again at your next logon (services stay paused), or now: pantheon service start worker");
+    }
     if (!relayStopped)
         return { lines };
     const teams = opts.teams ?? (opts.teamRelay ? [{ name: "", relay: opts.teamRelay }] : []);

package/dist/managed.js

@@ -23,6 +23,7 @@ export function managedLayout(execPath = process.execPath, os = platform()) {
             root, nodeDir, node: p, npm: win32.join(nodeDir, "npm.cmd"), npmCli: win32.join(nodeDir, "node_modules", "npm", "bin", "npm-cli.js"), binDir,
             launcher: win32.join(binDir, "pantheon.cmd"), pkgDir,
             entry: win32.join(pkgDir, "bin", "pantheon.js"), cli: win32.join(pkgDir, "dist", "cli.js"),
+            prevDir: win32.join(runtime, "cli.prev"),
         };
     }
     const p = posix.normalize(execPath);
@@ -42,8 +43,33 @@ export function managedLayout(execPath = process.execPath, os = platform()) {
         root, nodeDir, node: p, npm: posix.join(bin, "npm"), npmCli: posix.join(nodeDir, "lib", "node_modules", "npm", "bin", "npm-cli.js"), binDir,
         launcher: posix.join(binDir, "pantheon"), pkgDir,
         entry: posix.join(pkgDir, "bin", "pantheon.js"), cli: posix.join(pkgDir, "dist", "cli.js"),
+        prevDir: posix.join(runtime, "cli.prev"),
     };
 }
+const shq = (p) => `'${p.replace(/'/g, `'\\''`)}'`;
+export function launcherRepairLines(m, os = platform()) {
+    if (os === "win32") {
+        return [
+            "rem An upgrade cut off mid-swap leaves the previous version beside the runtime: put it back.",
+            'if not exist "%~dp0..\\runtime\\node\\node_modules\\@join-pantheon\\cli\\" if exist "%~dp0..\\runtime\\cli.prev\\bin\\pantheon.js" move "%~dp0..\\runtime\\cli.prev" "%~dp0..\\runtime\\node\\node_modules\\@join-pantheon\\cli" >nul 2>&1',
+        ];
+    }
+    return [
+        "# An upgrade cut off mid-swap leaves the previous version beside the runtime: put it back.",
+        `[ -e ${shq(m.pkgDir)} ] || { [ -f ${shq(posix.join(m.prevDir, "bin", "pantheon.js"))} ] && mv ${shq(m.prevDir)} ${shq(m.pkgDir)} 2>/dev/null; }`,
+    ];
+}
+export function launcherWithRepair(current, m, os = platform()) {
+    if (current.includes("cli.prev"))
+        return null;
+    const nl = os === "win32" ? "\r\n" : "\n";
+    const lines = current.split(nl);
+    const at = os === "win32" ? lines.findIndex((l) => l.startsWith('"%~dp0..\\runtime\\node\\node.exe"')) : lines.findIndex((l) => l.startsWith("exec "));
+    if (at < 0)
+        return null;
+    lines.splice(at, 0, ...launcherRepairLines(m, os));
+    return lines.join(nl);
+}
 export function childNodeFlags(execArgv = process.execArgv, layout = managedLayout()) {
     return execArgv.includes("--use-system-ca") || layout ? ["--use-system-ca"] : [];
 }
@@ -178,7 +204,7 @@ export function installerLine(relay, shell, args = []) {
     if (shell === "ps" && !args.length)
         return `irm ${base}/install.ps1 | iex`;
     const set = args.length ? `Set-Item Env:PANTHEON_ARGS '${args.join(" ")}'; ` : "";
-    return `powershell -NoProfile -ExecutionPolicy Bypass -Command "${set}irm ${base}/install.ps1 | iex"`;
+    return `powershell -NoProfile -Command "${set}irm ${base}/install.ps1 | iex"`;
 }
 export function installerLineHere(relay, os = platform()) {
     return installerLine(relay, os === "win32" ? "ps" : "sh") ?? installerLine(HOSTED_INSTALLER_BASE, os === "win32" ? "ps" : "sh");

package/dist/notice-linux.js

@@ -0,0 +1,501 @@
+import { execFileSync, spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { busSocketPath, DBus, Notifications, portalOpenUri as busPortalOpenUri } from "./dbus.js";
+import { CONFIG_DIR } from "./config.js";
+import { hostEnv } from "./host-env.js";
+import { childNodeFlags } from "./managed.js";
+import { parseSystemdEnvironment } from "./service.js";
+import { which } from "./which.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const LINUX_LIMITS = { summary: 80, line: 220, body: 600 };
+export function noticeText(s, max, markup) {
+    const t = s.replace(/\r\n?/g, "\n").replace(/[\u0000-\u0009\u000b-\u001f\u007f-\u009f‎‏‪-‮⁦-⁩]/g, "").trim();
+    const esc = (c) => (!markup ? c : c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === ">" ? "&gt;" : c);
+    const pieces = Array.from(t, esc);
+    const whole = pieces.join("");
+    if (whole.length <= max)
+        return whole;
+    let out = "";
+    for (const p of pieces) {
+        if (out.length + p.length > max - 1)
+            break;
+        out += p;
+    }
+    return `${out.trimEnd()}…`;
+}
+export function linuxNoticeBody(n, markup) {
+    const lines = [];
+    const context = noticeText(n.context.replace(/\n/g, " "), LINUX_LIMITS.line, markup);
+    if (context)
+        lines.push(markup ? `<b>${context}</b>` : context);
+    const body = noticeText(n.body, LINUX_LIMITS.line * 2, markup);
+    if (body)
+        lines.push(body);
+    const who = noticeText(n.who.replace(/\n/g, " "), LINUX_LIMITS.line, markup);
+    if (who)
+        lines.push(markup ? `<i>${who}</i>` : who);
+    let out = lines.join("\n");
+    if (out.length > LINUX_LIMITS.body)
+        out = noticeText([n.context, n.body, n.who].filter(Boolean).join("\n"), LINUX_LIMITS.body, markup);
+    return out;
+}
+export function noticeActions(n) {
+    const out = [["default", "Open board"]];
+    if (n.kind === "decision" && n.details?.decision)
+        out.push(["done", "Done"]);
+    out.push(["board", "Open board"]);
+    return out;
+}
+export function noticeUrgency(n) {
+    return n.kind === "decision" ? 2 : 1;
+}
+export function toDesktopNotice(n, caps, replacesId = 0) {
+    const markup = caps.includes("body-markup");
+    return {
+        appName: "Pantheon",
+        summary: noticeText(n.heading.replace(/\n/g, " "), LINUX_LIMITS.summary, false),
+        body: caps.includes("body") || caps.length === 0 ? linuxNoticeBody(n, markup) : "",
+        actions: caps.includes("actions") ? noticeActions(n) : [],
+        urgency: noticeUrgency(n),
+        timeoutMs: n.ttl > 0 ? n.ttl * 1000 : 0,
+        replacesId,
+        hints: [
+            ["category", { sig: "s", value: n.kind === "decision" ? "im.received" : n.kind === "delivery" ? "transfer.complete" : n.kind === "worker_failed" ? "transfer.error" : "transfer.complete" }],
+            ...(n.sound ? [] : [["suppress-sound", { sig: "b", value: true }]]),
+        ],
+    };
+}
+export function notifySendArgs(n) {
+    const u = noticeUrgency(n);
+    return [
+        "--app-name=Pantheon",
+        `--urgency=${u === 2 ? "critical" : "normal"}`,
+        `--expire-time=${n.ttl > 0 ? n.ttl * 1000 : 0}`,
+        "--",
+        noticeText(n.heading.replace(/\n/g, " "), LINUX_LIMITS.summary, false),
+        linuxNoticeBody(n, false),
+    ];
+}
+export function sessionBusCandidates(env = process.env, exists = existsSync) {
+    const out = [];
+    const fromEnv = env.DBUS_SESSION_BUS_ADDRESS ? busSocketPath(env.DBUS_SESSION_BUS_ADDRESS, null) : null;
+    if (fromEnv && (fromEnv.startsWith("\0") || exists(fromEnv)))
+        out.push(fromEnv);
+    if (env.XDG_RUNTIME_DIR) {
+        const p = join(env.XDG_RUNTIME_DIR, "bus");
+        if (exists(p) && !out.includes(p))
+            out.push(p);
+    }
+    return out;
+}
+export function hudActionFor(n, action) {
+    if (action !== "done" || n.kind !== "decision" || !n.details?.decision)
+        return null;
+    return { action: "done", decision: n.details.decision, ...(n.details.act ? { act: n.details.act } : {}), ...(n.space ? { space: n.space } : {}) };
+}
+export function serverLabel(info) {
+    if (!info)
+        return "the notification server";
+    const NAMES = { "gnome-shell": "GNOME Shell", Plasma: "KDE Plasma", "Xfce Notify Daemon": "Xfce", mako: "mako", dunst: "dunst" };
+    const name = NAMES[info.name] ?? (info.name || info.vendor || "the notification server");
+    return info.version ? `${name} ${info.version}` : name;
+}
+const realOpen = async (path) => {
+    const bus = await DBus.connect(path, 3_000);
+    try {
+        return await Notifications.open(bus);
+    }
+    catch (e) {
+        bus.close();
+        throw e;
+    }
+};
+const realRun = (file, args, env, timeoutMs) => new Promise((done) => {
+    let out = "";
+    let child;
+    try {
+        child = spawn(file, args, { env, stdio: ["ignore", "pipe", "pipe"] });
+    }
+    catch {
+        done({ code: null, out: "" });
+        return;
+    }
+    const timer = setTimeout(() => { child.kill(); }, timeoutMs);
+    child.stdout?.on("data", (d) => { out += d.toString(); });
+    child.stderr?.on("data", (d) => { out += d.toString(); });
+    child.on("error", () => { clearTimeout(timer); done({ code: null, out }); });
+    child.on("close", (code) => { clearTimeout(timer); done({ code, out }); });
+});
+const thisCli = () => [process.execPath, ...childNodeFlags(), resolve(HERE, "cli.js")];
+export class LinuxAlerts {
+    conn = null;
+    connecting = null;
+    shown = new Map();
+    byDecision = new Map();
+    actions = Promise.resolve();
+    saidNone = false;
+    retryAt = 0;
+    lastSaid = "";
+    say(line) { if (line !== this.lastSaid) {
+        this.lastSaid = line;
+        this.d.log(line);
+    } }
+    opening = new Set();
+    posting = new Set();
+    d;
+    constructor(deps = {}) {
+        const run = deps.run ?? realRun;
+        const cli = deps.cli ?? thisCli();
+        this.d = {
+            env: deps.env ?? process.env,
+            exists: deps.exists ?? existsSync,
+            open: deps.open ?? realOpen,
+            findNotifySend: deps.findNotifySend ?? (() => which("notify-send")),
+            run,
+            cli,
+            log: deps.log ?? ((l) => console.error(l)),
+            openBoard: deps.openBoard ?? ((env) => openBoardWith(cli, env)),
+            sessionEnv: deps.sessionEnv ?? realSessionEnv,
+        };
+    }
+    get live() { return this.shown.size; }
+    async connection() {
+        if (this.conn)
+            return this.conn;
+        if (this.connecting)
+            return this.connecting;
+        if (Date.now() < this.retryAt)
+            return null;
+        this.connecting = (async () => {
+            const errors = [];
+            for (const path of sessionBusCandidates(this.d.env, this.d.exists)) {
+                let n = null;
+                try {
+                    n = await this.d.open(path);
+                    const caps = await n.capabilities();
+                    const info = await n.serverInfo().catch(() => null);
+                    n.onAction((id, action, token) => this.onAction(id, action, token));
+                    n.onClosed((id) => this.forget(id));
+                    const conn = { n, caps, info, path };
+                    n.onDisconnect(() => { if (this.conn === conn) {
+                        this.conn = null;
+                        this.shown.clear();
+                        this.byDecision.clear();
+                    } });
+                    n.onServerChange?.(() => {
+                        if (this.conn !== conn)
+                            return;
+                        if (this.shown.size)
+                            this.d.log(`alerts: the notification server restarted — ${this.shown.size} earlier alert(s) no longer have working buttons`);
+                        this.shown.clear();
+                        this.byDecision.clear();
+                    });
+                    this.conn = conn;
+                    this.say(`alerts: D-Bus notifications${caps.includes("actions") ? " with actions" : ", no buttons"} (${serverLabel(info)})`);
+                    return this.conn;
+                }
+                catch (e) {
+                    try {
+                        n?.disconnect();
+                    }
+                    catch { }
+                    errors.push(`${path.replace(/^\0/, "@")}: ${e.message.split("\n")[0]}`);
+                }
+            }
+            if (errors.length) {
+                this.retryAt = Date.now() + 60_000;
+                this.say(`alerts: could not use the session bus (${errors.join("; ")})`);
+            }
+            return null;
+        })().finally(() => { this.connecting = null; });
+        return this.connecting;
+    }
+    async show(notice, home = CONFIG_DIR) {
+        try {
+            const c = await this.connection();
+            if (c) {
+                const prev = notice.details?.decision ? this.byDecision.get(notice.details.decision) : undefined;
+                try {
+                    const posting = c.n.notify(toDesktopNotice(notice, c.caps, prev && this.shown.has(prev) ? prev : 0)).then((id) => {
+                        if (prev !== undefined && prev !== id)
+                            this.shown.delete(prev);
+                        if (c.caps.includes("actions")) {
+                            this.shown.set(id, { notice, home });
+                            if (notice.details?.decision)
+                                this.byDecision.set(notice.details.decision, id);
+                        }
+                        return id;
+                    });
+                    this.posting.add(posting);
+                    try {
+                        await posting;
+                    }
+                    finally {
+                        this.posting.delete(posting);
+                    }
+                    return true;
+                }
+                catch (e) {
+                    this.d.log(`alerts: Notify failed (${e.message.split("\n")[0]})`);
+                    try {
+                        c.n.disconnect();
+                    }
+                    catch { }
+                    if (this.conn === c) {
+                        this.conn = null;
+                        this.shown.clear();
+                        this.byDecision.clear();
+                    }
+                }
+            }
+            const ns = this.d.findNotifySend();
+            if (ns) {
+                const r = await this.d.run(ns, notifySendArgs(notice), this.d.env, 10_000);
+                if (r.code === 0)
+                    return true;
+                this.d.log(`alerts: notify-send failed${r.out.trim() ? ` (${r.out.trim().split("\n")[0]})` : ""}`);
+                return false;
+            }
+            if (!this.saidNone) {
+                this.saidNone = true;
+                this.d.log("alerts: none — no desktop session bus here (SSH or headless?) and no notify-send; decisions wait on pantheon board --watch and pantheon brief");
+            }
+            return false;
+        }
+        catch (e) {
+            this.d.log(`alerts: could not show a notice (${e.message.split("\n")[0]})`);
+            return false;
+        }
+    }
+    forget(id) {
+        const s = this.shown.get(id);
+        this.shown.delete(id);
+        const dec = s?.notice.details?.decision;
+        if (dec && this.byDecision.get(dec) === id)
+            this.byDecision.delete(dec);
+    }
+    onAction(id, action, token) {
+        if (!this.shown.has(id) && !this.posting.size)
+            return this.actions;
+        const inflight = [...this.posting];
+        const step = async () => {
+            if (inflight.length)
+                await Promise.allSettled(inflight);
+            const s = this.shown.get(id);
+            if (!s)
+                return;
+            if (action === "done") {
+                const hud = hudActionFor(s.notice, action);
+                if (!hud)
+                    return;
+                await this.runQueued(id, hud, s.home);
+            }
+            else if (action === "board" || action === "default") {
+                const display = this.d.env.DISPLAY || this.d.env.WAYLAND_DISPLAY ? {} : pickDisplay(this.d.sessionEnv());
+                const env = { ...this.d.env, ...display, ...(token ? { XDG_ACTIVATION_TOKEN: token, DESKTOP_STARTUP_ID: token } : {}) };
+                const opening = this.d.openBoard(env).catch(() => false).then(async (opened) => {
+                    if (!opened)
+                        await this.note("Open the board in a terminal", "Run pantheon board (or pantheon brief) to see everything that needs you.");
+                });
+                this.opening.add(opening);
+                void opening.finally(() => this.opening.delete(opening));
+            }
+        };
+        this.actions = this.actions.then(step).catch((e) => this.d.log(`alerts: a button failed (${e.message.split("\n")[0]})`));
+        return this.actions;
+    }
+    async runQueued(id, hud, home) {
+        const nonce = randomBytes(16).toString("hex");
+        writeHudAction(home, { ...hud, nonce });
+        const env = home === CONFIG_DIR ? this.d.env : { ...this.d.env, PANTHEON_HOME: home };
+        const [file, ...args] = this.d.cli;
+        const r = await this.d.run(file, [...args, "explain", "--queued", "--only-action", "--action-id", nonce], env, 60_000);
+        const lines = r.out.replace(/\u001b\[[0-9;]*m/g, "").trim().split("\n").filter(Boolean);
+        const took = lines.includes(`action ${nonce}`);
+        const said = lines.filter((l) => !/^action [0-9a-f]+$/.test(l)).pop() ?? "";
+        if (r.code === 0 && !took) {
+            this.d.log("alerts: Done was not sent (another click took the action first)");
+            await this.note("Not marked done", "Another click took that action first — open the board to check it.");
+            return;
+        }
+        if (r.code === 0) {
+            this.d.log(`alerts: Done → ${said || "sent"}`);
+            try {
+                await this.conn?.n.close(id);
+            }
+            catch { }
+            this.forget(id);
+        }
+        else {
+            this.d.log(`alerts: Done was not sent (${said || `exit ${r.code}`})`);
+            await this.note("Not marked done", said.replace(/^not sent:\s*/, "") || "Open the board to answer it there.");
+        }
+    }
+    async note(heading, body) {
+        const c = this.conn;
+        if (!c)
+            return;
+        await c.n.notify({ appName: "Pantheon", summary: noticeText(heading, LINUX_LIMITS.summary, false), body: noticeText(body, LINUX_LIMITS.line, c.caps.includes("body-markup")), urgency: 1, timeoutMs: 8_000 }).catch(() => { });
+    }
+    close() { try {
+        this.conn?.n.disconnect();
+    }
+    catch { } this.conn = null; this.shown.clear(); this.byDecision.clear(); }
+}
+export async function portalOpenUri(url, env = process.env, exists = existsSync) {
+    for (const path of sessionBusCandidates(env, exists)) {
+        let bus = null;
+        try {
+            bus = await DBus.connect(path, 3_000);
+            return await busPortalOpenUri(bus, url);
+        }
+        catch { }
+        finally {
+            try {
+                bus?.close();
+            }
+            catch { }
+        }
+    }
+    return false;
+}
+export function pickDisplay(env) {
+    const out = {};
+    for (const k of ["DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "XDG_CURRENT_DESKTOP", "XDG_SESSION_TYPE"])
+        if (env[k])
+            out[k] = env[k];
+    return out;
+}
+export function realSessionEnv(exec = (c, a) => execFileSync(c, a, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3_000 }), env = process.env, exists = existsSync, uid = typeof process.getuid === "function" ? process.getuid() : null) {
+    try {
+        const sd = pickDisplay(parseSystemdEnvironment(exec("systemctl", ["--user", "show-environment"])));
+        if (sd.DISPLAY || sd.WAYLAND_DISPLAY)
+            return sd;
+    }
+    catch { }
+    return logindDisplay(exec, env, exists, uid);
+}
+export function logindDisplay(exec, env, exists, uid) {
+    if (uid === null)
+        return {};
+    let list;
+    try {
+        list = exec("loginctl", ["list-sessions", "--no-legend"]);
+    }
+    catch {
+        return {};
+    }
+    for (const line of list.split("\n")) {
+        const [id, u] = line.trim().split(/\s+/);
+        if (!id || Number(u) !== uid || !/^[A-Za-z0-9_-]+$/.test(id))
+            continue;
+        let props;
+        try {
+            props = Object.fromEntries(exec("loginctl", ["show-session", id, "-p", "Type", "-p", "Remote", "-p", "Active", "-p", "Display", "-p", "State"])
+                .split("\n").map((l) => l.split("=", 2)).filter(([k]) => k));
+        }
+        catch {
+            continue;
+        }
+        if (props.Remote !== "no" || props.Active !== "yes" || (props.Type !== "x11" && props.Type !== "wayland"))
+            continue;
+        const out = { XDG_SESSION_TYPE: props.Type };
+        if (props.Display && /^:\d+(\.\d+)?$/.test(props.Display))
+            out.DISPLAY = props.Display;
+        if (props.Type === "wayland" && env.XDG_RUNTIME_DIR) {
+            for (const n of ["wayland-0", "wayland-1"])
+                if (exists(join(env.XDG_RUNTIME_DIR, n))) {
+                    out.WAYLAND_DISPLAY = n;
+                    break;
+                }
+        }
+        if (out.DISPLAY || out.WAYLAND_DISPLAY)
+            return out;
+    }
+    return {};
+}
+export function linuxDesktopReachable(env = process.env, sessionEnv = () => realSessionEnv(), host = () => hostEnv(env)) {
+    const h = host();
+    if (h.ephemeral)
+        return false;
+    if (h.desktop)
+        return true;
+    if (env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY)
+        return false;
+    const s = sessionEnv();
+    return !!(s.DISPLAY || s.WAYLAND_DISPLAY);
+}
+export function writeHudAction(home, hud) {
+    const f = join(home, "bin", ".hud-action.json");
+    mkdirSync(dirname(f), { recursive: true });
+    const tmp = `${f}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(hud), { mode: 0o600 });
+    renameSync(tmp, f);
+    return f;
+}
+function openBoardWith(cli, env) {
+    return new Promise((done) => {
+        const [file, ...args] = cli;
+        let settled = false;
+        const settle = (v) => { if (!settled) {
+            settled = true;
+            done(v);
+        } };
+        let child;
+        try {
+            child = spawn(file, [...args, "board", "--open"], { env, stdio: "ignore", detached: true });
+        }
+        catch {
+            settle(false);
+            return;
+        }
+        child.on("error", () => settle(false));
+        child.on("exit", (code) => settle(code === 0));
+        setTimeout(() => settle(true), 30_000).unref();
+        child.unref();
+    });
+}
+export async function probeLinuxAlerts(deps = {}) {
+    const env = deps.env ?? process.env;
+    const candidates = sessionBusCandidates(env, deps.exists ?? existsSync);
+    const open = deps.open ?? realOpen;
+    const errors = [];
+    for (const path of candidates) {
+        let n = null;
+        try {
+            n = await open(path);
+            const caps = await n.capabilities();
+            const info = await n.serverInfo().catch(() => null);
+            return caps.includes("actions")
+                ? { mode: "dbus-actions", line: `D-Bus notifications with actions (${serverLabel(info)})` }
+                : { mode: "dbus", line: `D-Bus notifications, no buttons — ${serverLabel(info)} does not offer actions; alerts still arrive, answer them on the board` };
+        }
+        catch (e) {
+            errors.push(e.message.split("\n")[0]);
+        }
+        finally {
+            try {
+                n?.disconnect();
+            }
+            catch { }
+        }
+    }
+    const ns = (deps.findNotifySend ?? (() => which("notify-send")))();
+    if (ns) {
+        return { mode: "notify-send", line: candidates.length
+                ? `notify-send, no buttons — the session bus did not answer Pantheon directly (${errors[0] ?? "no reply"})`
+                : "notify-send, no buttons — no session bus address in this environment, so alerts go through notify-send" };
+    }
+    return { mode: "none", line: candidates.length
+            ? `none — no notification server answered on the session bus (${errors[0] ?? "no reply"}); install one (dunst, mako) or use pantheon board --watch`
+            : "none — no desktop session bus (SSH or headless): use pantheon board --watch" };
+}
+let shared = null;
+export function showLinuxNotice(notice, home) {
+    shared ??= new LinuxAlerts();
+    return shared.show(notice, home);
+}
+//# sourceMappingURL=notice-linux.js.map