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

package/dist/win-host.js

@@ -0,0 +1,993 @@
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { dirname, join, resolve, win32 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CONFIG_DIR } from "./config.js";
+import { pidAlive } from "./file-lock.js";
+import { VERSION } from "./version.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const LEGACY_TASK_NAME = "Pantheon";
+const SID_RE = /^S-1-\d+(?:-\d+)+$/;
+export function parseWhoamiSid(out) {
+    const m = /"[^"]*"\s*,\s*"(S-1-[0-9-]+)"/.exec(out) ?? /\b(S-1-\d+(?:-\d+)+)\b/.exec(out);
+    const sid = m?.[1] ?? null;
+    return sid && SID_RE.test(sid) ? sid : null;
+}
+export function taskNameFor(sid, user = "") {
+    if (sid && SID_RE.test(sid))
+        return `${LEGACY_TASK_NAME}-${sid}`;
+    const safe = user.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 64);
+    return `${LEGACY_TASK_NAME}-${safe || "user"}`;
+}
+const sidCache = new WeakMap();
+export function userSid(exec) {
+    if (sidCache.has(exec))
+        return sidCache.get(exec);
+    let sid = null;
+    try {
+        sid = parseWhoamiSid(String(exec("whoami", ["/user", "/fo", "csv", "/nh"]) ?? ""));
+    }
+    catch {
+        sid = null;
+    }
+    sidCache.set(exec, sid);
+    return sid;
+}
+export function legacyTaskIsUsers(exec, env = process.env) {
+    let xml;
+    try {
+        const out = exec("schtasks", ["/Query", "/TN", LEGACY_TASK_NAME, "/XML"]);
+        xml = (Buffer.isBuffer(out) ? fromUtf16le(out) : String(out ?? "")).replace(/\0/g, "");
+    }
+    catch {
+        return false;
+    }
+    return taskIsUsers(xml, taskUserId(env.USERNAME ?? env.USER ?? "", env), userSid(exec));
+}
+export function recordedTaskName(home = CONFIG_DIR) {
+    try {
+        return /<URI>\\([^<]+)<\/URI>/.exec(fromUtf16le(readFileSync(hostFiles(home).taskXml)))?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export const taskName = (exec, env = process.env) => taskNameFor(userSid(exec), env.USERNAME ?? env.USER ?? "");
+export function taskIsUsers(xml, userId, sid) {
+    const ids = [...xml.matchAll(/<UserId>([^<]*)<\/UserId>/g)].map((m) => m[1].trim().toLowerCase());
+    if (!ids.length)
+        return false;
+    const mine = new Set([userId.toLowerCase(), ...(sid ? [sid.toLowerCase()] : [])]);
+    const bare = userId.includes("\\") ? userId.split("\\").pop().toLowerCase() : userId.toLowerCase();
+    return ids.every((id) => mine.has(id) || (!id.includes("\\") && !id.startsWith("s-1-") && id === bare));
+}
+export const HOST_KINDS = ["worker", "notifier"];
+export const HOST_CHILDREN = ["worker", "notifier", "tray"];
+export const isHostKind = (k) => HOST_KINDS.includes(k);
+export const HOST_RESTART_CODE = 75;
+export const hostDir = (home = CONFIG_DIR) => join(home, "host");
+export const hostFiles = (home = CONFIG_DIR) => {
+    const dir = hostDir(home);
+    return {
+        dir,
+        definition: (k) => join(dir, `${k}.json`),
+        disabled: (c) => join(dir, `${c}.disabled`),
+        restart: (c) => join(dir, `${c}.restart`),
+        stop: join(dir, "stop"),
+        trayStop: join(dir, "tray.stop"),
+        notices: join(dir, "notices"),
+        noticesSkipped: join(dir, "notices.skipped"),
+        launch: join(dir, "launch.txt"),
+        clm: join(dir, "clm"),
+        state: join(dir, "state.json"),
+        lock: join(dir, "host.lock"),
+        taskXml: join(dir, "task.xml"),
+        log: join(home, "logs", "host.log"),
+        childLog: (c) => join(home, "logs", `${c}.log`),
+    };
+};
+export function readDefinition(kind, home = CONFIG_DIR) {
+    try {
+        const d = JSON.parse(readFileSync(hostFiles(home).definition(kind), "utf8"));
+        if (!d || typeof d.cwd !== "string" || !Array.isArray(d.args) || !d.args.every((a) => typeof a === "string"))
+            return null;
+        return { kind, cwd: d.cwd, args: d.args };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeDefinition(def, home = CONFIG_DIR) {
+    const f = hostFiles(home).definition(def.kind);
+    writeAtomic(f, JSON.stringify({ kind: def.kind, cwd: def.cwd, args: def.args }, null, 2) + "\n");
+    return f;
+}
+function writeAtomic(f, text) {
+    mkdirSync(dirname(f), { recursive: true });
+    const tmp = `${f}.${process.pid}.tmp`;
+    writeFileSync(tmp, text);
+    try {
+        renameSync(tmp, f);
+    }
+    catch (e) {
+        rmSync(tmp, { force: true });
+        throw e;
+    }
+}
+export const HOST_BEAT_STALE_MS = 30_000;
+export function readHostState(home = CONFIG_DIR) {
+    try {
+        const s = JSON.parse(readFileSync(hostFiles(home).state, "utf8"));
+        return s && Number.isInteger(s.pid) && typeof s.beat === "number" ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function hostAlive(s, now = Date.now(), alive = pidAlive) {
+    return !!s && now - s.beat < HOST_BEAT_STALE_MS && s.beat - now < 60_000 && alive(s.pid);
+}
+export function hostChildRunning(c, home = CONFIG_DIR, now = Date.now(), alive = pidAlive) {
+    const s = readHostState(home);
+    if (!hostAlive(s, now, alive))
+        return null;
+    const r = s.children[c];
+    if (!r || r.phase !== "running" || !r.pid || !alive(r.pid))
+        return null;
+    return { ...r, pid: r.pid, hostPid: s.pid };
+}
+export const HOST_POLICY = { baseMs: 2_000, maxMs: 60_000, healthyMs: 10 * 60_000 };
+export const KILL_AGAIN_MS = 10_000;
+export const GIVE_UP_CODE = 64;
+export const initialSup = (p = HOST_POLICY) => ({
+    children: Object.fromEntries(HOST_CHILDREN.map((c) => [c, { phase: "stopped", delayMs: p.baseMs, restarts: 0 }])),
+    exiting: null,
+    done: false,
+});
+const clone = (s) => ({ ...s, children: Object.fromEntries(Object.entries(s.children).map(([k, v]) => [k, { ...v }])) });
+export function hostStep(prev, e, p = HOST_POLICY) {
+    const s = clone(prev);
+    const cmds = [];
+    if (s.done)
+        return { s, cmds };
+    const scheduleAfterExit = (c, ch, now, want, why, code = null) => {
+        const ranMs = ch.startedAt !== undefined ? now - ch.startedAt : 0;
+        if (ranMs >= p.healthyMs)
+            ch.delayMs = p.baseMs;
+        delete ch.pid;
+        delete ch.startedAt;
+        delete ch.stoppingAt;
+        delete ch.argv;
+        if (s.exiting !== null || want === null) {
+            ch.phase = "stopped";
+            delete ch.again;
+            delete ch.nextAt;
+            cmds.push({ do: "log", line: `${c}: ${why} — stays stopped` });
+            return;
+        }
+        if (code === GIVE_UP_CODE && !ch.again) {
+            ch.phase = "stopped";
+            delete ch.nextAt;
+            ch.gaveUp = "clm";
+            cmds.push({ do: "log", line: `${c}: ${why} — it cannot run in this session (PowerShell is in Constrained Language Mode); not started again until the next logon` });
+            return;
+        }
+        if (ch.again) {
+            delete ch.again;
+            delete ch.nextAt;
+            ch.delayMs = p.baseMs;
+            ch.phase = "running";
+            ch.key = want;
+            cmds.push({ do: "log", line: `${c}: ${why} — starting it again now` });
+            cmds.push({ do: "start", child: c, key: want });
+            return;
+        }
+        ch.restarts++;
+        ch.phase = "waiting";
+        ch.nextAt = now + ch.delayMs;
+        cmds.push({ do: "log", line: `${c}: ${why} — starting it again in ${Math.round(ch.delayMs / 1000)}s` });
+        ch.delayMs = Math.min(ch.delayMs * 2, p.maxMs);
+    };
+    switch (e.t) {
+        case "tick": {
+            if (s.exiting === null && (e.stop || e.restartHost)) {
+                s.exiting = e.stop ? 0 : HOST_RESTART_CODE;
+                cmds.push({ do: "log", line: e.stop ? "stop requested — stopping everything" : "a new Pantheon version is on disk — restarting the host on it" });
+            }
+            for (const c of HOST_CHILDREN) {
+                const ch = s.children[c];
+                const want = s.exiting !== null ? null : e.want[c];
+                if (ch.phase === "running") {
+                    if (want === null || want !== ch.key || e.restart.includes(c)) {
+                        if (want !== null)
+                            ch.again = true;
+                        ch.phase = "stopping";
+                        ch.stoppingAt = e.now;
+                        cmds.push({ do: "kill", child: c, pid: ch.pid });
+                    }
+                    continue;
+                }
+                if (ch.phase === "stopping") {
+                    if (ch.pid && ch.stoppingAt !== undefined && e.now - ch.stoppingAt >= KILL_AGAIN_MS) {
+                        ch.stoppingAt = e.now;
+                        cmds.push({ do: "kill", child: c, pid: ch.pid });
+                    }
+                    continue;
+                }
+                if (want === null) {
+                    if (ch.phase === "waiting") {
+                        ch.phase = "stopped";
+                        delete ch.nextAt;
+                    }
+                    continue;
+                }
+                const restartNow = e.restart.includes(c);
+                if (ch.gaveUp && !restartNow)
+                    continue;
+                if (ch.phase === "stopped" || restartNow || (ch.nextAt !== undefined && e.now >= ch.nextAt)) {
+                    if (restartNow) {
+                        ch.delayMs = p.baseMs;
+                        delete ch.gaveUp;
+                    }
+                    delete ch.nextAt;
+                    ch.phase = "running";
+                    ch.key = want;
+                    cmds.push({ do: "start", child: c, key: want });
+                }
+            }
+            if (s.exiting !== null && HOST_CHILDREN.every((c) => s.children[c].phase === "stopped")) {
+                s.done = true;
+                cmds.push({ do: "exit", code: s.exiting });
+            }
+            break;
+        }
+        case "started": {
+            const ch = s.children[e.child];
+            ch.pid = e.pid;
+            ch.startedAt = e.now;
+            ch.phase = "running";
+            if (e.argv)
+                ch.argv = [...e.argv];
+            else
+                delete ch.argv;
+            break;
+        }
+        case "spawnFailed": {
+            const ch = s.children[e.child];
+            ch.startedAt = e.now;
+            scheduleAfterExit(e.child, ch, e.now, e.want, `could not start (${e.error})`);
+            break;
+        }
+        case "exited": {
+            const ch = s.children[e.child];
+            ch.lastExit = e.code !== null ? String(e.code) : (e.signal ?? "unknown");
+            scheduleAfterExit(e.child, ch, e.now, e.want, `exited (${e.code !== null ? `code ${e.code}` : e.signal ?? "no code"})`, e.code);
+            if (s.exiting !== null && HOST_CHILDREN.every((c) => s.children[c].phase === "stopped")) {
+                s.done = true;
+                cmds.push({ do: "exit", code: s.exiting });
+            }
+            break;
+        }
+    }
+    return { s, cmds };
+}
+export function hostReport(s, pid, started, now, version = VERSION, session) {
+    const children = {};
+    for (const c of HOST_CHILDREN) {
+        const ch = s.children[c];
+        children[c] = {
+            phase: ch.phase, restarts: ch.restarts,
+            ...(ch.pid ? { pid: ch.pid } : {}), ...(ch.startedAt && ch.pid ? { since: ch.startedAt } : {}),
+            ...(ch.lastExit !== undefined ? { lastExit: ch.lastExit } : {}), ...(ch.nextAt !== undefined ? { nextAt: ch.nextAt } : {}),
+            ...(ch.pid && ch.argv ? { argv: ch.argv } : {}), ...(ch.gaveUp ? { gaveUp: ch.gaveUp } : {}),
+        };
+    }
+    return { pid, version, started, beat: now, ...(session ? { session } : {}), children };
+}
+export class HostLoop {
+    io;
+    policy;
+    pid;
+    s;
+    started;
+    constructor(io, policy = HOST_POLICY, pid = process.pid) {
+        this.io = io;
+        this.policy = policy;
+        this.pid = pid;
+        this.s = initialSup(policy);
+        this.started = io.now();
+    }
+    feed(e) {
+        const { s, cmds } = hostStep(this.s, e, this.policy);
+        this.s = s;
+        for (const c of cmds) {
+            if (c.do === "log")
+                this.io.log(c.line);
+            else if (c.do === "kill") {
+                try {
+                    this.io.kill(c.child, c.pid);
+                }
+                catch (err) {
+                    this.io.log(`${c.child}: could not stop pid ${c.pid} (${err.message})`);
+                }
+            }
+            else if (c.do === "start") {
+                const now = this.io.now();
+                let started;
+                try {
+                    started = this.io.start(c.child, (code, signal) => this.exited(c.child, code, signal));
+                }
+                catch (err) {
+                    this.feed({ t: "spawnFailed", child: c.child, now, error: err.message.split("\n")[0], want: this.io.want().want[c.child] });
+                    continue;
+                }
+                const pid = typeof started === "number" ? started : started.pid;
+                this.io.log(`${c.child}: started, pid ${pid}`);
+                this.feed({ t: "started", child: c.child, pid, now, ...(typeof started === "number" ? {} : { argv: started.argv }) });
+            }
+            else if (c.do === "exit") {
+                this.writeState();
+                this.io.exit(c.code);
+            }
+        }
+    }
+    writeState() { try {
+        this.io.writeState(hostReport(this.s, this.pid, this.started, this.io.now(), VERSION, this.io.session));
+    }
+    catch { } }
+    tick() {
+        const { want, installed } = this.io.want();
+        const stop = this.io.stopRequested() || this.io.parentGone() || installed === 0;
+        const restartHost = !stop && this.io.newVersion() && !this.io.workerBusy();
+        this.feed({ t: "tick", now: this.io.now(), want, restart: this.io.takeRestarts(), stop, restartHost });
+        if (!this.s.done)
+            this.writeState();
+    }
+    exited(child, code, signal) {
+        this.feed({ t: "exited", child, code, signal, now: this.io.now(), want: this.io.want().want[child] });
+        if (!this.s.done)
+            this.writeState();
+    }
+}
+export const trayScriptPath = () => resolve(HERE, "..", "helper", "windows", "pantheon-tray.ps1");
+export const trayIconPath = () => resolve(HERE, "..", "helper", "windows", "pantheon.ico");
+export const noticeScriptPath = () => resolve(HERE, "..", "helper", "windows", "pantheon-notice.ps1");
+export const psQuote = (s) => `'${s.replace(/'/g, "''")}'`;
+export const CLM_GUARD = `if ($ExecutionContext.SessionState.LanguageMode -ne 'FullLanguage') { exit ${GIVE_UP_CODE} }`;
+export function trayArgv(script, pantheon, home, extra = {}, powershell = windowsPowerShell()) {
+    const more = [
+        ...(extra.icon ? [`-Icon ${psQuote(extra.icon)}`] : []),
+        ...(extra.notices ? [`-NoticeScript ${psQuote(extra.notices)}`] : []),
+    ];
+    return [powershell, "-NoProfile", "-NonInteractive", "-WindowStyle", "Hidden", "-Command",
+        `${CLM_GUARD}; & ([scriptblock]::Create([IO.File]::ReadAllText(${psQuote(script)}))) -Pantheon ${psQuote(pantheon)} -Home ${psQuote(home)}${more.map((m) => ` ${m}`).join("")}`];
+}
+export const trayQuitText = (session, at = new Date()) => `quit session=${session} at=${at.toISOString()}\n`;
+export function trayQuitHolds(home, session) {
+    let text;
+    try {
+        text = readFileSync(hostFiles(home).disabled("tray"), "utf8");
+    }
+    catch {
+        return false;
+    }
+    return /\bsession=([A-Za-z0-9_.:-]+)/.exec(text)?.[1] === session;
+}
+export function clearTrayQuit(home = CONFIG_DIR) {
+    const f = hostFiles(home);
+    const had = existsSync(f.disabled("tray"));
+    try {
+        rmSync(f.disabled("tray"), { force: true });
+    }
+    catch { }
+    return had;
+}
+export function clearStaleTrayQuit(home, session) {
+    if (!existsSync(hostFiles(home).disabled("tray")) || trayQuitHolds(home, session))
+        return false;
+    return clearTrayQuit(home);
+}
+export function hostSession(env = process.env, pid = process.pid) {
+    const s = env.PANTHEON_HOST_SESSION;
+    return s && /^[A-Za-z0-9_.:-]{8,80}$/.test(s) ? s : `local-${pid}`;
+}
+export function splitWindowsCommandLine(line) {
+    const out = [];
+    let i = 0;
+    const n = line.length;
+    while (i < n && /[ \t]/.test(line[i]))
+        i++;
+    if (i >= n)
+        return out;
+    let prog = "";
+    if (line[i] === '"') {
+        i++;
+        while (i < n && line[i] !== '"')
+            prog += line[i++];
+        i++;
+    }
+    else
+        while (i < n && !/[ \t]/.test(line[i]))
+            prog += line[i++];
+    out.push(prog);
+    for (;;) {
+        while (i < n && /[ \t]/.test(line[i]))
+            i++;
+        if (i >= n)
+            return out;
+        let cur = "", inQ = false;
+        while (i < n) {
+            const c = line[i];
+            if (c === "\\") {
+                let j = i;
+                while (j < n && line[j] === "\\")
+                    j++;
+                const bs = j - i;
+                if (line[j] === '"') {
+                    cur += "\\".repeat(Math.floor(bs / 2));
+                    if (bs % 2) {
+                        cur += '"';
+                        i = j + 1;
+                    }
+                    else
+                        i = j;
+                }
+                else {
+                    cur += "\\".repeat(bs);
+                    i = j;
+                }
+            }
+            else if (c === '"') {
+                if (inQ && line[i + 1] === '"') {
+                    cur += '"';
+                    i += 2;
+                }
+                else {
+                    inQ = !inQ;
+                    i++;
+                }
+            }
+            else if (!inQ && (c === " " || c === "\t"))
+                break;
+            else {
+                cur += c;
+                i++;
+            }
+        }
+        out.push(cur);
+    }
+}
+export function provenOrphan(r, info, toleranceMs = 10_000) {
+    if (!info?.cmd || !info.startedMs || !r.argv?.length || !r.since)
+        return false;
+    if (Math.abs(info.startedMs - r.since) > toleranceMs)
+        return false;
+    const got = splitWindowsCommandLine(info.cmd);
+    const want = r.argv;
+    return got.length === want.length && got.every((a, i) => (i === 0 ? a.toLowerCase() === want[0].toLowerCase() : a === want[i]));
+}
+export function windowsPowerShell(env = process.env) {
+    const root = env.SystemRoot ?? env.windir ?? env.WINDIR ?? "C:\\Windows";
+    return `${root}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+}
+export function childArgv(kind, args, node, flags, cli) {
+    return [node, ...flags, cli, kind, ...args];
+}
+const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
+function openLog(f) {
+    mkdirSync(dirname(f), { recursive: true });
+    try {
+        if (statSync(f).size > LOG_ROTATE_BYTES)
+            renameSync(f, `${f}.1`);
+    }
+    catch { }
+    return openSync(f, "a");
+}
+const RUN_RECORD = "worker-run.json";
+export function realHostIo(o = {}) {
+    const home = o.home ?? CONFIG_DIR;
+    const f = hostFiles(home);
+    const node = o.node ?? process.execPath;
+    const flags = o.flags ?? [];
+    const cli = o.cli ?? resolve(HERE, "cli.js");
+    const pantheon = o.pantheonCommand ?? `"${node}" ${flags.join(" ")} "${cli}"`.replace(/\s+/g, " ");
+    const session = o.session ?? hostSession();
+    const parent = process.ppid;
+    let versionAt = 0, versionChanged = false;
+    const hardKill = (pid) => {
+        if (process.platform === "win32") {
+            const r = spawn("taskkill", ["/T", "/F", "/PID", String(pid)], { stdio: "ignore", windowsHide: true });
+            r.on("error", () => { try {
+                process.kill(pid);
+            }
+            catch { } });
+        }
+        else
+            process.kill(pid, "SIGTERM");
+    };
+    return {
+        session,
+        now: () => Date.now(),
+        want: () => {
+            const want = {};
+            let installed = 0;
+            for (const k of HOST_KINDS) {
+                const d = readDefinition(k, home);
+                if (d)
+                    installed++;
+                want[k] = d && !existsSync(f.disabled(k)) ? JSON.stringify([d.cwd, d.args]) : null;
+            }
+            const tray = trayScriptPath();
+            want.tray = existsSync(tray) && !existsSync(f.disabled("tray")) ? tray : null;
+            return { want, installed };
+        },
+        takeRestarts: () => HOST_CHILDREN.filter((c) => {
+            if (!existsSync(f.restart(c)))
+                return false;
+            try {
+                rmSync(f.restart(c), { force: true });
+            }
+            catch { }
+            return true;
+        }),
+        stopRequested: () => existsSync(f.stop),
+        newVersion: () => {
+            if (Date.now() - versionAt < 30_000)
+                return versionChanged;
+            versionAt = Date.now();
+            try {
+                const v = JSON.parse(readFileSync(resolve(dirname(cli), "..", "package.json"), "utf8")).version;
+                versionChanged = !!v && VERSION !== "unknown" && v !== VERSION;
+            }
+            catch { }
+            return versionChanged;
+        },
+        workerBusy: () => {
+            try {
+                const r = JSON.parse(readFileSync(join(home, RUN_RECORD), "utf8"));
+                return typeof r.at === "number" && Date.now() - r.at < 3 * 3600_000 && !!r.pid && pidAlive(r.pid);
+            }
+            catch {
+                return false;
+            }
+        },
+        parentGone: () => parent > 1 && !pidAlive(parent),
+        start: (child, onExit) => {
+            const m = o.managed;
+            if (m && !existsSync(m.pkgDir) && existsSync(join(m.prevDir, "bin", "pantheon.js"))) {
+                try {
+                    renameSync(m.prevDir, m.pkgDir);
+                }
+                catch { }
+            }
+            let argv;
+            let cwd = homedir();
+            if (child === "tray") {
+                const asked = Number(readFileSafe(f.trayStop));
+                if (!(Number.isInteger(asked) && asked > 0 && pidAlive(asked))) {
+                    try {
+                        rmSync(f.trayStop, { force: true });
+                    }
+                    catch { }
+                }
+                const icon = trayIconPath(), notices = noticeScriptPath();
+                argv = trayArgv(trayScriptPath(), pantheon, home, { icon: existsSync(icon) ? icon : null, notices: existsSync(notices) ? notices : null });
+            }
+            else {
+                const d = readDefinition(child, home);
+                if (!d)
+                    throw new Error(`no ${child} definition`);
+                argv = childArgv(child, d.args, node, flags, cli);
+                if (existsSync(d.cwd))
+                    cwd = d.cwd;
+            }
+            const fd = openLog(f.childLog(child));
+            try {
+                writeSync(fd, `\n--- ${new Date().toISOString()} the Pantheon host starts the ${child}\n`);
+                const proc = spawn(argv[0], argv.slice(1), { cwd, stdio: ["ignore", fd, fd], windowsHide: true, env: { ...process.env, PANTHEON_HOST_SESSION: session } });
+                let done = false;
+                const finish = (code, signal) => { if (!done) {
+                    done = true;
+                    onExit(code, signal);
+                } };
+                if (!proc.pid) {
+                    proc.on("error", () => { });
+                    throw new Error(`could not start ${argv[0]}`);
+                }
+                proc.on("error", () => finish(null, "error"));
+                proc.on("exit", (code, signal) => finish(code, signal));
+                return { pid: proc.pid, argv };
+            }
+            finally {
+                closeSync(fd);
+            }
+        },
+        kill: (child, pid) => {
+            if (child !== "tray") {
+                hardKill(pid);
+                return;
+            }
+            try {
+                mkdirSync(f.dir, { recursive: true });
+                writeFileSync(f.trayStop, String(pid));
+            }
+            catch { }
+            const t = setTimeout(() => { if (pidAlive(pid)) {
+                try {
+                    hardKill(pid);
+                }
+                catch { }
+            } }, o.trayGraceMs ?? 5_000);
+            t.unref?.();
+        },
+        writeState: (s) => writeAtomic(f.state, JSON.stringify(s) + "\n"),
+        log: (line) => {
+            try {
+                mkdirSync(dirname(f.log), { recursive: true });
+                writeFileSync(f.log, `${new Date().toISOString()} ${line}\n`, { flag: "a" });
+            }
+            catch { }
+        },
+        exit: (code) => process.exit(code),
+    };
+}
+export const HOST_LOCK_STARTUP_GRACE_MS = 2 * 60_000;
+export function takeHostLock(home = CONFIG_DIR, pid = process.pid, now = Date.now, alive = pidAlive) {
+    const f = hostFiles(home);
+    mkdirSync(f.dir, { recursive: true });
+    let lastHolder = -1;
+    for (let i = 0; i < 4; i++) {
+        try {
+            const fd = openSync(f.lock, "wx");
+            writeSync(fd, String(pid));
+            closeSync(fd);
+            return null;
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+        }
+        const held = Number(readFileSafe(f.lock));
+        let age = 0;
+        try {
+            age = now() - statSync(f.lock).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        if (Number.isInteger(held) && held > 0) {
+            lastHolder = held;
+            if (held === pid)
+                return null;
+            if (alive(held) && (hostAlive(readHostState(home)) || age < HOST_LOCK_STARTUP_GRACE_MS))
+                return held;
+        }
+        else if (age < 10_000) {
+            return lastHolder;
+        }
+        const gone = `${f.lock}.stale-${pid}-${i}`;
+        try {
+            renameSync(f.lock, gone);
+        }
+        catch {
+            continue;
+        }
+        rmSync(gone, { force: true });
+    }
+    return lastHolder;
+}
+const readFileSafe = (p) => { try {
+    return readFileSync(p, "utf8").trim();
+}
+catch {
+    return "";
+} };
+export function orphans(prev, isOurs, alive = pidAlive, self = process.pid) {
+    if (!prev || prev.pid === self || alive(prev.pid))
+        return [];
+    const out = [];
+    for (const c of HOST_CHILDREN) {
+        const r = prev.children[c];
+        if (r?.pid && (r.phase === "running" || r.phase === "stopping") && alive(r.pid) && isOurs(r.pid, r))
+            out.push([c, r.pid]);
+    }
+    return out;
+}
+export function runHost(o = {}) {
+    const home = o.home ?? CONFIG_DIR;
+    const f = hostFiles(home);
+    const io = realHostIo(o);
+    process.on("uncaughtException", (e) => { io.log(`host crashed: ${e.stack ?? e.message}`); process.exit(1); });
+    const other = takeHostLock(home);
+    if (other) {
+        io.log(`another host is running (pid ${other}) — this one leaves`);
+        process.exit(0);
+    }
+    rmSync(f.stop, { force: true });
+    if (clearStaleTrayQuit(home, io.session))
+        io.log("tray: it was quit in an earlier session — showing it again");
+    io.log(`host ${VERSION} starts (pid ${process.pid}, session ${io.session})`);
+    for (const [c, pid] of orphans(readHostState(home), o.isOurs ?? (() => false))) {
+        io.log(`${c}: pid ${pid} was left running by a host that is gone — stopping it before starting a new one`);
+        try {
+            io.kill(c, pid);
+        }
+        catch { }
+    }
+    const loop = new HostLoop({ ...io, exit: (code) => { rmSync(f.state, { force: true }); rmSync(f.lock, { force: true }); io.log(`host exits (${code === HOST_RESTART_CODE ? "to start again on the new version" : "stopped"})`); process.exit(code); } });
+    loop.tick();
+    setInterval(() => loop.tick(), o.tickMs ?? 2_000);
+}
+export function winQuote(a) {
+    if (a.length > 0 && !/[\s"]/.test(a))
+        return a;
+    let out = '"', bs = 0;
+    for (const ch of a) {
+        if (ch === "\\") {
+            bs++;
+            continue;
+        }
+        if (ch === '"') {
+            out += "\\".repeat(bs * 2 + 1) + '"';
+        }
+        else
+            out += "\\".repeat(bs) + ch;
+        bs = 0;
+    }
+    return out + "\\".repeat(bs * 2) + '"';
+}
+export const hostArgv = (o) => [o.node, ...o.flags, o.cli, "host"];
+export const launchFileText = (argv) => {
+    if (argv.some((a) => /[\r\n]/.test(a) || a === ""))
+        throw new Error(`a path with a line break in it cannot be started by the task: ${JSON.stringify(argv)}`);
+    return argv.join("\r\n") + "\r\n";
+};
+export function powershellHostLoop(o) {
+    const baked = `@(${o.argv.map(psQuote).join(", ")})`;
+    return [
+        `$env:PANTHEON_HOST_SESSION = [guid]::NewGuid().ToString('N')`,
+        ...(o.home ? [`$env:PANTHEON_HOME = ${psQuote(o.home)}`] : []),
+        `$d = 2; $gone = $null`,
+        `while ($true) {` +
+            ` $a = @(); try { $a = @(Get-Content -LiteralPath ${psQuote(o.launch)} -Encoding UTF8 -ErrorAction Stop | Where-Object { $_ }) } catch { $a = @() };` +
+            ` if ($a.Count -lt 1 -or -not (Test-Path -LiteralPath $a[0] -PathType Leaf)) { $a = ${baked} };` +
+            ` if (-not (Test-Path -LiteralPath $a[0] -PathType Leaf)) { if ($null -eq $gone) { $gone = Get-Date }; if (((Get-Date) - $gone).TotalSeconds -ge ${o.graceSeconds ?? 600}) { exit 3 }; Start-Sleep -Seconds $d; $d = [Math]::Min($d * 2, 60); continue };` +
+            ` $gone = $null; $t = Get-Date;` +
+            ` & $a[0] @($a | Select-Object -Skip 1); $c = $LASTEXITCODE;` +
+            ` if ($c -eq 0) { exit 0 }; if ($c -eq ${HOST_RESTART_CODE}) { $d = 2; continue };` +
+            ` if (((Get-Date) - $t).TotalMinutes -ge 10) { $d = 2 }; Start-Sleep -Seconds $d; $d = [Math]::Min($d * 2, 60)` +
+            ` }`,
+    ].join("; ");
+}
+export function hostLaunch(o) {
+    const argv = hostArgv(o);
+    const launch = o.launch ?? win32.join(o.home ?? CONFIG_DIR, "host", "launch.txt");
+    if (o.shim) {
+        const args = [...(o.home ? ["--env", `PANTHEON_HOME=${o.home}`] : []), "--launch", launch, "--", ...argv];
+        return { command: o.shim, arguments: args.map(winQuote).join(" "), how: "shim" };
+    }
+    const run = powershellHostLoop({ argv, launch, home: o.home });
+    return { command: o.powershell ?? windowsPowerShell(), arguments: `-NoProfile -NonInteractive -WindowStyle Hidden -Command "${run}"`, how: "powershell" };
+}
+const xmlText = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+export function taskXml(o) {
+    const user = xmlText(o.userId);
+    return [
+        `<?xml version="1.0" encoding="UTF-16"?>`,
+        `<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">`,
+        `  <RegistrationInfo>`,
+        `    <Author>${user}</Author>`,
+        `    <Description>${xmlText(o.description ?? "Pantheon: keeps the worker, desktop alerts and the tray icon running while you are logged on. Remove with: pantheon service uninstall worker (and notifier), or pantheon uninstall.")}</Description>`,
+        `    <URI>\\${xmlText(o.name)}</URI>`,
+        `  </RegistrationInfo>`,
+        `  <Triggers>`,
+        `    <LogonTrigger>`,
+        `      <Enabled>true</Enabled>`,
+        `      <UserId>${user}</UserId>`,
+        `    </LogonTrigger>`,
+        `  </Triggers>`,
+        `  <Principals>`,
+        `    <Principal id="Author">`,
+        `      <UserId>${user}</UserId>`,
+        `      <LogonType>InteractiveToken</LogonType>`,
+        `      <RunLevel>LeastPrivilege</RunLevel>`,
+        `    </Principal>`,
+        `  </Principals>`,
+        `  <Settings>`,
+        `    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>`,
+        `    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>`,
+        `    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>`,
+        `    <AllowHardTerminate>true</AllowHardTerminate>`,
+        `    <StartWhenAvailable>false</StartWhenAvailable>`,
+        `    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>`,
+        `    <IdleSettings>`,
+        `      <StopOnIdleEnd>false</StopOnIdleEnd>`,
+        `      <RestartOnIdle>false</RestartOnIdle>`,
+        `    </IdleSettings>`,
+        `    <AllowStartOnDemand>true</AllowStartOnDemand>`,
+        `    <Enabled>true</Enabled>`,
+        `    <Hidden>false</Hidden>`,
+        `    <RunOnlyIfIdle>false</RunOnlyIfIdle>`,
+        `    <WakeToRun>false</WakeToRun>`,
+        `    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>`,
+        `    <Priority>5</Priority>`,
+        `    <RestartOnFailure>`,
+        `      <Interval>PT1M</Interval>`,
+        `      <Count>999</Count>`,
+        `    </RestartOnFailure>`,
+        `  </Settings>`,
+        `  <Actions Context="Author">`,
+        `    <Exec>`,
+        `      <Command>${xmlText(o.launch.command)}</Command>`,
+        `      <Arguments>${xmlText(o.launch.arguments)}</Arguments>`,
+        `      <WorkingDirectory>${xmlText(o.workingDirectory)}</WorkingDirectory>`,
+        `    </Exec>`,
+        `  </Actions>`,
+        `</Task>`,
+        ``,
+    ].join("\r\n");
+}
+export const utf16le = (text) => Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(text, "utf16le")]);
+export const fromUtf16le = (b) => (b[0] === 0xff && b[1] === 0xfe ? b.subarray(2) : b).toString("utf16le");
+export const taskUserId = (user, env = process.env) => env.USERDOMAIN && user && !user.includes("\\") ? `${env.USERDOMAIN}\\${user}` : user;
+export const shimSourcePath = () => resolve(HERE, "..", "helper", "windows", "pantheon-host.cs");
+export function cscCandidates(env = process.env) {
+    const root = env.SystemRoot ?? env.windir ?? env.WINDIR;
+    if (!root)
+        return [];
+    return ["Framework64", "FrameworkArm64", "Framework"].map((fw) => `${root}\\Microsoft.NET\\${fw}\\v4.0.30319\\csc.exe`);
+}
+export function ensureHostShim(o) {
+    const exists = o.exists ?? existsSync;
+    const source = o.source ?? shimSourcePath();
+    let hash;
+    try {
+        hash = createHash("sha256").update(readFileSync(source)).digest("hex").slice(0, 12);
+    }
+    catch {
+        return null;
+    }
+    const out = join(o.home ?? CONFIG_DIR, "bin", `pantheon-host-${hash}.exe`);
+    if (exists(out))
+        return out;
+    const csc = cscCandidates(o.env).find((c) => exists(c));
+    if (!csc) {
+        o.log?.("  no csc.exe here (.NET Framework 4) — the task starts the host through PowerShell");
+        return null;
+    }
+    try {
+        mkdirSync(dirname(out), { recursive: true });
+        o.exec(csc, ["/nologo", "/target:winexe", "/optimize+", `/out:${out}`, source]);
+    }
+    catch (e) {
+        o.log?.(`  could not compile the host launcher (${e.message.split("\n")[0]}) — the task starts the host through PowerShell`);
+        return null;
+    }
+    if (!exists(out))
+        return null;
+    try {
+        for (const n of readdirSync(dirname(out))) {
+            if (/^pantheon-host-[0-9a-f]{12}\.exe$/.test(n) && join(dirname(out), n) !== out) {
+                try {
+                    rmSync(join(dirname(out), n), { force: true });
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    return out;
+}
+function taskQuery(exec, name) {
+    try {
+        exec("schtasks", ["/Query", "/TN", name]);
+        return true;
+    }
+    catch (e) {
+        return e.code === "ENOENT" ? null : false;
+    }
+}
+export function windowsFacts(exec, home = CONFIG_DIR, now = Date.now(), trayShipped = existsSync(trayScriptPath())) {
+    const f = hostFiles(home);
+    const name = taskName(exec);
+    const taskRegistered = taskQuery(exec, name);
+    const legacyTask = legacyTaskIsUsers(exec);
+    let launch = null;
+    try {
+        const cmd = /<Command>([^<]*)<\/Command>/.exec(fromUtf16le(readFileSync(f.taskXml)))?.[1] ?? "";
+        launch = /pantheon-host-[0-9a-f]+\.exe$/i.test(cmd) ? "shim" : cmd ? "powershell" : null;
+    }
+    catch { }
+    const state = readHostState(home);
+    const hostUp = hostAlive(state, now);
+    const by = (fn) => Object.fromEntries(HOST_KINDS.map((k) => [k, fn(k)]));
+    const trayReport = hostUp ? state?.children.tray : undefined;
+    return {
+        taskName: name, taskRegistered, legacyTask, launch, state, hostUp, now,
+        installed: by((k) => existsSync(f.definition(k))),
+        disabled: by((k) => existsSync(f.disabled(k))),
+        running: by((k) => !!hostChildRunning(k, home, now)),
+        tray: { shipped: trayShipped, quit: existsSync(f.disabled("tray")), running: !!hostChildRunning("tray", home, now) },
+        clm: trayReport?.gaveUp === "clm" || existsSync(f.clm),
+    };
+}
+export function windowsDoctorRows(x) {
+    const rows = [];
+    const any = x.installed.worker || x.installed.notifier;
+    if (!any) {
+        rows.push({ level: "warn", name: "background", detail: "nothing runs in the background here — no worker, no desktop alerts, no tray",
+            fix: `pantheon service install worker   and   pantheon service install notifier   (one Task Scheduler task, ${x.taskName}, starts them at logon; no admin rights needed)`, share: "no Windows background services" });
+        return rows;
+    }
+    if (x.taskRegistered === false) {
+        rows.push({ level: "warn", name: "task", detail: `the ${x.taskName} task is not registered in Task Scheduler — nothing starts the worker or alerts at logon${x.legacyTask ? ` (a "${LEGACY_TASK_NAME}" task from an older Pantheon is; installing replaces it)` : ""}`,
+            fix: `pantheon service install ${x.installed.worker ? "worker" : "notifier"}   (registers it again)`, share: x.legacyTask ? "task missing, legacy task present" : "task missing" });
+    }
+    else if (x.taskRegistered) {
+        rows.push({ level: x.launch === "powershell" ? "warn" : "pass", name: "task",
+            detail: x.launch === "powershell"
+                ? `${x.taskName}, at logon — through PowerShell, because no csc.exe (.NET Framework 4) was found to build pantheon-host.exe: a console may show for a moment at logon`
+                : `${x.taskName}, at logon, hidden (pantheon-host.exe), as you, without admin rights`,
+            ...(x.launch === "powershell" ? { fix: "harmless; with the .NET Framework 4.8 feature on, pantheon service install worker builds the hidden launcher" } : {}),
+            share: x.launch === "powershell" ? "registered, PowerShell launch" : "registered" });
+    }
+    if (x.hostUp && x.state) {
+        const restarts = HOST_CHILDREN.map((c) => [c, x.state.children[c]?.restarts ?? 0]).filter(([, n]) => n > 0);
+        rows.push({ level: "pass", name: "host", detail: `running (pid ${x.state.pid}, ${x.state.version})${restarts.length ? ` — restarted ${restarts.map(([c, n]) => `the ${c} ${n}×`).join(", ")}` : ""}`,
+            share: "running" });
+    }
+    else {
+        rows.push({ level: "warn", name: "host", detail: "not running — the worker, alerts and tray are all down until it starts",
+            fix: `pantheon service start ${x.installed.worker ? "worker" : "notifier"}   (or log out and back in; its log: ~/.pantheon/logs/host.log)`, share: "not running" });
+    }
+    const one = (k, name, what, off) => {
+        if (!x.installed[k]) {
+            rows.push({ level: "warn", name, detail: `not installed — ${off}`, fix: `pantheon service install ${k}`, share: "not installed" });
+        }
+        else if (x.disabled[k]) {
+            rows.push({ level: "warn", name, detail: `paused (pantheon stop, or Pause in the tray) — ${off}`, fix: `pantheon service start ${k}`, share: "paused" });
+        }
+        else if (x.running[k]) {
+            rows.push({ level: "pass", name, detail: `running under the host — ${what}`, share: "running" });
+        }
+        else if (x.hostUp) {
+            const r = x.state?.children[k];
+            const next = r?.nextAt ? `, starting again in ${Math.max(0, Math.round((r.nextAt - x.now) / 1000))}s` : "";
+            rows.push({ level: "warn", name, detail: `not running${r?.lastExit ? ` — last exit ${r.lastExit}` : ""}${next}`, fix: `its log: pantheon logs ${k}`, share: "not running" });
+        }
+        else {
+            rows.push({ level: "warn", name, detail: `not running — the host is down`, fix: `pantheon service start ${k}`, share: "host down" });
+        }
+    };
+    one("worker", "worker svc", "a teammate's request can start an agent run here while you are away", "teammates' requests wait for you");
+    one("notifier", "alerts", x.clm ? "but PowerShell runs in Constrained Language Mode here, so Windows shows none of its alerts" : "a desktop alert when a teammate needs you", "no desktop alert when a teammate needs you");
+    if (x.clm && x.installed.notifier) {
+        const last = rows[rows.length - 1];
+        if (last.level === "pass")
+            Object.assign(last, { level: "warn", fix: "your IT's policy (AppLocker or WDAC) sets it; pantheon board (in a browser) and pantheon brief show the same", share: "running, Constrained Language Mode" });
+    }
+    if (x.tray.shipped) {
+        if (x.clm) {
+            rows.push({ level: "warn", name: "tray", detail: "not shown — PowerShell runs in Constrained Language Mode here (an IT policy), which refuses what the tray icon needs; it is not retried until you log in again",
+                fix: "pantheon board   (the same view in a browser)", share: "Constrained Language Mode" });
+        }
+        else if (x.tray.quit) {
+            rows.push({ level: "warn", name: "tray", detail: "you quit it from its menu — it comes back when you next log in",
+                fix: "pantheon tray   (shows it again now)", share: "quit" });
+        }
+        else if (x.tray.running) {
+            rows.push({ level: "pass", name: "tray", detail: "in the notification area — what needs you, Open board, Pause", share: "running" });
+        }
+        else if (x.hostUp) {
+            const r = x.state?.children.tray;
+            rows.push({ level: "warn", name: "tray", detail: `not running${r?.lastExit ? ` — last exit ${r.lastExit}` : ""}`, fix: "its log: ~/.pantheon/logs/tray.log; pantheon tray starts it again", share: "not running" });
+        }
+        else {
+            rows.push({ level: "warn", name: "tray", detail: "not running — the host is down", fix: `pantheon service start ${x.installed.worker ? "worker" : "notifier"}`, share: "host down" });
+        }
+    }
+    return rows;
+}
+//# sourceMappingURL=win-host.js.map