visigraph 0.0.4 → 0.0.6

package/README.md

@@ -3,7 +3,9 @@
 Command line for [VisiGraph](https://github.com/textologylabs/visigraph):
 architecture models you can play through.
 
-Early, pre-1.0. Today it validates a model; the journey player follows.
+Early, pre-1.0. Today it validates a model. Next it builds a static,
+playable site from one: no server, works as a file, a GitLab Pages site or
+a Confluence embed.
 
 ```sh
 npm install -g visigraph
@@ -18,3 +20,29 @@ reference, with a path to each one:
 ```
 error: model.yaml:journeys[0].steps[2].endpoint: container 'auth-service' has no endpoint 'token'
 ```
+
+## Self-update
+
+On an interactive launch the CLI checks the npm registry for a newer
+version and offers to update. Saying yes installs the new version and
+re-runs the command you typed on it. Nothing is ever installed without
+that answer.
+
+- Skipped entirely in CI, pipes and non-terminal shells.
+- The network check uses the registry npm is configured with (so a
+  corporate mirror works), is cached for 24 hours, and gives up silently
+  after two seconds. A failed check never blocks or errors the command.
+- Under `npx`, it only prints the newer version and suggests
+  `npx visigraph@latest`.
+- `--version` and `--help` never check.
+
+Disable it:
+
+- per shell or container image: `VISIGRAPH_NO_UPDATE_CHECK=1`
+- centrally, for locked-down or air-gapped environments, in
+  `~/.visigraph/config.yaml`:
+
+  ```yaml
+  update:
+    check: false
+  ```

package/dist/main.js

@@ -3662,13 +3662,13 @@ var require_directives = __commonJS({
             onError("Verbatim tags must end with a >");
           return verbatim;
         }
-        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
-        if (!suffix)
+        const [, handle, suffix2] = source.match(/^(.*!)([^!]*)$/s);
+        if (!suffix2)
           onError(`The ${source} tag has no suffix`);
         const prefix = this.tags[handle];
         if (prefix) {
           try {
-            return prefix + decodeURIComponent(suffix);
+            return prefix + decodeURIComponent(suffix2);
           } catch (error) {
             onError(String(error));
             return null;
@@ -3956,36 +3956,38 @@ var require_Alias = __commonJS({
           if (node.anchor === this.source)
             found = node;
         }
+        if (found && ctx) {
+          const { anchors: anchors2, doc: doc2, maxAliasCount } = ctx;
+          let data = anchors2.get(found);
+          if (!data) {
+            toJS.toJS(found, null, ctx);
+            data = anchors2.get(found);
+          }
+          if (data?.res === void 0) {
+            const msg = "This should not happen: Alias anchor was not resolved?";
+            throw new ReferenceError(msg);
+          }
+          if (maxAliasCount >= 0) {
+            data.count += 1;
+            if (data.aliasCount === 0)
+              data.aliasCount = getAliasCount(doc2, found, anchors2);
+            if (data.count * data.aliasCount > maxAliasCount) {
+              const msg = "Excessive alias count indicates a resource exhaustion attack";
+              throw new ReferenceError(msg);
+            }
+          }
+        }
         return found;
       }
       toJSON(_arg, ctx) {
         if (!ctx)
           return { source: this.source };
-        const { anchors: anchors2, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc, ctx);
+        const source = this.resolve(ctx.doc, ctx);
         if (!source) {
           const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
           throw new ReferenceError(msg);
         }
-        let data = anchors2.get(source);
-        if (!data) {
-          toJS.toJS(source, null, ctx);
-          data = anchors2.get(source);
-        }
-        if (data?.res === void 0) {
-          const msg = "This should not happen: Alias anchor was not resolved?";
-          throw new ReferenceError(msg);
-        }
-        if (maxAliasCount >= 0) {
-          data.count += 1;
-          if (data.aliasCount === 0)
-            data.aliasCount = getAliasCount(doc, source, anchors2);
-          if (data.count * data.aliasCount > maxAliasCount) {
-            const msg = "Excessive alias count indicates a resource exhaustion attack";
-            throw new ReferenceError(msg);
-          }
-        }
-        return data.res;
+        return ctx.anchors.get(source).res;
       }
       toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;
@@ -7987,37 +7989,38 @@ var require_resolve_flow_scalar = __commonJS({
       }
       if (badChar)
         onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
-      return foldLines(source);
+      return unfoldLines(source);
     }
     function singleQuotedValue(source, onError) {
       if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
-      return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+      return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
     }
-    function foldLines(source) {
-      let first, line;
+    function unfoldLines(source) {
+      const line = /(.*?)\r?\n/sy;
+      let match = line.exec(source);
+      if (!match)
+        return source;
+      let trimEnd, trimBoth;
       try {
-        first = new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
-        line = new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
+        trimEnd = new RegExp("(?<![ 	])[ 	]+$");
+        trimBoth = new RegExp("^[ 	]+|(?<![ 	])[ 	]+$", "g");
       } catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
       }
-      let match = first.exec(source);
-      if (!match)
-        return source;
-      let res = match[1];
+      let res = match[1].replace(trimEnd, "");
       let sep = " ";
-      let pos = first.lastIndex;
-      line.lastIndex = pos;
+      let pos = line.lastIndex;
       while (match = line.exec(source)) {
-        if (match[1] === "") {
+        const lm = match[1].replace(trimBoth, "");
+        if (lm === "") {
           if (sep === "\n")
             res += sep;
           else
             sep = "\n";
         } else {
-          res += sep + match[1];
+          res += sep + lm;
           sep = " ";
         }
         pos = line.lastIndex;
@@ -11126,6 +11129,101 @@ async function validate(file) {
   return EXIT.ok;
 }
 
+// src/update.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import { spawn } from "child_process";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import readline from "readline";
+
+// src/progress.ts
+var CELLS = 6;
+var GLYPHS = {
+  unicode: { filled: "\u25B0", empty: "\u25B1" },
+  // ▰ ▱  black / white parallelogram
+  ascii: { filled: "#", empty: ".", open: "[", close: "]" }
+};
+function renderProgress(done, total, opts = {}) {
+  const cells = opts.cells ?? CELLS;
+  const safeTotal = Math.max(total, 0);
+  const safeDone = Math.min(Math.max(done, 0), safeTotal);
+  const filled = safeTotal === 0 ? 0 : Math.round(safeDone / safeTotal * cells);
+  return `${bar(filled, cells, opts.unicode ?? true)} ${safeDone}/${safeTotal}${suffix(opts.label)}`;
+}
+function renderSweep(tick, opts = {}) {
+  const cells = opts.cells ?? CELLS;
+  const unicode = opts.unicode ?? true;
+  const g = unicode ? GLYPHS.unicode : GLYPHS.ascii;
+  const pos = (tick % cells + cells) % cells;
+  const body = Array.from({ length: cells }, (_, i) => i === pos ? g.filled : g.empty).join("");
+  return `${unicode ? body : `${GLYPHS.ascii.open}${body}${GLYPHS.ascii.close}`}${suffix(opts.label)}`;
+}
+function bar(filled, cells, unicode) {
+  const g = unicode ? GLYPHS.unicode : GLYPHS.ascii;
+  const body = g.filled.repeat(filled) + g.empty.repeat(cells - filled);
+  return unicode ? body : `${GLYPHS.ascii.open}${body}${GLYPHS.ascii.close}`;
+}
+function suffix(label) {
+  return label ? ` ${label}` : "";
+}
+function supportsUnicode(env = process.env, platform = process.platform) {
+  if (platform === "win32") {
+    return Boolean(env.WT_SESSION || env.TERM_PROGRAM === "vscode" || env.ConEmuANSI === "ON");
+  }
+  if (env.TERM === "dumb") return false;
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "";
+  return /utf-?8/i.test(locale) || locale === "";
+}
+var ProgressLine = class {
+  constructor(out = process.stderr) {
+    this.out = out;
+    this.enabled = Boolean(out.isTTY);
+    this.unicode = supportsUnicode();
+  }
+  out;
+  timer;
+  tick = 0;
+  enabled;
+  unicode;
+  /** Animate a sweep with a label until `stop` or `finish` is called. */
+  sweep(label, intervalMs = 120) {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.draw(renderSweep(this.tick, { unicode: this.unicode, label }));
+    this.timer = setInterval(() => {
+      this.tick += 1;
+      this.draw(renderSweep(this.tick, { unicode: this.unicode, label }));
+    }, intervalMs);
+  }
+  /** Show `done` of `total` with a label. */
+  update(done, total, label) {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.draw(renderProgress(done, total, label === void 0 ? { unicode: this.unicode } : { unicode: this.unicode, label }));
+  }
+  /** Fill the bar, print the final label, and move to a new line. */
+  finish(label) {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.draw(renderProgress(CELLS, CELLS, { unicode: this.unicode, label }));
+    this.out.write("\n");
+  }
+  /** Erase the line without a final message. */
+  stop() {
+    if (!this.enabled) return;
+    this.clearTimer();
+    this.out.write("\r\x1B[2K");
+  }
+  draw(text) {
+    this.out.write(`\r\x1B[2K${text}`);
+  }
+  clearTimer() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+  }
+};
+
 // src/version.ts
 import { createRequire } from "module";
 var load = createRequire(import.meta.url);
@@ -11133,15 +11231,174 @@ var pkg = load("../package.json");
 var VERSION = pkg.version;
 var DESCRIPTION = pkg.description;
 
+// src/update.ts
+var PKG_NAME = "visigraph";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var FETCH_TIMEOUT_MS = 2e3;
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var NO_UPDATE_ENV = "VISIGRAPH_NO_UPDATE_CHECK";
+var configDir = () => process.env.VISIGRAPH_HOME ?? join2(homedir(), ".visigraph");
+async function maybeUpdate() {
+  const gate = shouldCheck({
+    noUpdateEnv: process.env[NO_UPDATE_ENV] === "1",
+    stdinTTY: Boolean(process.stdin.isTTY),
+    stdoutTTY: Boolean(process.stdout.isTTY),
+    configCheckDisabled: await configDisablesCheck()
+  });
+  if (!gate) return;
+  const latest = await latestVersion();
+  if (!latest || !isNewerVersion(latest, VERSION)) return;
+  const viaNpx = invokedViaNpx({ npmCommand: process.env.npm_command, script: process.argv[1] ?? "" });
+  console.log(`visigraph ${latest} is available; you have ${VERSION}.`);
+  if (viaNpx) {
+    console.log(`Run it with: npx ${PKG_NAME}@latest`);
+    return;
+  }
+  if (!await confirm("Update now?")) return;
+  const progress = new ProgressLine();
+  progress.sweep(`installing visigraph ${latest}`);
+  const result = await runInstall();
+  if (!result.ok) {
+    progress.stop();
+    console.error("Update failed. Continuing with the current version.");
+    if (result.output.trim()) console.error(result.output.trim());
+    return;
+  }
+  progress.finish(`updated to ${latest}, relaunching`);
+  await relaunch();
+}
+function shouldCheck(input) {
+  if (input.noUpdateEnv) return false;
+  if (input.configCheckDisabled) return false;
+  if (!input.stdinTTY || !input.stdoutTTY) return false;
+  return true;
+}
+function compareVersions(a, b) {
+  const pa = a.split("-")[0].split(".").map(Number);
+  const pb = b.split("-")[0].split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function isNewerVersion(latest, current) {
+  return compareVersions(latest, current) > 0;
+}
+function invokedViaNpx(input) {
+  return input.npmCommand === "exec" || /[\\/]_npx[\\/]/.test(input.script);
+}
+function registryFrom(input) {
+  const fromEnv = input.env?.trim();
+  if (fromEnv) return fromEnv.replace(/\/+$/, "");
+  const line = input.npmrc?.split(/\r?\n/).find((l) => /^\s*registry\s*=/.test(l));
+  const fromRc = line?.split("=").slice(1).join("=").trim();
+  if (fromRc) return fromRc.replace(/\/+$/, "");
+  return DEFAULT_REGISTRY;
+}
+function cacheIsFresh(entry, now, ttl = CACHE_TTL_MS) {
+  return entry !== void 0 && typeof entry.latest === "string" && now - entry.checkedAt < ttl;
+}
+async function fetchLatestVersion(registry, fetchImpl = fetch) {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetchImpl(`${registry}/${PKG_NAME}/latest`, {
+      signal: ctrl.signal,
+      headers: { "User-Agent": `${PKG_NAME}/${VERSION}`, accept: "application/json" }
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function configDisablesCheck() {
+  try {
+    const text = await readFile2(join2(configDir(), "config.yaml"), "utf8");
+    const cfg = (0, import_yaml2.parse)(text);
+    return cfg?.update?.check === false;
+  } catch {
+    return false;
+  }
+}
+async function latestVersion() {
+  const cachePath = join2(configDir(), "update-check.json");
+  const now = Date.now();
+  try {
+    const cached = JSON.parse(await readFile2(cachePath, "utf8"));
+    if (cacheIsFresh(cached, now)) return cached.latest;
+  } catch {
+  }
+  let npmrc;
+  try {
+    npmrc = await readFile2(join2(homedir(), ".npmrc"), "utf8");
+  } catch {
+    npmrc = void 0;
+  }
+  const registry = registryFrom({ env: process.env.npm_config_registry, npmrc });
+  const latest = await fetchLatestVersion(registry);
+  if (latest) {
+    try {
+      await mkdir(configDir(), { recursive: true });
+      await writeFile(cachePath, JSON.stringify({ checkedAt: now, latest }));
+    } catch {
+    }
+  }
+  return latest;
+}
+function confirm(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.on("close", () => resolve2(false));
+    rl.question(`${question} (y/N) `, (answer) => {
+      resolve2(/^y(es)?$/i.test(answer.trim()));
+      rl.close();
+    });
+  });
+}
+function runInstall() {
+  const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+  return new Promise((resolve2) => {
+    const chunks = [];
+    const child = spawn(npm, ["install", "-g", `${PKG_NAME}@latest`, "--no-fund", "--no-audit"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+    child.stdout.on("data", (d) => chunks.push(d.toString()));
+    child.stderr.on("data", (d) => chunks.push(d.toString()));
+    child.on("exit", (code) => resolve2({ ok: code === 0, output: chunks.join("") }));
+    child.on("error", (e) => resolve2({ ok: false, output: e.message }));
+  });
+}
+function relaunch() {
+  const script = process.argv[1];
+  const args = process.argv.slice(2);
+  return new Promise((_, reject) => {
+    const child = spawn(process.execPath, [script, ...args], {
+      stdio: "inherit",
+      shell: false,
+      env: { ...process.env, [NO_UPDATE_ENV]: "1" }
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+    child.on("error", reject);
+  });
+}
+
 // src/main.ts
 var program2 = new Command();
-program2.name("visigraph").description(DESCRIPTION).version(VERSION, "-v, --version", "print the version and exit").helpOption("-h, --help", "print help and exit").helpCommand("help [command]", "print help for a command").showHelpAfterError("(run with --help for usage)").exitOverride();
+program2.name("visigraph").addHelpText("before", `${DESCRIPTION}
+`).version(VERSION, "-v, --version", "print the version and exit").helpOption("-h, --help", "print help and exit").helpCommand("help [command]", "print help for a command").showHelpAfterError("(run with --help for usage)").exitOverride();
 registerValidate(program2);
+var INSTANT = /* @__PURE__ */ new Set(["-v", "--version", "-h", "--help", "help"]);
 try {
   if (process.argv.length <= 2) {
     program2.outputHelp();
     process.exitCode = EXIT.usage;
   } else {
+    if (!process.argv.slice(2).some((a) => INSTANT.has(a))) await maybeUpdate();
     await program2.parseAsync(process.argv);
   }
 } catch (e) {