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

package/dist/client.js

@@ -21,6 +21,7 @@ export class PantheonClient {
     seen = new Map();
     backoff = 500;
     closed = false;
+    disposed = false;
     everConnected = false;
     localOverride = null;
     usingLoopback = false;
@@ -170,6 +171,11 @@ export class PantheonClient {
     }
     attempt(address) {
         return new Promise((resolve, reject) => {
+            if (this.disposed) {
+                this.closed = true;
+                reject(new Error("this client was disposed"));
+                return;
+            }
             let settled = false;
             let heard = false;
             const fail = reject;
@@ -195,6 +201,8 @@ export class PantheonClient {
             this.watchdog.unref?.();
             ws.on("open", () => { });
             ws.on("message", (raw) => {
+                if (this.disposed)
+                    return;
                 this.lastInbound = Date.now();
                 let msg;
                 try {
@@ -438,6 +446,14 @@ export class PantheonClient {
         this.waiters = [];
         this.ws?.close(4000, "handover");
     }
+    dispose() {
+        this.disposed = true;
+        this.close();
+        if (this.watchdog) {
+            clearInterval(this.watchdog);
+            this.watchdog = null;
+        }
+    }
     close() {
         this.closed = true;
         for (const w of this.waiters) {

package/dist/command-state.js

@@ -5,6 +5,7 @@ import { chooseAgent, claudeSandboxable, NOT_FOR_UNATTENDED_RUNS, parseRepoComma
 import { detectClaudeFeatures } from "./claude-confine.js";
 import { loadPersonas } from "./persona.js";
 import { plistPath, existingUnitPath } from "./service.js";
+import { readDefinition } from "./win-host.js";
 import { loadPolicy, unsandboxedAllowed } from "./worker-policy.js";
 export function workerServiceAllowsBash(plat = platform()) {
     try {
@@ -17,7 +18,7 @@ export function workerServiceAllowsBash(plat = platform()) {
             return args.includes("--allow-bash");
         }
         if (plat === "win32")
-            return null;
+            return readDefinition("worker")?.args.includes("--allow-bash") ?? null;
         const u = existingUnitPath("worker");
         if (!u)
             return null;

package/dist/dbus.js

@@ -193,6 +193,7 @@ export function encodeMessage(m) {
     f(FIELD.error_name, "s", m.error_name);
     f(FIELD.reply_serial, "u", m.reply_serial);
     f(FIELD.destination, "s", m.destination);
+    f(FIELD.sender, "s", m.sender);
     f(FIELD.signature, "g", m.signature || undefined);
     const head = new Writer();
     head.byte("l".charCodeAt(0));
@@ -363,6 +364,32 @@ export class DBus {
     onClose(h) { this.closedHandlers.push(h); }
     close() { this.sock?.end(); this.sock = null; }
 }
+export async function portalOpenUri(bus, uri, waitMs = 3_000) {
+    const REQ = "org.freedesktop.portal.Request";
+    await bus.call({ destination: "org.freedesktop.DBus", path: "/org/freedesktop/DBus", interface: "org.freedesktop.DBus", member: "AddMatch", signature: "s",
+        body: [`type='signal',interface='${REQ}',member='Response'`] });
+    const responses = new Map();
+    let handle = null;
+    let answered = null;
+    bus.onSignal((m) => {
+        if (m.interface !== REQ || m.member !== "Response" || !m.path)
+            return;
+        const code = Number(m.body[0]);
+        if (handle === m.path && answered)
+            answered(code);
+        else
+            responses.set(m.path, code);
+    });
+    const r = await bus.call({ destination: "org.freedesktop.portal.Desktop", path: "/org/freedesktop/portal/desktop", interface: "org.freedesktop.portal.OpenURI",
+        member: "OpenURI", signature: "ssa{sv}", body: ["", uri, []] }, 10_000);
+    handle = String(r.body[0] ?? "");
+    const early = responses.get(handle);
+    const code = early ?? await new Promise((done) => {
+        const t = setTimeout(() => done(null), waitMs);
+        answered = (c) => { clearTimeout(t); done(c); };
+    });
+    return code === null || code === 0 || code === 1;
+}
 const N = { destination: "org.freedesktop.Notifications", path: "/org/freedesktop/Notifications", interface: "org.freedesktop.Notifications" };
 export class Notifications {
     bus;
@@ -377,33 +404,84 @@ export class Notifications {
         const n = new Notifications(b);
         await b.call({ destination: "org.freedesktop.DBus", path: "/org/freedesktop/DBus", interface: "org.freedesktop.DBus", member: "AddMatch", signature: "s",
             body: ["type='signal',interface='org.freedesktop.Notifications',path='/org/freedesktop/Notifications'"] });
+        await b.call({ destination: "org.freedesktop.DBus", path: "/org/freedesktop/DBus", interface: "org.freedesktop.DBus", member: "AddMatch", signature: "s",
+            body: [`type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',arg0='${N.destination}'`] });
         b.onSignal((m) => {
-            if (m.interface !== N.interface)
+            if (m.sender === "org.freedesktop.DBus" && m.interface === "org.freedesktop.DBus" && m.member === "NameOwnerChanged" && m.body[0] === N.destination) {
+                n.serverChanged(String(m.body[2] ?? "") || null);
                 return;
-            const id = Number(m.body[0]);
-            if (m.member === "ActivationToken")
-                n.tokens.set(id, String(m.body[1] ?? ""));
-            else if (m.member === "ActionInvoked") {
-                const tok = n.tokens.get(id);
-                for (const h of n.actionHandlers)
-                    h(id, String(m.body[1] ?? ""), tok);
-            }
-            else if (m.member === "NotificationClosed") {
-                n.tokens.delete(id);
-                for (const h of n.closedHandlers)
-                    h(id, Number(m.body[1] ?? 0));
             }
+            if (m.interface !== N.interface || m.path !== N.path)
+                return;
+            void n.fromServer(m.sender).then((ok) => {
+                if (!ok)
+                    return;
+                const id = Number(m.body[0]);
+                if (m.member === "ActivationToken")
+                    n.tokens.set(id, String(m.body[1] ?? ""));
+                else if (m.member === "ActionInvoked") {
+                    const tok = n.tokens.get(id);
+                    for (const h of n.actionHandlers)
+                        h(id, String(m.body[1] ?? ""), tok);
+                }
+                else if (m.member === "NotificationClosed") {
+                    n.tokens.delete(id);
+                    for (const h of n.closedHandlers)
+                        h(id, Number(m.body[1] ?? 0));
+                }
+            });
         });
         return n;
     }
+    owner = null;
+    lookup = null;
+    serverChangeHandlers = [];
+    serverChanged(owner) {
+        const was = this.owner;
+        this.owner = owner;
+        if (was === owner)
+            return;
+        this.tokens.clear();
+        for (const h of this.serverChangeHandlers) {
+            try {
+                h();
+            }
+            catch { }
+        }
+    }
+    fromServer(sender) {
+        if (!sender)
+            return Promise.resolve(false);
+        if (sender === this.owner)
+            return Promise.resolve(true);
+        this.lookup ??= this.bus.call({ destination: "org.freedesktop.DBus", path: "/org/freedesktop/DBus", interface: "org.freedesktop.DBus", member: "GetNameOwner", signature: "s", body: [N.destination] })
+            .then((r) => String(r.body[0] ?? "") || null, () => null)
+            .finally(() => { this.lookup = null; });
+        return this.lookup.then((o) => {
+            if (o && this.owner && o !== this.owner)
+                this.serverChanged(o);
+            else if (o)
+                this.owner = o;
+            return !!o && sender === o;
+        });
+    }
+    onServerChange(h) { this.serverChangeHandlers.push(h); }
     async capabilities() {
         const r = await this.bus.call({ ...N, member: "GetCapabilities" });
         return r.body[0] ?? [];
     }
+    async serverInfo() {
+        const r = await this.bus.call({ ...N, member: "GetServerInformation" });
+        const [name = "", vendor = "", version = "", spec = ""] = r.body.map(String);
+        return { name, vendor, version, spec };
+    }
     async notify(n) {
         const hints = [["urgency", { sig: "y", value: n.urgency ?? 1 }]];
         if (n.urgency === 2)
             hints.push(["resident", { sig: "b", value: true }]);
+        for (const h of n.hints ?? [])
+            if (!hints.some(([k]) => k === h[0]))
+                hints.push(h);
         const r = await this.bus.call({ ...N, member: "Notify", signature: "susssasa{sv}i", body: [
                 n.appName ?? "Pantheon", n.replacesId ?? 0, n.icon ?? "", n.summary, n.body ?? "",
                 (n.actions ?? []).flat(), hints, n.timeoutMs ?? -1,
@@ -413,6 +491,7 @@ export class Notifications {
     async close(id) { await this.bus.call({ ...N, member: "CloseNotification", signature: "u", body: [id] }).catch(() => { }); }
     onAction(h) { this.actionHandlers.push(h); }
     onClosed(h) { this.closedHandlers.push(h); }
+    onDisconnect(h) { this.bus.onClose(h); }
     disconnect() { this.bus.close(); }
 }
 //# sourceMappingURL=dbus.js.map

package/dist/doctor.js

@@ -12,6 +12,7 @@ import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { dirname, join, resolve, sep } from "node:path";
 import { expectedLauncher, managedLayout, runtimeNodeFit, runtimeVerdict } from "./managed.js";
+import { compareVersions } from "./installer.js";
 import { PKG_NAME } from "./upgrade.js";
 import { PantheonClient } from "./client.js";
 import { load, resolveFor, loadAll, CONFIG_PATH } from "./config.js";
@@ -23,7 +24,8 @@ import { workerProc, menubarProc, notifierProc } from "./machine.js";
 import { agentById, chooseAgent, describeChoice, unattendedRefusal, skippedSummary, SANDBOXED_FOR_UNATTENDED } from "./agents.js";
 import { loginShellLookup, npmSpawn, onPathNamed, which, whichWindows } from "./which.js";
 import { VERSION } from "./version.js";
-import { serviceInstalled, servicesUnavailable } from "./service.js";
+import { realSys, serviceInstalled, servicesUnavailable } from "./service.js";
+import { windowsDoctorRows, windowsFacts } from "./win-host.js";
 import { hasPrebuilt } from "./helpers-build.js";
 import { traySourcePath, TRAY_PREBUILT } from "./tray.js";
 import { hudSourcePath, HUD_PREBUILT } from "./notifier.js";
@@ -63,7 +65,7 @@ export function userScopeWiring(home = homedir(), present = onPathNamed, env = p
     };
     const server = (key) => (d) => !!d[key]?.["pantheon"];
     const out = [];
-    if (present("claude")) {
+    if (present("claude") || existsSync(join(home, ".claude"))) {
         const f = join(home, ".claude.json");
         out.push({ agent: "Claude Code", file: f, state: json(f, server("mcpServers")) });
     }
@@ -176,8 +178,13 @@ export async function doctor(projectDir) {
     if (host.ephemeral) {
         add("warn", "machine", `${platformName(host.platform)} in ${host.kind === "container" ? "a container" : "a cloud workspace"} — ${host.evidence.join("; ")}`, `this is not the computer you work on, which is why it reports ${platformName(host.platform)} to someone who may be sitting at a Mac. The team and your account are fine here, but the menu bar, desktop alerts and the worker belong on your own machine — run the setup from a terminal there.`, `${host.platform} in ${host.kind === "container" ? "a container" : "a cloud workspace"}`);
     }
+    else if (host.platform === "win32") {
+        add("pass", "machine", `Windows${host.desktop ? " — the background host, desktop alerts and the tray icon can run here" : " — a remote shell (SSH): the background host's alerts and tray need a session at the desktop"}`, undefined, `win32${host.desktop ? ", desktop" : ""}`);
+        for (const r of windowsDoctorRows(windowsFacts(realSys().exec)))
+            add(r.level, r.name, r.detail, r.fix, r.share);
+    }
     else {
-        add("pass", "machine", `${platformName(host.platform)}${host.desktop ? " — menu bar and desktop alerts can run here" : " — no menu bar or desktop alerts here yet; ask your agent for pantheon_status, or run pantheon brief, to see what needs you"}`, undefined, `${host.platform}${host.desktop ? ", desktop" : ""}`);
+        add("pass", "machine", `${platformName(host.platform)}${host.desktop ? (host.platform === "linux" ? " — desktop alerts can run here (the menu bar is macOS-only; pantheon board is the view)" : " — menu bar and desktop alerts can run here") : " — no menu bar or desktop alerts here yet; ask your agent for pantheon_status, or run pantheon brief, to see what needs you"}`, undefined, `${host.platform}${host.desktop ? ", desktop" : ""}`);
     }
     let cfg = null;
     try {
@@ -386,12 +393,19 @@ export async function doctor(projectDir) {
             add("pass", "relay", `reachable at ${health}`, undefined, `reachable (${where})`);
         }
         if (body.ok || body.storage) {
-            if (body.pkg && body.pkg !== VERSION) {
+            const held = typeof body.upgrades_held_at === "string" ? body.upgrades_held_at : null;
+            if (held && body.pkg === held && VERSION !== held && compareVersions(VERSION, held) > 0) {
+                add("pass", "version", `${VERSION}; the relay is holding upgrades at ${held} for now, so this machine stays where it is`, undefined, `${VERSION}, upgrades held at ${held}`);
+            }
+            else if (body.pkg && body.pkg !== VERSION) {
                 add("warn", "version", `this machine is ${VERSION}, the relay is ${body.pkg}`, "run `pantheon upgrade` on the older side — features land on both halves of the wire, and the protocol version cannot tell you they are missing", `this machine ${VERSION}, relay ${body.pkg}`);
             }
             else if (body.pkg) {
                 add("pass", "version", `${VERSION}, matching the relay`, undefined, `${VERSION}, matching the relay`);
             }
+            else if (typeof body.relay_pkg === "string") {
+                add("pass", "version", `${VERSION}; the relay runs ${body.relay_pkg}, a prerelease, and tells no machine to upgrade`, undefined, `relay prerelease ${body.relay_pkg}`);
+            }
             else {
                 add("warn", "version", `this machine is ${VERSION}; the relay is too old to report its own`, "update the relay host, then re-run this", `this machine ${VERSION}; relay too old to say`);
             }
@@ -545,7 +559,24 @@ export async function doctor(projectDir) {
                 add("warn", "sandbox", `${missing.join(" and ")} not found — Claude Code's sandbox cannot start, so every woken command run will be refused`, "install them: sudo apt install bubblewrap socat (Debian/Ubuntu) or sudo dnf install bubblewrap socat (Fedora)", `sandbox tools missing: ${missing.join(", ")}`);
         }
     }
-    if (host.desktop) {
+    if (host.platform === "linux" && !host.ephemeral) {
+        const { probeLinuxAlerts } = await import("./notice-linux.js");
+        const probe = await probeLinuxAlerts().catch((e) => ({ mode: "none", line: `none — ${e.message.split("\n")[0]}` }));
+        const installedN = serviceInstalled("notifier");
+        if (probe.mode === "none") {
+            add(host.desktop || installedN ? "warn" : "pass", "alerts", probe.line, host.desktop || installedN ? "decisions still wait in pantheon board --watch and pantheon brief; on a desktop, a notification server (GNOME Shell, Plasma, dunst, mako) shows them" : undefined, "none");
+        }
+        else if (!installedN) {
+            add("warn", "alerts", `not installed — this desktop would show them as ${probe.line}`, "pantheon service install notifier   (--no-notifications at setup also leaves it off; that is fine if it was your choice)", "not installed");
+        }
+        else if (!notifierProc().running) {
+            add("warn", "alerts", "installed, but not running — nothing on this desktop will show you a teammate's message", "pantheon service restart notifier   (journalctl --user -u pantheon-notifier says why it stopped)", "installed, not running");
+        }
+        else {
+            add("pass", "alerts", probe.line, undefined, probe.mode);
+        }
+    }
+    if (host.desktop && host.platform === "darwin") {
         const needsTools = (name, source) => hasPrebuilt(name, source) ? "" : "needs the Xcode Command Line Tools — xcode-select --install — because this build has no prebuilt helper for it; ";
         if (!serviceInstalled("menubar")) {
             add("warn", "menu bar", "not installed on a Mac that can run it", `install it with: pantheon service install menubar (${needsTools(TRAY_PREBUILT, traySourcePath())}from a setup that ran on this computer, not in a cloud agent). --no-menubar at setup also leaves it off; that is fine if it was your choice`, "not installed");

package/dist/folder-guard.js

@@ -0,0 +1,89 @@
+import { realpathSync } from "node:fs";
+import { homedir, platform, tmpdir } from "node:os";
+import path from "node:path";
+function isOneDriveRoot(dir, f, p) {
+    if ((f.oneDriveRoots ?? []).some((r) => same(dir, r, p)))
+        return true;
+    const d = p.resolve(dir);
+    return same(p.dirname(d), f.home, p) && /^OneDrive( - .+)?$/i.test(p.basename(d));
+}
+export const TEMP_FOLDER_ADVICE = "open your agent in your project folder, or bind one with pantheon use <team> --here from there";
+export function isInside(child, parent, p = path) {
+    if (!child || !parent)
+        return false;
+    const rel = p.relative(p.resolve(parent), p.resolve(child));
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${p.sep}`) && !p.isAbsolute(rel));
+}
+const same = (a, b, p) => p.relative(p.resolve(a), p.resolve(b)) === "";
+export function folderRefusal(here, f, p = path) {
+    const dir = p.resolve(here);
+    if (p.dirname(dir) === dir)
+        return { kind: "root", why: "this is the root of the disk" };
+    if (same(dir, f.home, p))
+        return { kind: "home", why: "this is your home folder" };
+    if (isInside(f.home, dir, p))
+        return { kind: "above-home", why: "this folder holds your home folder" };
+    if (["Downloads", "Desktop", "Documents", "Library", "tmp"].some((n) => same(dir, p.join(f.home, n), p))) {
+        return { kind: "catch-all", why: `this is your ${p.basename(dir)} folder, which holds unrelated things` };
+    }
+    if (p.sep === "\\") {
+        if (isOneDriveRoot(dir, f, p))
+            return { kind: "catch-all", why: `this is your OneDrive folder, which holds everything you sync` };
+        if (/^(Desktop|Documents|Pictures)$/i.test(p.basename(dir)) && isOneDriveRoot(p.dirname(dir), f, p)) {
+            return { kind: "catch-all", why: `this is your ${p.basename(dir)} folder (in OneDrive), which holds unrelated things` };
+        }
+        const appData = p.join(f.home, "AppData");
+        if (same(dir, appData, p) || ["Local", "LocalLow", "Roaming"].some((n) => same(dir, p.join(appData, n), p))) {
+            return { kind: "catch-all", why: `this is ${p.basename(dir) === "AppData" ? "your AppData folder" : `AppData\\${p.basename(dir)}`}, where every program keeps its own data` };
+        }
+    }
+    const parts = dir.split(p.sep === "\\" ? /[\\/]+/ : /\/+/);
+    const scratch = parts.findIndex((s, i) => i > 0 && s.toLowerCase() === "scratch-workspaces" && parts[i - 1].toLowerCase() === "claude");
+    if (scratch > 0 || f.appDirs.some((a) => isInside(dir, a, p))) {
+        return { kind: "app-scratch", why: `this is a scratch workspace of the Claude app, a temporary folder that goes away; ${TEMP_FOLDER_ADVICE}` };
+    }
+    const root = f.tempRoots.find((r) => isInside(dir, r, p) && !isInside(f.home, r, p));
+    if (root)
+        return { kind: "temporary", why: `this is a temporary folder (${root}) that goes away; ${TEMP_FOLDER_ADVICE}` };
+    return null;
+}
+const real = (d) => { try {
+    return realpathSync.native(d);
+}
+catch {
+    return path.resolve(d);
+} };
+export function folderFacts(env = process.env, os = platform()) {
+    const home = real(homedir());
+    const roots = new Set();
+    const add = (set, d) => { if (d) {
+        set.add(path.resolve(d));
+        set.add(real(d));
+    } };
+    add(roots, tmpdir());
+    for (const k of ["TMPDIR", "TEMP", "TMP"])
+        add(roots, env[k]);
+    if (env["LOCALAPPDATA"])
+        add(roots, path.join(env["LOCALAPPDATA"], "Temp"));
+    if (os !== "win32")
+        for (const d of ["/tmp", "/private/tmp", "/var/tmp", "/private/var/tmp", "/var/folders", "/private/var/folders"])
+            add(roots, d);
+    const apps = new Set();
+    if (os === "darwin")
+        add(apps, path.join(home, "Library", "Application Support", "Claude"));
+    if (os === "win32") {
+        add(apps, path.join(env["APPDATA"] ?? path.join(home, "AppData", "Roaming"), "Claude"));
+    }
+    if (os === "linux")
+        add(apps, path.join(env["XDG_CONFIG_HOME"] ?? path.join(home, ".config"), "Claude"));
+    const oneDrive = new Set();
+    if (os === "win32")
+        for (const k of ["OneDrive", "OneDriveCommercial", "OneDriveConsumer"])
+            add(oneDrive, env[k]);
+    return { home, tempRoots: [...roots], appDirs: [...apps], ...(oneDrive.size ? { oneDriveRoots: [...oneDrive] } : {}) };
+}
+export function folderRefusalHere(dir) {
+    return folderRefusal(real(dir), folderFacts());
+}
+export const isTemporaryRefusal = (r) => r?.kind === "temporary" || r?.kind === "app-scratch";
+//# sourceMappingURL=folder-guard.js.map

package/dist/git-safe.js

@@ -77,7 +77,7 @@ const hasGitLfs = () => {
     if (lfsBinary !== null)
         return lfsBinary;
     try {
-        execFileSync("git-lfs", ["version"], { stdio: "ignore", timeout: 10_000 });
+        execFileSync("git-lfs", ["version"], { windowsHide: true, stdio: "ignore", timeout: 10_000 });
         lfsBinary = true;
     }
     catch {
@@ -94,7 +94,7 @@ export function lfsInUse(cwd) {
     }
     catch { }
     try {
-        return execFileSync("git", ["-c", "core.fsmonitor=false", "-c", `core.hooksPath=${noHooksDir()}`, "config", "--get", "filter.lfs.clean"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 }).trim().length > 0;
+        return execFileSync("git", ["-c", "core.fsmonitor=false", "-c", `core.hooksPath=${noHooksDir()}`, "config", "--get", "filter.lfs.clean"], { cwd, encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 }).trim().length > 0;
     }
     catch {
         return false;
@@ -217,7 +217,7 @@ function inspect(worktree, a, snapshot = false) {
 }
 function commonOf(project) {
     try {
-        const out = execFileSync("git", [...gitHarden(), "rev-parse", "--git-common-dir"], { cwd: project, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, GIT_CONFIG_NOSYSTEM: "1" }, timeout: 10_000 }).trim();
+        const out = execFileSync("git", [...gitHarden(), "rev-parse", "--git-common-dir"], { cwd: project, encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, GIT_CONFIG_NOSYSTEM: "1" }, timeout: 10_000 }).trim();
         return real(resolve(project, out));
     }
     catch {

package/dist/host-env.js

@@ -34,6 +34,8 @@ export function hostEnv(env = process.env, plat = process.platform, exists = exi
     if (plat === "darwin") {
         return { platform: plat, kind: "local", evidence: [], ephemeral: false, desktop: true };
     }
+    if (plat === "win32")
+        return windowsHostEnv(env);
     const evidence = [];
     let kind = "local";
     for (const [name, label] of CLOUD_VARS) {
@@ -82,9 +84,43 @@ export function hostEnv(env = process.env, plat = process.platform, exists = exi
         kind,
         evidence,
         ephemeral: kind !== "local",
-        desktop: false,
+        desktop: plat === "linux" && kind === "local" && linuxGraphicalSession(env, wsl),
     };
 }
+export function windowsHostEnv(env = process.env) {
+    const evidence = [];
+    let kind = "local";
+    for (const [name, label] of CLOUD_VARS) {
+        if (env[name]) {
+            evidence.push(label);
+            kind = "cloud-workspace";
+        }
+    }
+    for (const [name, label] of CONTAINER_VARS)
+        if (env[name])
+            evidence.push(label);
+    const user = (env.USERNAME ?? "").toLowerCase();
+    if (user === "containeradministrator" || user === "containeruser")
+        evidence.push(`the user is ${env.USERNAME}, a Windows container's account`);
+    if (evidence.length && kind === "local")
+        kind = "container";
+    const ssh = !!(env.SSH_CONNECTION || env.SSH_CLIENT);
+    return { platform: "win32", kind, evidence, ephemeral: kind !== "local", desktop: kind === "local" && !ssh };
+}
+export function linuxGraphicalSession(env, wsl = !!env.WSL_DISTRO_NAME) {
+    if (wsl)
+        return false;
+    const display = env.DISPLAY ?? "";
+    const forwarded = /^[^:]+:/.test(display);
+    const ssh = !!(env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY);
+    if (env.WAYLAND_DISPLAY)
+        return true;
+    if (ssh)
+        return !!display && !forwarded && env.XDG_SESSION_TYPE !== "tty";
+    if (display)
+        return true;
+    return env.XDG_SESSION_TYPE === "x11" || env.XDG_SESSION_TYPE === "wayland";
+}
 export const platformName = (p) => p === "win32" ? "Windows" : p === "darwin" ? "macOS" : p === "linux" ? "Linux" : p;
 export function ephemeralWarning(host) {
     return `this looks like ${host.kind === "container" ? "a container" : "a cloud workspace"}, not the computer you work on `
@@ -93,11 +129,21 @@ export function ephemeralWarning(host) {
         + `the session. Your account and team are fine — run the same setup from a terminal on your own computer to finish it.`;
 }
 export function desktopUnavailable(host, what) {
+    if (what === "the menu bar" && host.platform === "linux" && !host.ephemeral)
+        return "not available — the menu bar is macOS-only; on Linux, pantheon board shows what needs you";
     if (host.desktop)
         return null;
+    if (host.platform === "linux" && !host.ephemeral && what === "desktop alerts") {
+        return "not available — desktop alerts need a graphical login session, and this Linux shell has none (SSH or headless); pantheon board --watch shows what needs you";
+    }
     if (host.ephemeral) {
         return `not available — ${what} ${what === "desktop alerts" ? "need" : "needs"} your own computer, and this is ${host.kind === "container" ? "a container" : "a cloud workspace"} reporting ${platformName(host.platform)}`;
     }
+    if (host.platform === "win32") {
+        return what === "the menu bar"
+            ? "not available — the menu bar is macOS's; on Windows the Pantheon tray icon runs with the background host, from a session at the desktop"
+            : "not available — desktop alerts need the Windows desktop, and this is a remote shell (SSH); set Pantheon up from a session at the desktop";
+    }
     return `not available — ${what} ${host.platform === "darwin" ? "could not be built here" : `${what === "desktop alerts" ? "are" : "is"} macOS-only, and this machine is ${platformName(host.platform)}`}`;
 }
 //# sourceMappingURL=host-env.js.map

package/dist/install.js

@@ -12,6 +12,8 @@ import { FEEDBACK_ADDRESS } from "./feedback.js";
 import { kiroDir, kiroAgentFile, refreshKiroAgentAllowed } from "./kiro-files.js";
 import { eolOf, isJsonc, stripBom, stripJsonc, withEol } from "./text-file.js";
 import { childNodeFlags, managedLayout, managedLauncher } from "./managed.js";
+import { claudeHomeConflict, claudeJsonFile, claudeUserEntryShape, mergeClaudeUserEntry, removeClaudeUserEntry } from "./claude-config.js";
+import { inWokenRun } from "./worker-policy.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export function onPath() {
     return onPathNamed("pantheon");
@@ -255,11 +257,38 @@ export function claudeAddFailed(e, command) {
     const why = said || (err.message ?? "failed").split("\n")[0];
     return `failed: claude mcp add did not work (${why}) — fix: run \`${command}\` yourself to see why, then pantheon install --user`;
 }
-function claudeUserScope(entry) {
+export const CLAUDE_DIRECT_NOTE = "written to ~/.claude.json directly (no claude CLI here) — the Claude desktop app and Claude Code read it";
+export function claudeUserScope(entry, present = true, claudeBin = which("claude"), home = homedir(), direct = false) {
     const tool = "claude code";
-    const claudeBin = which("claude");
-    if (!claudeBin)
-        return { tool, where: "-", status: "skipped (claude not on PATH)" };
+    if (!claudeBin) {
+        if (!present)
+            return { tool, where: "-", status: "skipped (claude not on PATH)" };
+        const file = claudeJsonFile(home);
+        const conflict = claudeHomeConflict();
+        if (conflict)
+            return { tool, where: "-", status: `skipped (claude not on PATH) — ${conflict}` };
+        if (!direct || inWokenRun()) {
+            const there = (() => { try {
+                const d = JSON.parse(stripBom(readFileSync(file, "utf8")));
+                return d?.mcpServers?.["pantheon"];
+            }
+            catch {
+                return undefined;
+            } })();
+            return there !== undefined && JSON.stringify(there) === JSON.stringify(claudeUserEntryShape(entry))
+                ? { tool, where: file, status: `unchanged — ${CLAUDE_DIRECT_NOTE}` }
+                : { tool, where: "-", status: "skipped (claude not on PATH here) — run pantheon install --user yourself to write ~/.claude.json directly" };
+        }
+        try {
+            const r = mergeClaudeUserEntry(file, entry, isOurMcpEntry);
+            if (r === "not ours")
+                return { tool, where: file, status: `failed: ${file} already has an MCP server called "pantheon" that Pantheon did not write — rename or remove it, then run pantheon install --user` };
+            return { tool, where: file, status: `${r} — ${CLAUDE_DIRECT_NOTE}` };
+        }
+        catch (e) {
+            return { tool, where: file, status: `failed: ${e.message}` };
+        }
+    }
     try {
         const remove = agentSpawn(claudeBin, ["mcp", "remove", "pantheon", "-s", "user"]);
         const add = agentSpawn(claudeBin, ["mcp", "add", "pantheon", "-s", "user", "--", entry.command, ...entry.args]);
@@ -277,8 +306,11 @@ function claudeUserScope(entry) {
 function claudeLocalScope(entry, projectDir) {
     const tool = "claude code";
     const claudeBin = which("claude");
-    if (!claudeBin)
-        return { tool, where: "-", status: "skipped (claude not on PATH) — once Claude Code is installed, run `pantheon install` here again" };
+    if (!claudeBin) {
+        return existsSync(join(homedir(), ".claude"))
+            ? { tool, where: "-", status: "skipped (claude not on PATH) — the user-scope entry is in ~/.claude.json, but this folder's own entry can only be written by the claude CLI, and this repo's committed .mcp.json (which starts pantheon by a name Windows cannot run) may be read first; once claude is on PATH, run `pantheon install` here again" }
+            : { tool, where: "-", status: "skipped (claude not on PATH) — once Claude Code is installed, run `pantheon install` here again" };
+    }
     try {
         const remove = agentSpawn(claudeBin, ["mcp", "remove", "pantheon", "-s", "local"]);
         const add = agentSpawn(claudeBin, ["mcp", "add", "pantheon", "-s", "local", "--", entry.command, ...entry.args]);
@@ -686,13 +718,13 @@ export function chosenApproval() {
         return "approve";
     }
 }
-export function installForUser(approval = chosenApproval(), present = agentPresence()) {
+export function installForUser(approval = chosenApproval(), present = agentPresence(), opts = {}) {
     const entry = userEntry();
     const said = (s) => /^(granted|already granted)/.test(s)
         ? `${s} — ${approval === "ask-before-sending" ? "reads run without asking; send, open_goal and claim prompt" : `the ${PANTHEON_TOOL_NAMES.length} pantheon tools run without asking`}`
         : s;
     return [
-        claudeUserScope(entry), cursorUserScope(entry, present.cursor), codexUserScope(entry, approval, present.codex),
+        claudeUserScope(entry, present.claude, undefined, undefined, !!opts.direct), cursorUserScope(entry, present.cursor), codexUserScope(entry, approval, present.codex),
         copilotUserScope(entry), vsCodeUserScope(entry), kiroUserScope(entry, approval),
         present.claude
             ? { tool: "claude perms", where: claudeSettingsFile(), status: said(grantClaudeToolPermissions(undefined, approval)) }
@@ -702,6 +734,24 @@ export function installForUser(approval = chosenApproval(), present = agentPrese
             : { tool: "cursor perms", where: "-", status: "skipped (Cursor not found on this machine)" },
     ];
 }
+export function agentAsksOnce(tools) {
+    const asks = [
+        [/^claude code$/i, "claude", `claude   say yes once if it asks to trust this folder`],
+        [/^cursor$/i, "cursor", `cursor   enable the "pantheon" MCP server if it asks`],
+        [/^codex$/i, "codex", `codex    run /hooks inside codex once to approve the wake-up hook`],
+        [/^kiro$/i, "kiro", `kiro     run kiro-cli chat --agent pantheon (or kiro-cli agent set-default pantheon) to keep working while a teammate waits; stay signed in — a woken run never starts Kiro signed out, since Kiro would open a browser`],
+        [/^copilot$/i, "copilot", `copilot  say yes once when it asks to trust this folder; on a Copilot Business or Enterprise plan an org owner must have the "MCP servers in Copilot" policy on`],
+    ];
+    const out = new Map();
+    for (const t of tools) {
+        if (/^(skipped|failed|could not)|unavailable|not found/i.test(t.status))
+            continue;
+        for (const [row, key, line] of asks)
+            if (row.test(t.tool))
+                out.set(key, line);
+    }
+    return [...out.values()];
+}
 export function isOurMcpEntry(e) {
     if (!e || typeof e !== "object")
         return false;
@@ -759,8 +809,24 @@ export function removeUserMcpEntries(deps = {}) {
         if (os === "win32" && deps.project)
             claudeRemove("local", `Claude Code's pantheon entry for ${deps.project} (local scope)`, deps.project);
     }
-    else if (os === "win32" && deps.project) {
-        left.push(`any Claude Code entry for ${deps.project} (local scope) — claude is not on PATH here; once it is: claude mcp remove pantheon -s local, run in that folder`);
+    else {
+        const file = claudeJsonFile(home);
+        const conflict = deps.home === undefined ? claudeHomeConflict() : null;
+        if (conflict)
+            left.push(`Claude Code's pantheon MCP server, if any — ${conflict}`);
+        else
+            try {
+                const r = removeClaudeUserEntry(file, isOurMcpEntry);
+                if (r === "removed")
+                    removed.push(`Claude Code's pantheon MCP server (user scope, ${file})`);
+                else if (r === "not ours")
+                    left.push(`an entry named "pantheon" in ${file} that Pantheon did not write — yours to keep or delete`);
+            }
+            catch (e) {
+                left.push(`Claude Code's pantheon MCP server (${e.message}) — delete the "pantheon" server under "mcpServers" in ${file} by hand, with Claude closed`);
+            }
+        if (os === "win32" && deps.project)
+            left.push(`any Claude Code entry for ${deps.project} (local scope) — claude is not on PATH here; once it is: claude mcp remove pantheon -s local, run in that folder`);
     }
     const files = [
         ["Cursor", join(home, ".cursor", "mcp.json"), "mcpServers"],

package/dist/installer.js

@@ -29,8 +29,9 @@ export function installerScript(name, dir = INSTALLER_DIR, version = VERSION) {
 export const NPM_PACKAGE = "@join-pantheon/cli";
 export const NPM_PACKUMENT_URL = "https://registry.npmjs.org/@join-pantheon%2fcli";
 export const INSTALLER_MIN_CLI = "0.32.0";
+export const isVersion = (v) => /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(v);
 function parseVer(v) {
-    const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(v);
+    const m = isVersion(v) ? /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/.exec(v) : null;
     return m ? { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]), pre: m[4] ?? null } : null;
 }
 export function compareVersions(a, b) {