@staff0rd/assist 0.749.0 → 0.751.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.751.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -10696,7 +10696,7 @@ function startWebServer(label2, port, handler, initialPath, open = true) {
   const server = createServer((req, res) => {
     runHandler(handler, req, res, port);
   });
-  server.listen(port, () => {
+  server.listen(port, "127.0.0.1", () => {
     console.log(chalk103.green(`${label2}: ${url}`));
     console.log(chalk103.dim("Press Ctrl+C to stop"));
     if (open) {
@@ -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 \`assist sessions nodes serve --port ${servePort}\` on ${spec.name}`;
+}
+
+// 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";
@@ -47553,15 +47643,74 @@ async function doctorNodes(name, options2) {
   else printReport(report2);
 }
 
+// src/commands/sessions/nodes/listNodes.ts
+import chalk254 from "chalk";
+async function nodesReport() {
+  const live = await queryNodes();
+  if (live)
+    return { local: live.local, daemonRunning: true, links: live.links };
+  return {
+    local: resolveNodeName(),
+    daemonRunning: false,
+    links: loadLinkSpecs().map((link3) => ({ ...link3, state: "disconnected" }))
+  };
+}
+async function listNodes(options2) {
+  const report2 = await nodesReport();
+  if (options2.json) {
+    console.log(JSON.stringify(report2, null, 2));
+    return;
+  }
+  console.log(`${report2.local} ${chalk254.dim("(this node)")}`);
+  if (!report2.daemonRunning)
+    console.log(chalk254.dim("  daemon not running; showing configured links"));
+  if (report2.links.length === 0) console.log(chalk254.dim("  no links"));
+  for (const link3 of report2.links) console.log(formatLink(link3));
+}
+
+// src/commands/sessions/nodes/nodeLogs.ts
+async function fetchLogTail(name, lines2) {
+  if (name === resolveNodeName())
+    return {
+      nodeName: name,
+      path: daemonPaths.log,
+      lines: readLogTail(daemonPaths.log, lines2)
+    };
+  const link3 = findLinkSpec(name);
+  if (!link3)
+    throw new Error(`No link named ${name}; see assist sessions nodes`);
+  try {
+    return await fetchPeerJson(
+      link3.url,
+      `/api/daemon-log?lines=${lines2}`
+    );
+  } catch (error) {
+    throw new Error(
+      `Could not read ${name}'s daemon log: ${describePeerError(error)}. Run assist sessions nodes doctor ${name}`
+    );
+  }
+}
+async function nodeLogs(name, options2) {
+  const lines2 = Number.parseInt(options2.lines, 10);
+  if (!Number.isInteger(lines2) || lines2 < 1)
+    throw new Error(`-n must be a positive integer, got ${options2.lines}`);
+  const tail = await fetchLogTail(name, lines2);
+  if (options2.json) {
+    console.log(JSON.stringify(tail, null, 2));
+    return;
+  }
+  for (const line of tail.lines) console.log(line);
+}
+
 // src/commands/sessions/nodes/linkNode.ts
-import chalk255 from "chalk";
+import chalk256 from "chalk";
 
 // src/commands/sessions/nodes/notifyDaemonLinks.ts
-import chalk254 from "chalk";
+import chalk255 from "chalk";
 async function notifyDaemonLinks() {
   if (!await isDaemonRunning()) {
     console.log(
-      chalk254.yellow(
+      chalk255.yellow(
         "The sessions daemon is not running; it loads the links when it starts."
       )
     );
@@ -47569,11 +47718,11 @@ async function notifyDaemonLinks() {
   }
   try {
     await sendToDaemonAwaitAck({ type: "reload-links" });
-    console.log(chalk254.dim("The sessions daemon reloaded its links."));
+    console.log(chalk255.dim("The sessions daemon reloaded its links."));
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
     console.log(
-      chalk254.yellow(
+      chalk255.yellow(
         `Could not notify the sessions daemon (${message3}); run \`assist daemon restart\` to apply the change.`
       )
     );
@@ -47596,134 +47745,191 @@ 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))})`)
+    chalk256.green(`Linked ${name} (${describeTarget(toLinkSpec(link3))})`)
   );
   await notifyDaemonLinks();
 }
 
-// src/commands/sessions/nodes/listNodes.ts
-import chalk256 from "chalk";
-async function nodesReport() {
-  const live = await queryNodes();
-  if (live)
-    return { local: live.local, daemonRunning: true, links: live.links };
-  return {
-    local: resolveNodeName(),
-    daemonRunning: false,
-    links: loadLinkSpecs().map((link3) => ({ ...link3, state: "disconnected" }))
-  };
-}
-async function listNodes(options2) {
-  const report2 = await nodesReport();
-  if (options2.json) {
-    console.log(JSON.stringify(report2, null, 2));
-    return;
-  }
-  console.log(`${report2.local} ${chalk256.dim("(this node)")}`);
-  if (!report2.daemonRunning)
-    console.log(chalk256.dim("  daemon not running; showing configured links"));
-  if (report2.links.length === 0) console.log(chalk256.dim("  no links"));
-  for (const link3 of report2.links) console.log(formatLink(link3));
+// src/commands/sessions/nodes/registerLinkCommand.ts
+function registerLinkCommand(nodes) {
+  nodes.command("link <name> [url]").description(
+    "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 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);
 }
 
-// src/commands/sessions/nodes/nodeLogs.ts
-async function fetchLogTail(name, lines2) {
-  if (name === resolveNodeName())
-    return {
-      nodeName: name,
-      path: daemonPaths.log,
-      lines: readLogTail(daemonPaths.log, lines2)
-    };
-  const link3 = findLinkSpec(name);
-  if (!link3)
-    throw new Error(`No link named ${name}; see assist sessions nodes`);
-  try {
-    return await fetchPeerJson(
-      link3.url,
-      `/api/daemon-log?lines=${lines2}`
-    );
-  } catch (error) {
+// src/commands/sessions/nodes/serveNode.ts
+import { execFile as execFile14, spawnSync as spawnSync12 } from "child_process";
+import { promisify as promisify13 } from "util";
+import chalk257 from "chalk";
+
+// src/commands/sessions/nodes/planServe.ts
+function planServe(status3, serveConfig2, port) {
+  tailnetSuffix(status3);
+  const fqdn = status3.Self?.DNSName?.replace(/\.$/, "");
+  if (!fqdn)
     throw new Error(
-      `Could not read ${name}'s daemon log: ${describePeerError(error)}. Run assist sessions nodes doctor ${name}`
+      `\`${tailscaleCli()} status --json\` reports no DNS name for this machine`
     );
-  }
+  const target = `http://127.0.0.1:${port}`;
+  const served = serveConfig2.Web?.[`${fqdn}:${port}`]?.Handlers?.["/"]?.Proxy;
+  return {
+    host: fqdn.split(".")[0],
+    url: `https://${fqdn}:${port}`,
+    target,
+    alreadyServing: served?.replace(/\/$/, "") === target,
+    args: ["serve", "--bg", `--https=${port}`, target]
+  };
 }
-async function nodeLogs(name, options2) {
-  const lines2 = Number.parseInt(options2.lines, 10);
-  if (!Number.isInteger(lines2) || lines2 < 1)
-    throw new Error(`-n must be a positive integer, got ${options2.lines}`);
-  const tail = await fetchLogTail(name, lines2);
-  if (options2.json) {
-    console.log(JSON.stringify(tail, null, 2));
-    return;
+
+// src/commands/sessions/nodes/serveNode.ts
+var execFileAsync12 = promisify13(execFile14);
+async function serveConfig() {
+  const { stdout } = await execFileAsync12(
+    tailscaleCli(),
+    ["serve", "status", "--json"],
+    { encoding: "utf8", timeout: 1e4, windowsHide: true }
+  );
+  return stdout.trim() ? JSON.parse(stdout) : {};
+}
+function runServe(args) {
+  console.log(chalk257.dim(`${tailscaleCli()} ${args.join(" ")}`));
+  const result = spawnSync12(tailscaleCli(), args, { stdio: "inherit" });
+  if (result.error) throw result.error;
+  if (result.status !== 0)
+    throw new Error(`tailscale serve exited with ${result.status}`);
+}
+async function serveNode(options2) {
+  const port = parsePort("--port", options2.port);
+  const plan2 = planServe(await tailscaleStatus(), await serveConfig(), port);
+  if (plan2.alreadyServing) {
+    console.log(chalk257.dim(`${plan2.url} already serves ${plan2.target}`));
+  } else {
+    runServe(plan2.args);
+    console.log(chalk257.green(`Serving ${plan2.target} at ${plan2.url}`));
   }
-  for (const line of tail.lines) console.log(line);
+  console.log("Link this node from another node with:");
+  console.log(
+    `  assist sessions nodes link ${resolveNodeName()} --tailscale ${plan2.host} --port ${port}`
+  );
 }
 
 // src/commands/sessions/nodes/unlinkNode.ts
-import chalk257 from "chalk";
+import chalk258 from "chalk";
 async function unlinkNode(name) {
   const links2 = readLinks();
   const remaining = links2.filter((link3) => link3.name !== name);
   if (remaining.length === links2.length) {
-    console.log(chalk257.yellow(`No link named ${name}`));
+    console.log(chalk258.yellow(`No link named ${name}`));
     return;
   }
   await writeLinks(remaining);
-  console.log(chalk257.green(`Unlinked ${name}`));
+  console.log(chalk258.green(`Unlinked ${name}`));
   await notifyDaemonLinks();
 }
 
 // src/commands/sessions/nodes/registerNodes.ts
 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)"
-  ).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(
-    "--local-port <port>",
-    "Local end of the ssh tunnel (default: 43000 + port % 1000, bumped past other links)"
-  ).action(linkNode);
+  registerLinkCommand(cmd);
   cmd.command("unlink <name>").description("Remove a linked node").action(unlinkNode);
+  cmd.command("serve").description(
+    "Expose this node's web server on the tailnet with tailscale serve (idempotent) and print the command that links it"
+  ).option("-p, --port <port>", "This node's web server port", "3100").action(serveNode);
   cmd.command("doctor [name]").description(
     "Probe each hop of every link (or one) in order and stop at the first failure with a remediation"
   ).option("--json", "Output as JSON").action(
@@ -47846,7 +48052,7 @@ async function renameSession(title) {
 
 // src/commands/sessions/summarise.ts
 import * as fs58 from "fs";
-import chalk258 from "chalk";
+import chalk259 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs57 from "fs";
@@ -47905,22 +48111,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk258.yellow("No sessions found."));
+    console.log(chalk259.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk258.green("All sessions already summarised."));
+    console.log(chalk259.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk258.cyan(
+    chalk259.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed3 } = processSessions(toProcess);
   console.log(
-    chalk258.green(`Done: ${succeeded} summarised`) + (failed3 > 0 ? chalk258.yellow(`, ${failed3} skipped`) : "")
+    chalk259.green(`Done: ${succeeded} summarised`) + (failed3 > 0 ? chalk259.yellow(`, ${failed3} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -47940,16 +48146,16 @@ function processSessions(files) {
   let failed3 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk258.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk259.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk258.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk259.green("\u2713")} ${summary}
 `);
     } else {
       failed3++;
-      process.stdout.write(` ${chalk258.yellow("skip")}
+      process.stdout.write(` ${chalk259.yellow("skip")}
 `);
     }
   }
@@ -47979,10 +48185,10 @@ function registerSessions(program2) {
 }
 
 // src/reportCliError.ts
-import chalk259 from "chalk";
+import chalk260 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
-    console.error(chalk259.red(error.message));
+    console.error(chalk260.red(error.message));
   } else {
     console.error(error);
   }

package/package.json

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