rshow 0.0.8 → 0.0.9

package/dist/main.js

@@ -26,8 +26,8 @@
  */
 
 // src/main.ts
-import path26 from "node:path";
-import process23 from "node:process";
+import path28 from "node:path";
+import process25 from "node:process";
 
 // src/binary.ts
 import { mkdir, mkdtemp, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -38,7 +38,7 @@ import process from "node:process";
 // src/version.ts
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-var VERSION = true ? "0.0.8" : versionFromPackage();
+var VERSION = true ? "0.0.9" : versionFromPackage();
 
 // src/binary.ts
 var ASSET_MANIFEST = "assets.json";
@@ -998,6 +998,7 @@ commands:
   pin <slug> <n|live>     serve version n, or live for the newest
   delete <slug> [--version n] [--force] --yes
                           delete an artifact, or one version of it
+  upgrade [--check]       update rshow to the newest release
   login [--url u]         save the API token for this account
   logout [--url u]        remove the saved token for a server
   completion <shell>      print a completion script for bash, zsh or fish
@@ -1275,6 +1276,31 @@ A theme or a theme version also needs --force, because pages link to it.
 A pinned version and the only version of an artifact cannot be deleted.
 A public version can stay visible for up to 5 minutes after the delete, and a
 theme file for longer.`;
+var UPGRADE_USAGE = `usage: rshow upgrade [--check] [--version <x.y.z>] [--force]
+
+Updates rshow to the newest release, or to the release --version names, which
+may be an older one.
+A single executable is replaced in place, and an npm global install runs
+npm install -g rshow@<version>.
+Any other install, such as a source checkout, an npx cache or a local
+dependency, is left alone and named with the tool that owns it.
+Running the command is the consent: there is no --yes.
+No config and no token are read, so it works before rshow init.
+
+--check prints the current and the newest version and changes nothing, and
+exits 0 either way; --json prints {current, latest, upgrade_available}.
+A run prints upgraded <old> -> <new>, or already at <version>. --json prints
+{previous, version, upgraded, kind}, where kind is binary or npm.
+--version takes x.y.z with an optional leading v; --force reinstalls the same
+version, which is how a broken binary comes back.
+Skills that rshow installed are refreshed by the new rshow, and a bash, zsh or
+fish completion that is already there is replaced; RSHOW_NO_COMPLETIONS=1
+leaves the completions alone.
+RSHOW_DOWNLOAD_BASE downloads from a mirror instead of the release, and takes
+an http or https url; it cannot be used with --check.
+
+A release older than this one has no upgrade command, so after a downgrade
+come back with curl -fsSL https://rslib.github.io/rshow/install.sh | sh.`;
 var LOGIN_USAGE = `usage: rshow login [--url u]
 
 Reads the token from stdin, checks it with the API, then saves it in the macOS
@@ -1968,27 +1994,27 @@ var sqrtTall = function sqrtTall2(extraVinculum, hLinePad2, viewBoxHeight) {
 };
 var sqrtPath = function sqrtPath2(size, extraVinculum, viewBoxHeight) {
   extraVinculum = 1e3 * extraVinculum;
-  var path27 = "";
+  var path29 = "";
   switch (size) {
     case "sqrtMain":
-      path27 = sqrtMain(extraVinculum, hLinePad);
+      path29 = sqrtMain(extraVinculum, hLinePad);
       break;
     case "sqrtSize1":
-      path27 = sqrtSize1(extraVinculum, hLinePad);
+      path29 = sqrtSize1(extraVinculum, hLinePad);
       break;
     case "sqrtSize2":
-      path27 = sqrtSize2(extraVinculum, hLinePad);
+      path29 = sqrtSize2(extraVinculum, hLinePad);
       break;
     case "sqrtSize3":
-      path27 = sqrtSize3(extraVinculum, hLinePad);
+      path29 = sqrtSize3(extraVinculum, hLinePad);
       break;
     case "sqrtSize4":
-      path27 = sqrtSize4(extraVinculum, hLinePad);
+      path29 = sqrtSize4(extraVinculum, hLinePad);
       break;
     case "sqrtTall":
-      path27 = sqrtTall(extraVinculum, hLinePad, viewBoxHeight);
+      path29 = sqrtTall(extraVinculum, hLinePad, viewBoxHeight);
   }
-  return path27;
+  return path29;
 };
 var innerPath = function innerPath2(name, height) {
   switch (name) {
@@ -6202,8 +6228,8 @@ var svgData = {
 };
 var staticSvg = function staticSvg2(value, options) {
   var _svgData$value = svgData[value], pathName = _svgData$value[0], width = _svgData$value[1], height = _svgData$value[2];
-  var path27 = new PathNode(pathName);
-  var svgNode = new SvgNode([path27], {
+  var path29 = new PathNode(pathName);
+  var svgNode = new SvgNode([path29], {
     "width": makeEm(width),
     "height": makeEm(height),
     // Override CSS rule `.katex svg { width: 100% }`
@@ -7346,8 +7372,8 @@ var stretchySvg = function stretchySvg2(group, options) {
           pathName = "tilde" + imgIndex;
         }
       }
-      var path27 = new PathNode(pathName);
-      var svgNode = new SvgNode([path27], {
+      var path29 = new PathNode(pathName);
+      var svgNode = new SvgNode([path29], {
         "width": "100%",
         "height": makeEm(_height),
         "viewBox": "0 0 " + viewBoxWidth + " " + viewBoxHeight,
@@ -8561,8 +8587,8 @@ var makeGlyphSpan = function makeGlyphSpan2(symbol, font, mode, options) {
 };
 var makeInner = function makeInner2(ch2, height, options) {
   var width = fontMetricsData["Size4-Regular"][ch2.charCodeAt(0)] ? fontMetricsData["Size4-Regular"][ch2.charCodeAt(0)][4] : fontMetricsData["Size1-Regular"][ch2.charCodeAt(0)][4];
-  var path27 = new PathNode("inner", innerPath(ch2, Math.round(1e3 * height)));
-  var svgNode = new SvgNode([path27], {
+  var path29 = new PathNode("inner", innerPath(ch2, Math.round(1e3 * height)));
+  var svgNode = new SvgNode([path29], {
     "width": makeEm(width),
     "height": makeEm(height),
     // Override CSS rule `.katex svg { width: 100% }`
@@ -8731,10 +8757,10 @@ var makeStackedDelim = function makeStackedDelim2(delim, heightTotal, center, op
     var midHeight = realHeightTotal - topHeightTotal - bottomHeightTotal;
     var viewBoxHeight = Math.round(realHeightTotal * 1e3);
     var pathStr = tallDelim(svgLabel, Math.round(midHeight * 1e3));
-    var path27 = new PathNode(svgLabel, pathStr);
+    var path29 = new PathNode(svgLabel, pathStr);
     var width = makeEm(viewBoxWidth / 1e3);
     var height = makeEm(viewBoxHeight / 1e3);
-    var svg = new SvgNode([path27], {
+    var svg = new SvgNode([path29], {
       "width": width,
       "height": height,
       "viewBox": "0 0 " + viewBoxWidth + " " + viewBoxHeight
@@ -8775,8 +8801,8 @@ var makeStackedDelim = function makeStackedDelim2(delim, heightTotal, center, op
 var vbPad = 80;
 var emPad = 0.08;
 var sqrtSvg = function sqrtSvg2(sqrtName, height, viewBoxHeight, extraVinculum, options) {
-  var path27 = sqrtPath(sqrtName, extraVinculum, viewBoxHeight);
-  var pathNode = new PathNode(sqrtName, path27);
+  var path29 = sqrtPath(sqrtName, extraVinculum, viewBoxHeight);
+  var pathNode = new PathNode(sqrtName, path29);
   var svg = new SvgNode([pathNode], {
     // Note: 1000:1 ratio of viewBox to document em width.
     "width": "400em",
@@ -9275,8 +9301,8 @@ var htmlBuilder$7 = (group, options) => {
     var angleHeight = inner2.height + inner2.depth + lineWeight + clearance;
     inner2.style.paddingLeft = makeEm(angleHeight / 2 + lineWeight);
     var viewBoxHeight = Math.floor(1e3 * angleHeight * scale);
-    var path27 = phasePath(viewBoxHeight);
-    var svgNode = new SvgNode([new PathNode("phase", path27)], {
+    var path29 = phasePath(viewBoxHeight);
+    var svgNode = new SvgNode([new PathNode("phase", path29)], {
       "width": "400em",
       "height": makeEm(viewBoxHeight / 1e3),
       "viewBox": "0 0 400000 " + viewBoxHeight,
@@ -13305,11 +13331,11 @@ var newcommand = (context, existsOK, nonexistsOK, skipIfExists) => {
     throw new ParseError("\\newcommand's first argument must be a macro name");
   }
   var name = arg[0].text;
-  var exists2 = context.isDefined(name);
-  if (exists2 && !existsOK) {
+  var exists3 = context.isDefined(name);
+  if (exists3 && !existsOK) {
     throw new ParseError("\\newcommand{" + name + "} attempting to redefine " + (name + "; use \\renewcommand"));
   }
-  if (!exists2 && !nonexistsOK) {
+  if (!exists3 && !nonexistsOK) {
     throw new ParseError("\\renewcommand{" + name + "} when command " + name + " does not yet exist; use \\newcommand");
   }
   var numArgs = 0;
@@ -13327,7 +13353,7 @@ var newcommand = (context, existsOK, nonexistsOK, skipIfExists) => {
     numArgs = parseInt(argText);
     arg = context.consumeArg().tokens;
   }
-  if (!(exists2 && skipIfExists)) {
+  if (!(exists3 && skipIfExists)) {
     context.macros.set(name, {
       tokens: arg,
       numArgs
@@ -17046,7 +17072,7 @@ function sameFiles(local, remote) {
   const paths = Object.keys(local);
   const other = remote;
   if (paths.length !== Object.keys(other).length) return false;
-  return paths.every((path27) => other[path27]?.hash === local[path27]?.hash);
+  return paths.every((path29) => other[path29]?.hash === local[path29]?.hash);
 }
 function reportUnchanged(out, result) {
   out.data({ unchanged: true, slug: result.slug, version: result.version.n });
@@ -17784,8 +17810,8 @@ function keyLine(text2, key2, mode) {
   }
   return 0;
 }
-function finding(path27, line, severity, message) {
-  return { path: path27, line: Math.max(1, line), severity, message };
+function finding(path29, line, severity, message) {
+  return { path: path29, line: Math.max(1, line), severity, message };
 }
 function resolveValue(name, map, fallback) {
   let current = map[name] ?? fallback[name];
@@ -19171,8 +19197,8 @@ async function create(argv, ctx) {
   if (baseDir === void 0) throw new UsageError(`no built-in theme: ${from}`);
   const parent = path18.resolve(stringValue(args, "dir") ?? ".");
   const target = path18.join(parent, name);
-  const exists2 = await stat13(target).catch(() => void 0);
-  if (exists2 !== void 0) throw new UsageError(`${target} already exists`);
+  const exists3 = await stat13(target).catch(() => void 0);
+  if (exists3 !== void 0) throw new UsageError(`${target} already exists`);
   const values = await baseRoleValues(baseDir, ROLE_TOKENS);
   const doc = { name, extends: from, tokens: {}, modeTokens: values };
   await mkdir6(target, { recursive: true });
@@ -22729,6 +22755,7 @@ var USAGE = {
   delete: DELETE_USAGE,
   login: LOGIN_USAGE,
   logout: LOGOUT_USAGE,
+  upgrade: UPGRADE_USAGE,
   completion: COMPLETION_USAGE
 };
 var WHEN = {
@@ -23105,6 +23132,7 @@ var SPECS = {
   delete: { usage: DELETE_USAGE },
   login: { usage: LOGIN_USAGE },
   logout: { usage: LOGOUT_USAGE },
+  upgrade: { usage: UPGRADE_USAGE },
   completion: { usage: COMPLETION_USAGE, choices: [...SHELLS] }
 };
 function optionsOf(usage) {
@@ -23470,15 +23498,507 @@ async function run20(argv, ctx, platform = process21.platform) {
   ctx.out.line(`logged in as ${email} (scope ${scope}) for ${url}, saved in ${store2.description}`);
 }
 
-// src/commands/logout.ts
+// src/commands/upgrade.ts
+import { realpath as realpath2 } from "node:fs/promises";
+import path27 from "node:path";
+import process23 from "node:process";
+
+// src/upgrade.ts
+import { execFile, spawn as spawn6 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { chmod as chmod2, copyFile as copyFile2, lstat as lstat2, mkdtemp as mkdtemp5, readFile as readFile19, realpath, rename as rename3, rm as rm8, stat as stat15 } from "node:fs/promises";
+import path26 from "node:path";
 import process22 from "node:process";
-async function run21(argv, ctx, platform = process22.platform) {
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var REPO = "rslib/rshow";
+var NPM_HINT = "npm i -g rshow";
+var INSTALLER_ELSEWHERE = `curl -fsSL https://rslib.github.io/rshow/install.sh | RSHOW_INSTALL_DIR=$HOME/.local/bin sh`;
+var LATEST_URL = `https://github.com/${REPO}/releases/latest`;
+var RELEASES = `https://github.com/${REPO}/releases/download/v`;
+var TARGETS = ["linux-x64", "linux-arm64", "darwin-arm64"];
+var VERSION_PATTERN = /^v?([0-9]+\.[0-9]+\.[0-9]+)$/;
+var TAG_PATH = /\/tag\/v([0-9]+\.[0-9]+\.[0-9]+)$/;
+var LOOKUP_TIMEOUT_MS = 15e3;
+var DOWNLOAD_TIMEOUT_MS = 6e5;
+var UNPACK_TIMEOUT_MS = 12e4;
+var RUN_TIMEOUT_MS = 2e4;
+var NPM_TIMEOUT_MS = 3e5;
+var SKILLS_TIMEOUT_MS = 12e4;
+var UpgradeFailure = class extends Error {
+  exit;
+  constructor(message, exit = EXIT.api) {
+    super(message);
+    this.name = "UpgradeFailure";
+    this.exit = exit;
+  }
+};
+function messageOf12(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function codeOf(err) {
+  const code = typeof err === "object" && err !== null ? err.code : void 0;
+  if (typeof code === "number") return `exit ${code}`;
+  if (typeof code === "string" && code !== "") return code;
+  return messageOf12(err);
+}
+function runProgram(file, args, options = {}) {
+  return new Promise((resolve2, reject) => {
+    const run23 = { timeout: options.timeoutMs, maxBuffer: 16 * 1024 * 1024 };
+    execFile(file, [...args], run23, (err, stdout) => {
+      if (err !== null) {
+        reject(err);
+        return;
+      }
+      resolve2(stdout);
+    });
+  });
+}
+function parseVersion(raw) {
+  const found = VERSION_PATTERN.exec(raw.trim());
+  if (found === null) throw new UsageError(`--version needs x.y.z, got: ${raw}`);
+  return found[1];
+}
+function compareVersions(left, right) {
+  const a = left.split(".").map(Number);
+  const b = right.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const diff = (a[index] ?? 0) - (b[index] ?? 0);
+    if (diff !== 0) return diff < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function targetOf2(platform, arch) {
+  const name = `${platform}-${arch}`;
+  return TARGETS.includes(name) ? name : void 0;
+}
+function releaseTagOf(location) {
+  if (location === null || location.trim() === "") return void 0;
+  let pathname;
+  try {
+    pathname = new URL(location, LATEST_URL).pathname;
+  } catch {
+    return void 0;
+  }
+  return TAG_PATH.exec(pathname)?.[1];
+}
+async function latestVersion(options) {
+  const reply = await sendRequest(
+    options.fetch,
+    LATEST_URL,
+    { redirect: "manual", signal: AbortSignal.timeout(LOOKUP_TIMEOUT_MS) },
+    options.env
+  );
+  const location = reply.headers.get("location");
+  const version2 = releaseTagOf(location);
+  if (version2 === void 0) {
+    throw new UpgradeFailure(`${LATEST_URL} did not name a release (location: ${location ?? "none"})`);
+  }
+  return version2;
+}
+function mirrorOf(options) {
+  const raw = (options.env.RSHOW_DOWNLOAD_BASE ?? "").trim();
+  if (raw === "") return void 0;
+  const base = raw.replace(/\/+$/, "");
+  let protocol;
+  try {
+    protocol = new URL(base).protocol;
+  } catch {
+    throw new UsageError(`RSHOW_DOWNLOAD_BASE is not a url: ${raw}`);
+  }
+  if (protocol !== "http:" && protocol !== "https:") {
+    throw new UsageError(`RSHOW_DOWNLOAD_BASE needs an http or https url, got: ${raw}`);
+  }
+  return base;
+}
+function otherError(options) {
+  const from = options.install.argv1 ?? options.install.execPath;
+  const version2 = options.wanted ?? "<version>";
+  const where = from.split(path26.sep).join("/");
+  if (where.includes("/_npx/")) {
+    return new UsageError(`rshow runs from ${from}, an npx cache that npm owns; run npx rshow@${version2}`);
+  }
+  if (where.includes("/node_modules/")) {
+    return new UsageError(
+      `rshow runs from ${from}, a local dependency that npm owns; run npm install rshow@${version2} to update it`
+    );
+  }
+  return new UsageError(`rshow runs from ${from}, a source checkout; update it with git pull and npm run build`);
+}
+function dataHome(env) {
+  const xdg = (env.XDG_DATA_HOME ?? "").trim();
+  return xdg !== "" ? xdg : path26.join(homeDir(env), ".local", "share");
+}
+function configHome(env) {
+  const xdg = (env.XDG_CONFIG_HOME ?? "").trim();
+  return xdg !== "" ? xdg : path26.join(homeDir(env), ".config");
+}
+function completionPaths(env) {
+  const data = dataHome(env);
+  const config = configHome(env);
+  return [
+    { name: "rshow.bash", dst: path26.join(data, "bash-completion", "completions", "rshow") },
+    { name: "_rshow", dst: path26.join(data, "zsh", "site-functions", "_rshow") },
+    { name: "rshow.fish", dst: path26.join(config, "fish", "completions", "rshow.fish") }
+  ];
+}
+async function exists2(file) {
+  return await stat15(file).catch(() => void 0) !== void 0;
+}
+function missingFile(name, url, named) {
+  if (named === void 0) {
+    return new UpgradeFailure(
+      `this release has no ${name} (${url}); a new release attaches its binaries a few minutes after it appears, so try again`
+    );
+  }
+  return new UpgradeFailure(
+    `release v${named} has no ${name} (${url}); it may not exist, and a release before 0.0.6 has no tarball, so use the installer with RSHOW_VERSION=${named}`
+  );
+}
+async function download(options, url, file, name, named) {
+  const reply = await sendRequest(options.fetch, url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }, options.env);
+  if (reply.status === 404) throw missingFile(name, url, named);
+  if (reply.status !== 200 || reply.body === null) {
+    throw new UpgradeFailure(`cannot download ${url}: HTTP ${reply.status}`);
+  }
+  try {
+    await pipeline(Readable.fromWeb(reply.body), createWriteStream(file));
+  } catch (err) {
+    throw new UpgradeFailure(`cannot write ${file}: ${messageOf12(err)}`);
+  }
+}
+function sumOf(text2, name) {
+  for (const line of text2.split("\n")) {
+    const parts2 = line.trim().split(/\s+/);
+    if (parts2.length < 2) continue;
+    if (parts2[1].replace(/^\*/, "") === name) return parts2[0];
+  }
+  return void 0;
+}
+async function sha256Of(file) {
+  const hash = createHash3("sha256");
+  await pipeline(createReadStream(file), hash);
+  return hash.digest("hex");
+}
+async function checkSum(file, name, sumsFile) {
+  const expected = sumOf(await readFile19(sumsFile, "utf8"), name);
+  const actual = await sha256Of(file);
+  if (expected === void 0) {
+    throw new UpgradeFailure(`SHA256SUMS holds no line for ${name}, and the download is ${actual}`);
+  }
+  if (expected !== actual) {
+    throw new UpgradeFailure(`checksum mismatch for ${name}: SHA256SUMS says ${expected}, the download is ${actual}`);
+  }
+}
+async function unpack2(file, dir, tarball) {
+  try {
+    await runProgram("tar", ["-xzf", file, "-C", dir], { timeoutMs: UNPACK_TIMEOUT_MS });
+  } catch (err) {
+    throw new UpgradeFailure(`cannot unpack ${tarball}: ${codeOf(err)}`);
+  }
+}
+async function printedVersion(file) {
+  try {
+    return (await runProgram(file, ["--version"], { timeoutMs: RUN_TIMEOUT_MS })).trim();
+  } catch (err) {
+    throw new UpgradeFailure(`the new rshow does not run (${codeOf(err)}); the old rshow is still in place`);
+  }
+}
+async function replaceCompletions(options, dir, target) {
+  if ((options.env.RSHOW_NO_COMPLETIONS ?? "").trim() === "1") return;
+  for (const entry of completionPaths(options.env)) {
+    const src = path26.join(dir, `rshow-${target}`, "completions", entry.name);
+    try {
+      if (!await exists2(entry.dst) || !await exists2(src)) continue;
+      await copyFile2(src, entry.dst);
+    } catch (err) {
+      warn(`cannot replace the completion ${entry.dst}: ${messageOf12(err)}`);
+    }
+  }
+}
+function modeOf(target, statuses) {
+  const kinds = statuses.filter((entry) => entry.target === target).map((entry) => entry.state.kind);
+  if (kinds.includes("copy")) return "copy";
+  if (kinds.includes("link")) return "link";
+  return void 0;
+}
+async function refreshSkills(options, file, prefix) {
+  const targets = await detectedTargets(options.home);
+  if (targets.length === 0) return;
+  let source;
+  try {
+    source = await skillsSource(options.env);
+  } catch {
+    return;
+  }
+  if (source === void 0) return;
+  const statuses = await skillsStatus({ home: options.home, source, targets });
+  const groups = { copy: [], link: [] };
+  for (const target of targets) {
+    const mode = modeOf(target, statuses);
+    if (mode !== void 0) groups[mode].push(target);
+  }
+  for (const mode of ["copy", "link"]) {
+    if (groups[mode].length === 0) continue;
+    try {
+      await runProgram(file, [...prefix, "skills", "install", `--${mode}`, ...groups[mode]], {
+        timeoutMs: SKILLS_TIMEOUT_MS
+      });
+    } catch (err) {
+      warn(`the new rshow could not refresh the skills (${codeOf(err)}); run rshow skills install`);
+    }
+  }
+}
+function versionIn(printed) {
+  return /^rshow ([0-9]+\.[0-9]+\.[0-9]+)/.exec(printed)?.[1];
+}
+async function replaceBinary(job, dest) {
+  const dir = path26.dirname(dest);
+  let tmp;
+  try {
+    tmp = await mkdtemp5(path26.join(dir, ".rshow-upgrade-"));
+  } catch (err) {
+    const code = err.code;
+    if (code === "EACCES" || code === "EPERM" || code === "EROFS") {
+      throw new UpgradeFailure(`${dir} is not writable; install elsewhere instead: ${INSTALLER_ELSEWHERE}`);
+    }
+    throw new UpgradeFailure(`cannot write next to ${dest}: ${messageOf12(err)}`);
+  }
+  try {
+    const tarball = `rshow-${job.target}.tar.gz`;
+    const file = path26.join(tmp, tarball);
+    const sums = path26.join(tmp, "SHA256SUMS");
+    const url = `${job.base}/${tarball}`;
+    process22.stderr.write(`rshow: downloading ${url}
+`);
+    await download(job.options, url, file, tarball, job.named);
+    await download(job.options, `${job.base}/SHA256SUMS`, sums, "SHA256SUMS", job.named);
+    await checkSum(file, tarball, sums);
+    await unpack2(file, tmp, tarball);
+    const folder = `rshow-${job.target}`;
+    const unpacked = path26.join(tmp, folder, "rshow");
+    const info = await lstat2(unpacked).catch(() => void 0);
+    if (info === void 0) {
+      throw new UpgradeFailure(`${tarball} holds no ${folder}/rshow; the old rshow is still in place`);
+    }
+    if (!info.isFile()) {
+      throw new UpgradeFailure(`${tarball} holds a ${folder}/rshow that is not a file; the old rshow is still in place`);
+    }
+    await chmod2(unpacked, 493);
+    const printed = await printedVersion(unpacked);
+    let version2;
+    if (job.version === void 0) {
+      const found = versionIn(printed);
+      if (found === void 0) {
+        throw new UpgradeFailure(`the new rshow printed ${printed || "no version"}; the old rshow is still in place`);
+      }
+      if (!job.force && found === job.options.current) return { replaced: false, version: found };
+      version2 = found;
+    } else {
+      if (!printed.startsWith(`rshow ${job.version}`)) {
+        throw new UpgradeFailure(
+          `the new rshow printed ${printed || "no version"}, not rshow ${job.version}; the old rshow is still in place`
+        );
+      }
+      version2 = job.version;
+    }
+    await rename3(unpacked, dest);
+    await replaceCompletions(job.options, tmp, job.target);
+    return { replaced: true, version: version2 };
+  } finally {
+    await rm8(tmp, { recursive: true, force: true });
+  }
+}
+async function installPath(options) {
+  try {
+    return await realpath(options.install.execPath);
+  } catch (err) {
+    throw new UpgradeFailure(`cannot read ${options.install.execPath}: ${messageOf12(err)}`);
+  }
+}
+function targetOrFail(options) {
+  const platform = options.platform ?? process22.platform;
+  const arch = options.arch ?? process22.arch;
+  const target = targetOf2(platform, arch);
+  if (target === void 0) {
+    throw new UsageError(`no rshow single executable for ${platform}-${arch}; run ${NPM_HINT}`);
+  }
+  return target;
+}
+async function installBinary(job) {
+  const dest = await installPath(job.options);
+  const outcome = await replaceBinary(job, dest);
+  if (!outcome.replaced) return { status: "current", kind: "binary", version: outcome.version };
+  await refreshSkills(job.options, dest, []);
+  return { status: "upgraded", kind: "binary", previous: job.options.current, version: outcome.version };
+}
+function runNpm(args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn6("npm", [...args], { stdio: ["ignore", 2, 2], timeout: NPM_TIMEOUT_MS });
+    child.on("error", (err) => {
+      child.emit("exit", null, null);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        resolve2();
+        return;
+      }
+      if (code !== null) {
+        const err = Object.assign(new Error(`npm exited ${code}`), { code });
+        reject(err);
+        return;
+      }
+      reject(new Error(`npm stopped on ${signal ?? "a timeout"}`));
+    });
+  });
+}
+async function npmInstall(version2) {
+  const command = `npm install -g rshow@${version2}`;
+  try {
+    await runNpm(["install", "-g", `rshow@${version2}`]);
+  } catch (err) {
+    const code = err.code;
+    if (typeof code === "number") throw new UpgradeFailure(`${command} failed (exit ${code})`, code);
+    throw new UpgradeFailure(`cannot run npm (${codeOf(err)}); run ${command}`, EXIT.usage);
+  }
+}
+async function upgrade(options) {
+  const mirror = mirrorOf(options);
+  const force = options.force === true;
+  const kind = options.install.kind;
+  if (options.check === true) {
+    if (mirror !== void 0) {
+      throw new UsageError(`--check cannot be used with RSHOW_DOWNLOAD_BASE (${mirror}), which names no release`);
+    }
+    const latest = options.wanted ?? await latestVersion(options);
+    return {
+      status: "check",
+      current: options.current,
+      latest,
+      upgrade: compareVersions(latest, options.current) > 0
+    };
+  }
+  if (kind === "other") throw otherError(options);
+  if (kind === "binary" && mirror !== void 0 && options.wanted === void 0) {
+    return installBinary({ options, base: mirror, target: targetOrFail(options), force });
+  }
+  let version2 = options.wanted;
+  if (version2 === void 0) {
+    const latest = await latestVersion(options);
+    if (compareVersions(latest, options.current) < 0) {
+      return { status: "newer", kind, current: options.current, latest };
+    }
+    version2 = latest;
+  }
+  if (version2 === options.current && !force) {
+    return { status: "current", kind, version: version2 };
+  }
+  if (kind === "binary") {
+    const base = mirror ?? `${RELEASES}${version2}`;
+    return installBinary({ options, base, target: targetOrFail(options), version: version2, named: options.wanted, force });
+  }
+  await npmInstall(version2);
+  const argv1 = options.install.argv1;
+  if (argv1 !== void 0) await refreshSkills(options, process22.execPath, [argv1]);
+  return { status: "upgraded", kind: "npm", previous: options.current, version: version2 };
+}
+function reportOf(result) {
+  if (result.status === "check") {
+    return {
+      data: { current: result.current, latest: result.latest, upgrade_available: result.upgrade },
+      lines: [`current: ${result.current}`, `latest: ${result.latest}`]
+    };
+  }
+  if (result.status === "newer") {
+    return {
+      data: { previous: result.current, version: result.current, upgraded: false, kind: result.kind },
+      lines: [`rshow: ${result.current} is newer than the newest release, ${result.latest}`]
+    };
+  }
+  if (result.status === "current") {
+    return {
+      data: { previous: result.version, version: result.version, upgraded: false, kind: result.kind },
+      lines: [`rshow: already at ${result.version}`]
+    };
+  }
+  return {
+    data: { previous: result.previous, version: result.version, upgraded: true, kind: result.kind },
+    lines: [`rshow: upgraded ${result.previous} -> ${result.version}`]
+  };
+}
+
+// src/commands/upgrade.ts
+var TIMEOUT_MS2 = 6e4;
+function isUnder2(file, dir) {
+  const rel2 = path27.relative(dir, file);
+  return rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path27.sep}`) && !path27.isAbsolute(rel2);
+}
+async function npmRoot() {
+  try {
+    const root2 = (await runProgram("npm", ["root", "-g"], { timeoutMs: TIMEOUT_MS2 })).trim();
+    return root2 === "" ? void 0 : await realpath2(root2);
+  } catch {
+    return void 0;
+  }
+}
+async function installKind() {
+  if (await isBinary()) return { kind: "binary", execPath: process23.execPath };
+  const argv1 = process23.argv[1];
+  const root2 = await npmRoot();
+  if (root2 !== void 0 && argv1 !== void 0) {
+    const script3 = await realpath2(argv1).catch(() => void 0);
+    if (script3 !== void 0 && isUnder2(script3, root2)) {
+      return { kind: "npm", execPath: process23.execPath, argv1: script3 };
+    }
+  }
+  return { kind: "other", execPath: process23.execPath, argv1 };
+}
+async function run21(argv, ctx) {
+  const args = parseCommandArgs(
+    argv,
+    { check: { type: "boolean" }, version: { type: "string" }, force: { type: "boolean" } },
+    0,
+    0,
+    UPGRADE_USAGE
+  );
+  const raw = stringValue(args, "version");
+  const wanted = raw === void 0 ? void 0 : parseVersion(raw);
+  const env = process23.env;
+  let result;
+  try {
+    result = await upgrade({
+      current: VERSION,
+      wanted,
+      check: boolValue(args, "check"),
+      force: boolValue(args, "force"),
+      install: await installKind(),
+      fetch,
+      env,
+      home: homeDir(env)
+    });
+  } catch (err) {
+    if (!(err instanceof UpgradeFailure)) throw err;
+    process23.stderr.write(`rshow: ${err.message}
+`);
+    return err.exit;
+  }
+  const report = reportOf(result);
+  ctx.out.data(report.data);
+  for (const line of report.lines) ctx.out.line(line);
+  return EXIT.ok;
+}
+
+// src/commands/logout.ts
+import process24 from "node:process";
+async function run22(argv, ctx, platform = process24.platform) {
   const args = parseCommandArgs(argv, { url: { type: "string" } }, 0, 0, LOGOUT_USAGE);
   const settings = await ctx.config();
   const given = (stringValue(args, "url") ?? "").trim();
   const url = (given === "" ? requireUrl(settings) : given).replace(/\/+$/, "");
   const removed = [];
-  for (const store2 of await every(process22.env, platform)) {
+  for (const store2 of await every(process24.env, platform)) {
     if (await store2.remove(url)) removed.push(store2.description);
   }
   if (removed.length === 0) {
@@ -23508,14 +24028,15 @@ var COMMANDS = {
   pin: { usage: PIN_USAGE, run: run12 },
   delete: { usage: DELETE_USAGE, run: run13 },
   login: { usage: LOGIN_USAGE, run: run20 },
-  logout: { usage: LOGOUT_USAGE, run: run21 },
+  logout: { usage: LOGOUT_USAGE, run: run22 },
+  upgrade: { usage: UPGRADE_USAGE, run: run21 },
   completion: { usage: COMPLETION_USAGE, run: run19 },
   // Kept out of the general help: the docs site runs it, a person rarely does.
   docs: { usage: DOCS_USAGE, run: run18 }
 };
 function fail(err) {
   const message = err instanceof Error ? err.message : String(err);
-  process23.stderr.write(`rshow: ${message}
+  process25.stderr.write(`rshow: ${message}
 `);
   if (err instanceof UsageError) return EXIT.usage;
   if (err instanceof CheckError) return EXIT.check;
@@ -23535,17 +24056,17 @@ async function main2(argv) {
   const wantsVersion = versionAt >= 0 && (commandAt < 0 || versionAt < commandAt);
   if (wantsVersion) {
     const suffix = await isBinary() ? " (binary)" : "";
-    process23.stdout.write(`rshow ${VERSION}${suffix}
+    process25.stdout.write(`rshow ${VERSION}${suffix}
 `);
     return EXIT.ok;
   }
   if (wantsHelp) {
-    process23.stdout.write(`${spec === void 0 ? GENERAL_USAGE : spec.usage}
+    process25.stdout.write(`${spec === void 0 ? GENERAL_USAGE : spec.usage}
 `);
     return EXIT.ok;
   }
   if (name === void 0) {
-    process23.stderr.write(`${GENERAL_USAGE}
+    process25.stderr.write(`${GENERAL_USAGE}
 `);
     return EXIT.usage;
   }
@@ -23555,12 +24076,12 @@ async function main2(argv) {
   const rest = [...args.slice(0, commandAt), ...args.slice(commandAt + 1)];
   const configs = /* @__PURE__ */ new Map();
   const clients = /* @__PURE__ */ new Map();
-  const keyOf = (dir) => dir === void 0 ? "" : path26.resolve(dir);
+  const keyOf = (dir) => dir === void 0 ? "" : path28.resolve(dir);
   const configFor = (dir) => {
     const key2 = keyOf(dir);
     let pending = configs.get(key2);
     if (pending === void 0) {
-      pending = loadConfig(process23.env, dir);
+      pending = loadConfig(process25.env, dir);
       configs.set(key2, pending);
     }
     return pending;
@@ -23573,7 +24094,7 @@ async function main2(argv) {
       if (cached !== void 0) return cached;
       const settings = await configFor(dir);
       const url = requireUrl(settings);
-      const client = new Client(url, await readToken(process23.env, url));
+      const client = new Client(url, await readToken(process25.env, url));
       clients.set(key2, client);
       return client;
     },
@@ -23582,11 +24103,11 @@ async function main2(argv) {
   const code = await spec.run(rest, ctx);
   return code ?? EXIT.ok;
 }
-main2(process23.argv.slice(2)).then(
+main2(process25.argv.slice(2)).then(
   (code) => {
-    process23.exitCode = code;
+    process25.exitCode = code;
   },
   (err) => {
-    process23.exitCode = fail(err);
+    process25.exitCode = fail(err);
   }
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rshow",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Publish static artifacts to rshow",
   "license": "MIT",
   "homepage": "https://rslib.github.io/rshow",

package/skills/rshow/reference/cli.md

@@ -28,6 +28,7 @@ This file is the whole surface, both config files and the exit codes.
 | `rshow config [dir] [--offline]` | print the merged config as JSON, with `theme` as `<name>@latest` and, with the network, `theme_resolved` as the version it resolves to |
 | `rshow init --url <admin-url> --art <viewer-url>` | write the global config file, with `--theme` and `--force` |
 | `rshow doctor [dir]` | check node, config, token, api, art, theme and skills, one `ok\|warn\|fail` line each |
+| `rshow upgrade [--check] [--version x.y.z] [--force]` | replace the single executable, or run `npm install -g` on an npm install, with another release |
 | `rshow list` | list artifacts you own or that are shared with you, with `--project`, `--tag` and `--q` filters |
 | `rshow show <slug>` | print the artifact, its versions, its shares, its project and its tags |
 | `rshow share <slug>` | set the mode, or add and remove shares |
@@ -51,6 +52,10 @@ This file is the whole surface, both config files and the exit codes.
 `--help` on its own prints the general usage, and `--help` after a command prints that command.
 `--json` is global and makes stdout the API reply, which is how a script reads a version number.
 
+`rshow upgrade` moves an installed rshow to the newest release, or to the one `--version` names, and `--check` prints both versions and changes nothing.
+It needs no config and no token, and a source checkout or an npx cache is named with the tool that owns it instead of being touched.
+Run `rshow upgrade` only when the person asks for it.
+
 Every flag takes `--flag value` or `--flag=value`.
 `--add`, `--editor`, `--remove` and `--tag` accept several values in a row after one flag.
 

package/worker/index.js

@@ -3277,18 +3277,15 @@ __name(etagMatches, "etagMatches");
 
 // src/cache.ts
 var CACHE_ORIGIN = "https://rshow.internal";
-var ACCESS_TTL_MS = 15e3;
-var ACCESS_MAX_ENTRIES = 500;
 var MANIFEST_MAX_ENTRIES = 200;
 var VERSION_MAX_ENTRIES = 500;
-var ACCESS_CACHE_CONTROL = "max-age=15";
+var ACCESS_CACHE_CONTROL = "max-age=2";
 var MANIFEST_CACHE_CONTROL = "public, max-age=31536000, immutable";
 var VERSION_CACHE_CONTROL = "public, max-age=31536000, immutable";
 var JSON_CONTENT_TYPE = "application/json";
 var BLOB_CACHE_CONTROL = "public, max-age=31536000, immutable";
 var ARTIFACT_COLUMNS2 = "slug, title, owner, mode, pinned, latest, last_n, version_gen, project, created_at, updated_at";
 var VERSION_COLUMNS = "slug, n, label, manifest_key, files, bytes, created_by, created_at";
-var accessMemory = /* @__PURE__ */ new Map();
 var manifestMemory = /* @__PURE__ */ new Map();
 var versionMemory = /* @__PURE__ */ new Map();
 var versionKeys = /* @__PURE__ */ new Map();
@@ -3313,16 +3310,6 @@ function versionMemoryKey(slug, n, gen) {
   return `${slug}/${n}/${gen}`;
 }
 __name(versionMemoryKey, "versionMemoryKey");
-function rememberAccess(slug, value, expires) {
-  accessMemory.delete(slug);
-  accessMemory.set(slug, { value, expires });
-  while (accessMemory.size > ACCESS_MAX_ENTRIES) {
-    const oldest = accessMemory.keys().next().value;
-    if (oldest === void 0) break;
-    accessMemory.delete(oldest);
-  }
-}
-__name(rememberAccess, "rememberAccess");
 function rememberManifest(key, value) {
   manifestMemory.delete(key);
   manifestMemory.set(key, value);
@@ -3453,30 +3440,18 @@ async function loadAccess(env, slug) {
 }
 __name(loadAccess, "loadAccess");
 async function accessFor(env, slug) {
-  const now = Date.now();
-  const memory = accessMemory.get(slug);
-  if (memory && memory.expires > now) {
-    rememberAccess(slug, memory.value, memory.expires);
-    return memory.value;
-  }
-  accessMemory.delete(slug);
   const key = accessCacheKey(slug);
   const cached = await cacheGet(key);
   if (cached) {
     const decoded = decodeAccess(await cached.text());
-    if (decoded.ok) {
-      rememberAccess(slug, decoded.value, now + ACCESS_TTL_MS);
-      return decoded.value;
-    }
+    if (decoded.ok) return decoded.value;
   }
   const value = await loadAccess(env, slug);
-  rememberAccess(slug, value, now + ACCESS_TTL_MS);
   await cachePut(key, JSON.stringify(value), ACCESS_CACHE_CONTROL);
   return value;
 }
 __name(accessFor, "accessFor");
 async function invalidateAccess(slug) {
-  accessMemory.delete(slug);
   const key = accessCacheKey(slug);
   trackedKeys.delete(key);
   try {
@@ -4036,10 +4011,11 @@ function registerArtifactCreate(app) {
     const existing = await getArtifact(c.env, slug);
     if (existing) return jsonError("slug is already taken", 409);
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    let counters;
     try {
-      await c.env.DB.prepare(
-        "INSERT INTO artifacts (slug, title, owner, mode, pinned, latest, project, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, NULL, NULL, ?5, ?6, ?6)"
-      ).bind(slug, title2, email, MODE.private, project, now).run();
+      counters = await c.env.DB.prepare(
+        "INSERT INTO artifacts (slug, title, owner, mode, pinned, latest, last_n, version_gen, project, created_at, updated_at) SELECT ?1, ?2, ?3, ?4, NULL, NULL, COALESCE((SELECT last_n FROM retired_slugs WHERE slug = ?1), 0), COALESCE((SELECT version_gen FROM retired_slugs WHERE slug = ?1), 0), ?5, ?6, ?6 RETURNING last_n, version_gen"
+      ).bind(slug, title2, email, MODE.private, project, now).first();
     } catch {
       return jsonError("slug is already taken", 409);
     }
@@ -4055,8 +4031,8 @@ function registerArtifactCreate(app) {
       mode: MODE.private,
       pinned: null,
       latest: null,
-      last_n: 0,
-      version_gen: 0,
+      last_n: counters?.last_n ?? 0,
+      version_gen: counters?.version_gen ?? 0,
       project,
       created_at: now,
       updated_at: now
@@ -4210,6 +4186,9 @@ function registerArtifactItem(app) {
     if (keys.length > 0) await c.env.BUCKET.delete(keys);
     await deleteArtifactData(c.env, access.artifact.slug);
     await c.env.DB.batch([
+      c.env.DB.prepare(
+        "INSERT INTO retired_slugs (slug, last_n, version_gen) SELECT slug, MAX(last_n, COALESCE(latest, 0)), version_gen + 1 FROM artifacts WHERE slug = ?1 ON CONFLICT(slug) DO UPDATE SET last_n = excluded.last_n, version_gen = excluded.version_gen"
+      ).bind(access.artifact.slug),
       c.env.DB.prepare("DELETE FROM page_data WHERE slug = ?1").bind(access.artifact.slug),
       c.env.DB.prepare("DELETE FROM artifact_tags WHERE slug = ?1").bind(access.artifact.slug),
       c.env.DB.prepare("DELETE FROM versions WHERE slug = ?1").bind(access.artifact.slug),

package/worker/migrations/0006_retired_slugs.sql

@@ -0,0 +1,5 @@
+CREATE TABLE retired_slugs (
+  slug TEXT PRIMARY KEY,
+  last_n INTEGER NOT NULL,
+  version_gen INTEGER NOT NULL
+);