@join-pantheon/cli 0.28.0 → 0.29.1

package/dist/quickstart.js

@@ -1,9 +1,12 @@
 import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { basename } from "node:path";
-import { homedir } from "node:os";
+import { createServer } from "node:net";
+import { basename, join as pathJoin } from "node:path";
+import { homedir, hostname, platform } from "node:os";
+import { lookup } from "node:dns/promises";
+import { describeNetError } from "./network.js";
 import { PantheonClient } from "./client.js";
-import { load, save, toInvite, resolveFor, repoInfo, bindRepo, DEFAULT_RELAY } from "./config.js";
+import { load, identity, save, toInvite, resolveFor, repoInfo, bindRepo, DEFAULT_RELAY } from "./config.js";
 import { loadProfile, wakeDefault } from "./profile.js";
 import { newKeypair } from "./identity.js";
 import { installForUser } from "./install.js";
@@ -13,7 +16,8 @@ import { installService, servicesUnavailable } from "./service.js";
 import { ensureNativeNotifier } from "./notifier.js";
 import { ensureTrayBinary, writeTrayCommands } from "./tray.js";
 import { desktopUnavailable, ephemeralWarning, hostEnv } from "./host-env.js";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { localAddresses } from "./machine.js";
 import { grant as grantCap, loadPolicy, policyPath, savePolicy } from "./worker-policy.js";
 import { Relay } from "./relay.js";
 import { which } from "./which.js";
@@ -98,7 +102,12 @@ export function wireUp(opts, deps = {}) {
     }
     else if (opts.unattended) {
         const project = opts.unattended;
-        const isRepo = sh(`git -C ${JSON.stringify(project)} rev-parse --is-inside-work-tree 2>/dev/null`) === "true";
+        const isRepo = (() => { try {
+            return execFileSync("git", ["-C", project, "rev-parse", "--is-inside-work-tree"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 }).trim() === "true";
+        }
+        catch {
+            return false;
+        } })();
         if (!isRepo && how === "explicit") {
             tools.push({ tool: "worker", status: `not installed — ${project} is not a git repo` });
             warnings.push(`--unattended needs a git repo to work in; pass --project <a clone>. Nothing was installed.`);
@@ -126,7 +135,136 @@ export function wireUp(opts, deps = {}) {
     }
     return { tools, granted, warnings };
 }
-export function findReach(port) {
+const TRANSLIT = {
+    а: "a", б: "b", в: "v", г: "g", д: "d", е: "e", ё: "yo", ж: "zh", з: "z", и: "i", й: "y", к: "k", л: "l", м: "m",
+    н: "n", о: "o", п: "p", р: "r", с: "s", т: "t", у: "u", ф: "f", х: "kh", ц: "ts", ч: "ch", ш: "sh", щ: "shch",
+    ъ: "", ы: "y", ь: "", э: "e", ю: "yu", я: "ya", є: "ye", і: "i", ї: "yi", ґ: "g", ў: "u",
+    α: "a", β: "v", γ: "g", δ: "d", ε: "e", ζ: "z", η: "i", θ: "th", ι: "i", κ: "k", λ: "l", μ: "m", ν: "n", ξ: "x",
+    ο: "o", π: "p", ρ: "r", σ: "s", ς: "s", τ: "t", υ: "y", φ: "f", χ: "ch", ψ: "ps", ω: "o",
+    ß: "ss", æ: "ae", ø: "o", đ: "d", ł: "l", þ: "th", œ: "oe",
+};
+export function slugName(raw, fallback) {
+    const s = raw.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "")
+        .replace(/./gu, (ch) => TRANSLIT[ch] ?? ch)
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/-{2,}/g, "-")
+        .replace(/^[-._]+|[-._]+$/g, "");
+    return /[a-z0-9]/.test(s) ? s : fallback;
+}
+export function teamNameFor(dir, repo = repoInfo(dir)) {
+    const fromOrigin = repo?.origin ? (repo.origin.replace(/\.git$/i, "").split(/[/:]/).filter(Boolean).pop() ?? "") : "";
+    return slugName(fromOrigin || basename(repo?.root ?? dir), "team");
+}
+export function isLocalRelay(url) {
+    let host = "";
+    try {
+        host = new URL(url.replace(/^ws/i, "http")).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return host === "localhost" || host === "::1" || host === "0.0.0.0" || host === "::" || /^127\./.test(host);
+}
+const hostOf = (url) => {
+    try {
+        return new URL(url.replace(/^ws/i, "http")).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    }
+    catch {
+        return "";
+    }
+};
+export async function relayPlace(url, localPort, deps = {}) {
+    if (isLocalRelay(url))
+        return "loopback";
+    const host = hostOf(url);
+    const hosted = new Set([hostOf(deps.hostedRelay ?? "wss://relay.joinpantheon.network"), hostOf(DEFAULT_RELAY)].filter(Boolean));
+    if (!host || hosted.has(host))
+        return "hosted";
+    const addrs = new Set((deps.localAddrs ?? localAddresses()).map((a) => a.toLowerCase()));
+    const name = (deps.hostname ?? hostname()).toLowerCase();
+    if (addrs.has(host) || host === name || host === `${name}.local`)
+        return "this-machine";
+    const resolved = await (deps.resolve ?? resolveHost)(host);
+    if (resolved?.some((a) => addrs.has(a.toLowerCase()) || /^127\./.test(a) || a === "::1"))
+        return "this-machine";
+    if ((deps.tunnelTo ?? tunnelRunningTo)(localPort) || (deps.hostedBefore ?? (() => false))(url))
+        return "tunnel";
+    return "remote";
+}
+async function resolveHost(host) {
+    try {
+        const all = await Promise.race([
+            lookup(host, { all: true }).then((r) => r.map((x) => x.address)),
+            new Promise((res) => setTimeout(() => res(null), 1500).unref()),
+        ]);
+        return all;
+    }
+    catch {
+        return null;
+    }
+}
+export function tunnelRunningTo(port, ps = () => sh("ps -Ao command= 2>/dev/null")) {
+    const out = ps() ?? "";
+    const re = new RegExp(`\\b(cloudflared|ngrok|tailscale\\s+(funnel|serve)|bore)\\b.*[:\\s]${port}\\b`);
+    return out.split("\n").some((l) => re.test(l));
+}
+const HOSTED_FOR = "hosted-for.json";
+export function hostedBefore(dataDir, url) {
+    try {
+        return JSON.parse(readFileSync(pathJoin(dataDir, HOSTED_FOR), "utf8")).includes(url.replace(/\/+$/, ""));
+    }
+    catch {
+        return false;
+    }
+}
+export function rememberHosted(dataDir, url) {
+    try {
+        const f = pathJoin(dataDir, HOSTED_FOR);
+        let list = [];
+        try {
+            list = JSON.parse(readFileSync(f, "utf8"));
+        }
+        catch { }
+        const u = url.replace(/\/+$/, "");
+        if (list.includes(u))
+            return;
+        mkdirSync(dataDir, { recursive: true });
+        writeFileSync(f, JSON.stringify([...list, u]));
+    }
+    catch { }
+}
+export async function probeRelay(url, timeoutMs, fetchImpl = fetch) {
+    const health = url.replace(/^ws/i, "http").replace(/\/+$/, "") + "/health";
+    try {
+        const r = await fetchImpl(health, { signal: AbortSignal.timeout(timeoutMs) });
+        if (r.ok)
+            return { ok: true };
+        return { ok: false, error: new Error(`${health} answered HTTP ${r.status}`) };
+    }
+    catch (e) {
+        if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+            return { ok: false, error: Object.assign(new Error(`no answer from ${health} in ${Math.round(timeoutMs / 1000)}s`), { code: "ETIMEDOUT" }) };
+        }
+        const cause = e?.cause;
+        if (cause?.message && /fetch failed/.test(e?.message ?? "")) {
+            return { ok: false, error: Object.assign(new Error(`fetch failed: ${cause.message}`), { cause, ...(cause.code ? { code: cause.code } : {}) }) };
+        }
+        return { ok: false, error: e };
+    }
+}
+export function portFree(port) {
+    return new Promise((res) => {
+        const s = createServer();
+        s.once("error", (e) => res(e.code ?? e.message));
+        s.listen(port, "0.0.0.0", () => s.close(() => res(true)));
+    });
+}
+export function cloudflaredInstall(os = platform()) {
+    return os === "darwin" ? "brew install cloudflared"
+        : os === "win32" ? "winget install --id Cloudflare.cloudflared"
+            : "install cloudflared (https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/)";
+}
+export function findReach(port, os = platform()) {
     const ts = sh("tailscale ip -4 2>/dev/null | head -1");
     if (ts && /^\d+\.\d+\.\d+\.\d+$/.test(ts)) {
         return { url: `ws://${ts}:${port}`, how: `tailscale (${ts})`, shareable: true };
@@ -143,33 +281,58 @@ export function findReach(port) {
         url: `ws://127.0.0.1:${port}`, how: "localhost", shareable: false,
         hint: `Only reachable on this machine. For a teammate elsewhere, easiest is Tailscale\n` +
             `  on both machines (then re-run \`pantheon start\`), or a tunnel:\n` +
-            `    brew install cloudflared && cloudflared tunnel --url http://localhost:${port}`,
+            (os === "darwin" || os === "win32"
+                ? `    ${cloudflaredInstall(os)} && cloudflared tunnel --url http://localhost:${port}`
+                : `    ${cloudflaredInstall(os)}, then:  cloudflared tunnel --url http://localhost:${port}`),
     };
 }
 export async function start(opts) {
     const warnings = [];
     const here = resolveFor(process.cwd());
-    const priorCfg = here.cfg;
+    const priorCfg = here.cfg ?? identity();
     const repo = repoInfo(process.cwd());
     const signedInRelay = priorCfg?.account ? (priorCfg.relay ?? DEFAULT_RELAY) : undefined;
     const chosen = opts.relay ?? signedInRelay;
+    const place = chosen ? await relayPlace(chosen, opts.port, { ...opts.place, hostedBefore: (u) => hostedBefore(opts.dataDir, u) }) : null;
+    const hostHere = place === "loopback" || place === "this-machine" || place === "tunnel";
     const reach = chosen
-        ? (/127\.0\.0\.1|localhost|\[::1\]/.test(chosen)
+        ? (place === "loopback"
             ? { url: chosen, how: "as given", shareable: false,
                 hint: `That address is this machine only — a teammate cannot reach it.\n` +
                     `  Use a tailnet address (tailscale ip -4) or a tunnel, then re-run pantheon start.` }
-            : { url: chosen, how: opts.relay ? "as given" : "your signed-in relay", shareable: true })
+            : { url: chosen, how: place === "this-machine" ? "this machine's address" : place === "tunnel" ? "a tunnel to this machine" : opts.relay ? "as given" : "your signed-in relay", shareable: true })
         : findReach(opts.port);
+    const nothing = (why) => ({ cfg: priorCfg ?? { relay: reach.url }, invite: null, claimed: false, reach, tools: [], granted: [], relay: null, warnings: [why] });
     let relay = null;
-    const health = reach.url.replace(/^ws/, "http") + "/health";
-    const already = await fetch(health, { signal: AbortSignal.timeout(1500) }).then((r) => r.ok).catch(() => false);
-    if (already) {
-        opts.log(`  relay      already running — nothing to start   ${reach.url}`);
+    if (chosen && !hostHere) {
+        const probe = await probeRelay(reach.url, opts.remoteTimeoutMs ?? 10_000, opts.fetchImpl);
+        if (!probe.ok) {
+            return nothing(`cannot reach the relay at ${reach.url}: ${describeNetError(probe.error, reach.url)}` +
+                (place === "remote" ? `\n    If that address is a tunnel to this machine, start the tunnel first (cloudflared tunnel --url http://localhost:${opts.port}) and run this again — Pantheon hosts the relay here when it sees the tunnel.` : ""));
+        }
+        opts.log(`  relay      ${reach.url}   (${reach.how})`);
     }
     else {
-        relay = new Relay({ port: opts.port, host: "0.0.0.0", dataDir: opts.dataDir, log: () => { } });
-        await relay.listen();
-        opts.log(`  relay      started on ${reach.url}  (${reach.how})`);
+        const urlPort = chosen && place !== "tunnel" ? Number(new URL(chosen.replace(/^ws/i, "http")).port) : 0;
+        const listenPort = urlPort || opts.port;
+        const local = `ws://127.0.0.1:${listenPort}`;
+        const probe = await probeRelay(place === "tunnel" ? local : reach.url, 1500);
+        if (probe.ok) {
+            opts.log(`  relay      already running — nothing to start   ${reach.url}`);
+        }
+        else {
+            const free = await portFree(listenPort);
+            if (free !== true) {
+                return nothing(free === "EADDRINUSE"
+                    ? `port ${listenPort} is taken by another program — it did not answer as a Pantheon relay (${local}/health). Free it, or pick another port: pantheon start --port <n>`
+                    : `the relay could not start on port ${listenPort}: ${free}`);
+            }
+            relay = new Relay({ port: listenPort, host: "0.0.0.0", dataDir: opts.dataDir, log: () => { } });
+            await relay.listen();
+            opts.log(`  relay      started on ${reach.url}  (${reach.how})`);
+        }
+        if (chosen && place !== "loopback")
+            rememberHosted(opts.dataDir, chosen);
     }
     const existing = priorCfg;
     const hasOwnSpace = !!existing?.space && !!existing?.token;
@@ -180,9 +343,9 @@ export async function start(opts) {
         ? { ...existing, relay: reach.url, agent: detectAgent() }
         : {
             relay: reach.url,
-            space: opts.space ?? (basename(process.cwd()).toLowerCase().replace(/[^a-z0-9._-]/g, "-") || "team"),
+            space: opts.space ?? teamNameFor(process.cwd(), repo),
             token: randomBytes(16).toString("hex"),
-            member: opts.me ?? (keepIdentity ? existing.member : (process.env.USER ?? "me").toLowerCase().replace(/[^a-z0-9._-]/g, "-")),
+            member: opts.me ?? (keepIdentity ? existing.member : slugName(process.env.USER ?? "me", "me")),
             agent: detectAgent(),
             ...(keepIdentity ? { publicKey: existing.publicKey, privateKey: existing.privateKey } : newKeypair()),
             ...(keepIdentity && existing.account ? { account: existing.account } : {}),
@@ -220,7 +383,8 @@ export async function start(opts) {
                     warnings.push(`this repo was bound to another team (${replaced.space}); it now belongs to "${c.space}"`);
             }
             opts.log(`  space      ${c.space} ${reuse ? "— reconnected" : "— created, you own it"}${repo ? `   ${repo.origin ?? "local repo"} → bound to it` : ""}`);
-            const inv = await client.makeInvite(wakeDefault(loadProfile(c)), opts.ttlMinutes);
+            const mayWake = opts.wake ? opts.wake === "anyone" : wakeDefault(loadProfile(c));
+            const inv = await client.makeInvite(mayWake, opts.ttlMinutes);
             invite = toInvite({ ...c, token: inv.url });
             claimed = true;
         }
@@ -265,7 +429,7 @@ export async function start(opts) {
     return { cfg, invite, claimed, reach, tools: wired.tools, granted: wired.granted, relay, warnings };
 }
 export async function join(opts) {
-    const existing = opts.reset ? null : load();
+    const existing = opts.reset ? null : (load() ?? identity());
     const repo = repoInfo(process.cwd());
     const keys = existing?.publicKey && existing.privateKey
         ? { publicKey: existing.publicKey, privateKey: existing.privateKey }
@@ -277,7 +441,7 @@ export async function join(opts) {
         relay: opts.invite.relay,
         space: opts.invite.space,
         token: "",
-        member: opts.me ?? existing?.member ?? (process.env.USER ?? "me").toLowerCase().replace(/[^a-z0-9._-]/g, "-"),
+        member: opts.me ?? existing?.member ?? slugName(process.env.USER ?? "me", "me"),
         agent: detectAgent(),
         ...keys,
         ...(existing?.account ? { account: existing.account } : {}),

package/dist/refusal.js

@@ -0,0 +1,29 @@
+const NET_CODE = /^(ECONN\w*|ENOTFOUND|ETIMEDOUT|EAI_\w+|EPROTO|EHOSTUNREACH|ENETUNREACH|EPIPE|ECONNRESET|UND_ERR_\w*|ERR_\w+)$/;
+const FIX = {
+    NOT_SIGNED_IN: "sign in on this machine: pantheon login --email you@work.com (or pantheon signup), then try again",
+    KEY_MISMATCH: "a member of the team runs  pantheon admit <you> --forget  and sends you a new invite (or pick another name with --me)",
+    REVOKED: "ask a member of the team to let you back in: pantheon admit <you>",
+    PLAN_LIMIT: "the team's owner frees a seat (pantheon invite --revoke all cancels unused invites) or upgrades the plan",
+    BAD_TOKEN: "this machine's copy of the team token is wrong — rejoin with a fresh invite: pantheon join <invite>",
+    NO_SUCH_SPACE: "the team does not exist on this relay — check  pantheon spaces, or join with a fresh invite",
+    SPACE_DELETED: "the team was deleted — remove it here with  pantheon leave <team>",
+    REPO_MISMATCH: "run this from the team's own repo, or bind this one: pantheon use <team> --here",
+    BAD_INVITE: "ask for a fresh invite: pantheon invite",
+};
+export function refusalOf(e) {
+    const text = typeof e === "string" ? e : String(e?.message ?? e ?? "");
+    const m = /^([A-Z][A-Z0-9_]{2,}): ([\s\S]*)$/.exec(text.trim());
+    if (!m || NET_CODE.test(m[1]) || m[1] === "PENDING")
+        return null;
+    return { code: m[1], message: m[2].trim(), fix: FIX[m[1]] ?? null };
+}
+export function connectFailure(e, relay) {
+    const r = refusalOf(e);
+    if (r) {
+        const fix = r.fix && !/pantheon \w/.test(r.message) ? `\n  ${r.fix}` : "";
+        return `the relay refused this machine (${r.code}): ${r.message}${fix}`;
+    }
+    const text = typeof e === "string" ? e : String(e?.message ?? e ?? "");
+    return `cannot reach the relay at ${relay} — ${text}`;
+}
+//# sourceMappingURL=refusal.js.map