@staff0rd/assist 0.749.0 → 0.750.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.749.0",
+  version: "0.750.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -12903,8 +12903,8 @@ var seqConfigHelp = [
 var nodesConfigHelp = [
   {
     key: "sessions.links",
-    setter: "assist sessions nodes link <name> http://127.0.0.1:<port> (or --ssh <alias> --port <port>)",
-    note: "linked nodes whose sessions merge into this node's web UI, each direct (url) or over an ssh tunnel (ssh alias, peer port, localPort); each name must match the peer's sessions.nodeName"
+    setter: "assist sessions nodes link <name> http://127.0.0.1:<port> (or --tailscale <host> --port <port>, or --ssh <alias> --port <port>)",
+    note: "linked nodes whose sessions merge into this node's web UI, each direct (url, including a Tailscale <host>.<tailnet>.ts.net https url) or over an ssh tunnel (ssh alias, peer port, localPort); each name must match the peer's sessions.nodeName"
   },
   {
     key: "sessions.linkVersionCheck",
@@ -47295,6 +47295,73 @@ async function sshHop(ssh, probes) {
   );
 }
 
+// src/commands/sessions/nodes/tailscaleStatus.ts
+import { execFile as execFile13 } from "child_process";
+import { promisify as promisify12 } from "util";
+var execFileAsync11 = promisify12(execFile13);
+var STATUS_TIMEOUT_MS2 = 1e4;
+function tailscaleCli() {
+  return detectPlatform() === "wsl" ? "tailscale.exe" : "tailscale";
+}
+async function tailscaleStatus() {
+  const { stdout } = await execFileAsync11(tailscaleCli(), ["status", "--json"], {
+    encoding: "utf8",
+    timeout: STATUS_TIMEOUT_MS2,
+    windowsHide: true
+  });
+  return JSON.parse(stdout);
+}
+
+// src/commands/sessions/nodes/findTailscalePeer.ts
+function findTailscalePeer(status3, hostname2) {
+  const nodes = [
+    ...status3.Self ? [{ ...status3.Self, Online: true }] : [],
+    ...Object.values(status3.Peer ?? {})
+  ];
+  return nodes.find(
+    (node) => node.DNSName?.replace(/\.$/, "").toLowerCase() === hostname2
+  );
+}
+
+// src/commands/sessions/nodes/tailscaleHop.ts
+async function tailscaleHop(spec, probes) {
+  const cli = tailscaleCli();
+  let status3;
+  try {
+    status3 = await probes.tailscale();
+  } catch (error) {
+    return failed2(
+      "tailscale",
+      describePeerError(error),
+      `\`${cli} status --json\` failed \u2014 install Tailscale on this node and sign in with \`${cli} up\``
+    );
+  }
+  if (status3.BackendState !== "Running")
+    return failed2(
+      "tailscale",
+      `Tailscale on this node is ${status3.BackendState ?? "not running"}`,
+      `run \`${cli} up\` on this node`
+    );
+  const { hostname: hostname2 } = new URL(spec.url);
+  const peer = findTailscalePeer(status3, hostname2);
+  if (!peer)
+    return failed2(
+      "tailscale",
+      `${hostname2} is not in this node's tailnet`,
+      `check the host in \`${cli} status\`, then relink with \`assist sessions nodes link ${spec.name} --tailscale <host> --port <port>\``
+    );
+  if (!peer.Online)
+    return failed2(
+      "tailscale",
+      `${hostname2} is offline in the tailnet`,
+      `is ${spec.name}'s machine awake with Tailscale running and signed in?`
+    );
+  return passed(
+    "tailscale",
+    `${hostname2} online${peer.TailscaleIPs?.[0] ? ` (${peer.TailscaleIPs[0]})` : ""}`
+  );
+}
+
 // src/commands/sessions/nodes/tunnelHop.ts
 async function tunnelHop(spec, ssh, probes) {
   const bound = `127.0.0.1:${ssh.localPort}`;
@@ -47307,10 +47374,26 @@ async function tunnelHop(spec, ssh, probes) {
   );
 }
 
+// src/commands/sessions/nodes/tailscaleServeRemediation.ts
+function tailscaleServeRemediation(spec, error) {
+  const status3 = error.status;
+  if (status3 !== void 0 && status3 !== 502) return void 0;
+  const { hostname: hostname2, port } = new URL(spec.url);
+  const servePort = port || "443";
+  return status3 === 502 ? `tailscale serve on ${hostname2} answered but nothing listens on 127.0.0.1:${servePort} behind it \u2014 is ${spec.name}'s web server running (project-switch webservers)?` : `nothing serves https on ${servePort} on ${hostname2} \u2014 run \`tailscale serve --bg --https=${servePort} http://127.0.0.1:${servePort}\` on ${spec.name} (tailscale.exe under WSL)`;
+}
+
+// src/commands/sessions/nodes/isTailscaleLink.ts
+function isTailscaleLink(spec) {
+  return new URL(spec.url).hostname.endsWith(".ts.net");
+}
+
 // src/commands/sessions/nodes/webHop.ts
 function webRemediation(spec, error) {
   if (spec.ssh && error.status === void 0)
     return `nothing listening on ${spec.ssh.port} on ${spec.ssh.alias} \u2014 is project-switch running ${spec.name}'s web server?`;
+  const serve = isTailscaleLink(spec) ? tailscaleServeRemediation(spec, error) : void 0;
+  if (serve) return serve;
   const { hostname: hostname2, port } = new URL(spec.url);
   switch (peerErrorCode(error)) {
     case "ECONNREFUSED":
@@ -47350,7 +47433,7 @@ async function webHop(spec, probes) {
   };
 }
 
-// src/commands/sessions/nodes/diagnoseLink.ts
+// src/commands/sessions/nodes/peerDaemonHop.ts
 function peerDaemonHop(spec, health2) {
   if (health2.daemon?.reachable) return passed("daemon", "reachable");
   return failed2(
@@ -47359,6 +47442,8 @@ function peerDaemonHop(spec, health2) {
     `run \`assist daemon status\` on ${spec.name}; restarting its web server starts the daemon`
   );
 }
+
+// src/commands/sessions/nodes/diagnoseLink.ts
 async function diagnoseLink(spec, probes) {
   const hops = [];
   const done2 = () => ({ ...spec, ok: hops.every((h) => h.ok), hops });
@@ -47373,6 +47458,10 @@ async function diagnoseLink(spec, probes) {
       if (!hops.at(-1)?.ok) return done2();
     }
   }
+  if (isTailscaleLink(spec)) {
+    hops.push(await tailscaleHop(spec, probes));
+    if (!hops.at(-1)?.ok) return done2();
+  }
   const web3 = await webHop(spec, probes);
   hops.push(web3.hop);
   if (!web3.health) return done2();
@@ -47520,7 +47609,7 @@ function printDiagnosis(diagnosis) {
   console.log(`${chalk253.bold(diagnosis.name)} ${chalk253.dim(diagnosis.url)}`);
   for (const hop of diagnosis.hops) {
     const mark = hop.ok ? chalk253.green("\u2713") : chalk253.red("\u2717");
-    console.log(`  ${mark} ${hop.hop.padEnd(6)} ${hop.detail ?? hop.error}`);
+    console.log(`  ${mark} ${hop.hop.padEnd(9)} ${hop.detail ?? hop.error}`);
     if (hop.remediation) console.log(`    ${chalk253.yellow(hop.remediation)}`);
   }
 }
@@ -47533,6 +47622,7 @@ function doctorProbes(live) {
     sshAgent: probeSshAgent,
     ssh: probeSsh,
     tunnel: (localPort) => portAccepts(localPort),
+    tailscale: tailscaleStatus,
     linkState: (name) => {
       if (!live) return "no-daemon";
       return live.links.find((l) => l.name === name) ?? "unknown-link";
@@ -47596,41 +47686,87 @@ async function writeLinks(links2) {
   saveGlobalConfig(updated2);
 }
 
-// src/commands/sessions/nodes/linkNode.ts
-function parseLinkUrl(url) {
-  const parsed = new URL(url);
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
-    throw new Error(`link url must be http(s): ${url}`);
-  return parsed.origin;
+// src/commands/sessions/nodes/tailnetSuffix.ts
+function tailnetSuffix(status3) {
+  if (status3.BackendState !== "Running")
+    throw new Error(
+      `Tailscale is not running on this node (${status3.BackendState ?? "unknown state"}) \u2014 run \`${tailscaleCli()} up\``
+    );
+  const suffix = status3.CurrentTailnet?.MagicDNSSuffix ?? status3.MagicDNSSuffix ?? "";
+  if (status3.CurrentTailnet?.MagicDNSEnabled === false || !suffix)
+    throw new Error(
+      "MagicDNS is off in this tailnet \u2014 turn on MagicDNS and HTTPS certificates on the DNS page of the Tailscale admin console"
+    );
+  return suffix.replace(/\.$/, "");
+}
+
+// src/commands/sessions/nodes/tailscaleLinkUrl.ts
+async function localTailnetSuffix() {
+  return tailnetSuffix(await tailscaleStatus());
+}
+async function tailscaleLinkUrl(host, port, resolveSuffix = localTailnetSuffix) {
+  const suffix = await resolveSuffix();
+  const fqdn = host.replace(/\.$/, "");
+  const bare = fqdn.endsWith(`.${suffix}`) ? fqdn.slice(0, -suffix.length - 1) : fqdn;
+  return `https://${bare}.${suffix}:${port}`;
 }
+
+// src/commands/sessions/nodes/parsePort.ts
 function parsePort(flag, value) {
   const port = Number(value);
   if (!Number.isInteger(port) || port < 1 || port > 65535)
     throw new Error(`${flag} must be a port number, got ${value}`);
   return port;
 }
-function freeTunnelPort(port, others) {
-  const taken = new Set(others.map((link3) => toLinkSpec(link3).ssh?.localPort));
-  let candidate = defaultTunnelPort(port);
-  while (taken.has(candidate)) candidate++;
-  return candidate;
+
+// src/commands/sessions/nodes/parseLinkUrl.ts
+function parseLinkUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+    throw new Error(`link url must be http(s): ${url}`);
+  return parsed.origin;
 }
-function buildLink(name, url, options2, others) {
-  if (url && options2.ssh)
-    throw new Error("pass either <url> or --ssh <alias>, not both");
+
+// src/commands/sessions/nodes/buildLink.ts
+async function buildLink(name, url, options2, others, resolveTailnetSuffix) {
+  if ([url, options2.ssh, options2.tailscale].filter(Boolean).length > 1)
+    throw new Error(
+      "pass only one of <url>, --tailscale <host> or --ssh <alias>"
+    );
   if (url) return { name, url: parseLinkUrl(url) };
+  if (options2.tailscale) {
+    const port2 = parsePort("--port", options2.port);
+    return {
+      name,
+      url: await tailscaleLinkUrl(
+        options2.tailscale,
+        port2,
+        resolveTailnetSuffix
+      )
+    };
+  }
   if (!options2.ssh)
-    throw new Error("pass the peer's <url> or --ssh <alias> --port <port>");
+    throw new Error(
+      "pass the peer's <url>, --tailscale <host> --port <port> or --ssh <alias> --port <port>"
+    );
   const port = parsePort("--port", options2.port);
   const localPort = options2.localPort ? parsePort("--local-port", options2.localPort) : freeTunnelPort(port, others);
   return { name, ssh: options2.ssh, port, localPort };
 }
+function freeTunnelPort(port, others) {
+  const taken = new Set(others.map((link3) => toLinkSpec(link3).ssh?.localPort));
+  let candidate = defaultTunnelPort(port);
+  while (taken.has(candidate)) candidate++;
+  return candidate;
+}
+
+// src/commands/sessions/nodes/linkNode.ts
 async function linkNode(name, url, options2) {
   if (name.includes(":")) throw new Error("node names cannot contain ':'");
   if (name === resolveNodeName())
     throw new Error(`${name} is this node; link to a different node`);
   const others = readLinks().filter((link4) => link4.name !== name);
-  const link3 = buildLink(name, url, options2, others);
+  const link3 = await buildLink(name, url, options2, others);
   await writeLinks([...others, link3]);
   console.log(
     chalk255.green(`Linked ${name} (${describeTarget(toLinkSpec(link3))})`)
@@ -47715,11 +47851,17 @@ async function unlinkNode(name) {
 function registerNodes(sessions) {
   const cmd = sessions.command("nodes").description("List this node and every linked node with its link state").option("--json", "Output as JSON").action(listNodes);
   cmd.command("link <name> [url]").description(
-    "Link a peer node by its web server URL, or over ssh with --ssh and --port (name must match the peer's sessions.nodeName)"
+    "Link a peer node by its web server URL, by its Tailscale name with --tailscale and --port, or over ssh with --ssh and --port (name must match the peer's sessions.nodeName)"
+  ).option(
+    "--tailscale <host>",
+    "Dial the peer at https://<host>.<tailnet>.ts.net:<port> (the peer runs tailscale serve for its web server port)"
   ).option(
     "--ssh <alias>",
     "Tunnel to the peer through this ~/.ssh/config alias"
-  ).option("--port <port>", "The peer's loopback web server port (with --ssh)").option(
+  ).option(
+    "--port <port>",
+    "The peer's web server port (with --tailscale or --ssh)"
+  ).option(
     "--local-port <port>",
     "Local end of the ssh tunnel (default: 43000 + port % 1000, bumped past other links)"
   ).action(linkNode);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.749.0",
+	"version": "0.750.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {