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

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