[feat] nopy update command and auto-update pipeline

2026-07-29 11:16:52 +02:00
parent 6ecb2c366f
commit ea08e76a2f
25 changed files with 4659 additions and 453 deletions
@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+/**
+ * Reports what each publishable package looks like on Gitea versus npmjs.
+ *
+ * The two registries are deliberately not equivalent: `publish-snapshot.yml`
+ * pushes a `main` snapshot to Gitea on every push to `main`, while `release.yml`
+ * publishes a tagged version to both. Gitea is therefore a superset, and the
+ * interesting question before a release is which versions exist *only* there —
+ * those are the ones that can still be tested and un-published.
+ *
+ * It also flags a missing `latest` dist-tag, which is worth a line of output
+ * because npm reports it by printing nothing and exiting 0. `npm view <name>`
+ * against a registry with no `latest` looks identical to a working lookup of an
+ * empty package, which is how the whole 1.0.0-alphaN dist-tag problem stayed
+ * invisible for as long as it did.
+ *
+ *   node scripts/registry-status.mjs
+ *   node scripts/registry-status.mjs --json
+ *   node scripts/registry-status.mjs --registry http://localhost:4873/
+ */
+
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const PACKAGES_DIR = 'packages';
+const SCOPE = '@bitsquare';
+const NPMJS_REGISTRY = 'https://registry.npmjs.org/';
+const FALLBACK_GITEA = 'https://gitea.bitsquare.dev/api/packages/BitSquare/npm/';
+const TIMEOUT_MS = 15_000;
+
+const argv = process.argv.slice(2);
+const asJson = argv.includes('--json');
+const flag = (name, fallback) => {
+  const at = argv.indexOf(name);
+  return at !== -1 && argv[at + 1] ? argv[at + 1] : fallback;
+};
+
+const withSlash = (url) => (url.endsWith('/') ? url : `${url}/`);
+
+/**
+ * The scope mapping in the repo's own `.npmrc` is the single source of truth,
+ * so this never drifts from what an actual install would do.
+ */
+function resolveGiteaRegistry() {
+  try {
+    const out = execFileSync('npm', ['config', 'get', `${SCOPE}:registry`], {
+      encoding: 'utf-8',
+      timeout: 10_000,
+    }).trim();
+    // npm prints the literal string "undefined" for an unset key.
+    if (out && out !== 'undefined' && out !== 'null') return withSlash(out);
+  } catch {
+    // npm missing or unreadable config — the fallback is still correct.
+  }
+  return FALLBACK_GITEA;
+}
+
+const GITEA_REGISTRY = withSlash(flag('--registry', resolveGiteaRegistry()));
+
+/** Fetches a packument, normalising every failure into a shape the report can print. */
+async function packument(registry, name) {
+  let response;
+  try {
+    response = await fetch(`${registry}${encodeURIComponent(name)}`, {
+      headers: { accept: 'application/vnd.npm.install-v1+json, application/json' },
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+  } catch (error) {
+    return { reachable: false, note: error.name === 'TimeoutError' ? 'timed out' : 'unreachable' };
+  }
+
+  if (response.status === 404) return { reachable: true, published: false };
+  if (!response.ok) return { reachable: true, note: `HTTP ${response.status}` };
+
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { reachable: true, note: 'unparseable response' };
+  }
+
+  // Gitea answers a missing package with 200 + {"error": "Not found"} rather
+  // than a 404, so the body has to be checked as well as the status.
+  if (body.error) return { reachable: true, published: false };
+
+  return {
+    reachable: true,
+    published: true,
+    tags: body['dist-tags'] ?? {},
+    versions: Object.keys(body.versions ?? {}),
+  };
+}
+
+const packages = fs
+  .readdirSync(PACKAGES_DIR)
+  .map((name) => path.join(PACKAGES_DIR, name))
+  .filter((dir) => fs.existsSync(path.join(dir, 'package.json')))
+  .map((dir) => ({ dir, manifest: JSON.parse(fs.readFileSync(path.join(dir, 'package.json'))) }))
+  .filter(({ manifest }) => !manifest.private)
+  .sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
+
+const report = await Promise.all(
+  packages.map(async ({ dir, manifest }) => {
+    const [gitea, npmjs] = await Promise.all([
+      packument(GITEA_REGISTRY, manifest.name),
+      packument(NPMJS_REGISTRY, manifest.name),
+    ]);
+
+    const npmjsVersions = new Set(npmjs.versions ?? []);
+    const giteaOnly = (gitea.versions ?? []).filter((v) => !npmjsVersions.has(v));
+
+    return {
+      name: manifest.name,
+      dir,
+      local: manifest.version,
+      gitea,
+      npmjs,
+      giteaOnly,
+      localPublished: {
+        gitea: (gitea.versions ?? []).includes(manifest.version),
+        npmjs: npmjsVersions.has(manifest.version),
+      },
+    };
+  })
+);
+
+if (asJson) {
+  console.log(
+    JSON.stringify(
+      { registries: { gitea: GITEA_REGISTRY, npmjs: NPMJS_REGISTRY }, report },
+      null,
+      2
+    )
+  );
+  process.exit(0);
+}
+
+const describe = (result) => {
+  if (!result.reachable) return `(${result.note})`;
+  if (result.note) return `(${result.note})`;
+  if (!result.published) return '(not published)';
+  const tags = Object.entries(result.tags)
+    .map(([tag, version]) => `${tag}=${version}`)
+    .sort()
+    .join(', ');
+  const count = `${result.versions.length} version${result.versions.length === 1 ? '' : 's'}`;
+  return `${count}${tags ? ` — ${tags}` : ' — no dist-tags'}`;
+};
+
+console.log('Registry status\n');
+console.log(`  gitea  ${GITEA_REGISTRY}`);
+console.log(`  npmjs  ${NPMJS_REGISTRY}`);
+
+for (const entry of report) {
+  console.log(`\n${entry.name}  (local ${entry.local})`);
+  console.log(`  gitea  ${describe(entry.gitea)}`);
+  console.log(`  npmjs  ${describe(entry.npmjs)}`);
+
+  if (entry.giteaOnly.length > 0) {
+    console.log(`  gitea only  ${entry.giteaOnly.join(', ')}`);
+  }
+
+  const notes = [];
+  if (entry.gitea.published && !entry.gitea.tags.latest) {
+    notes.push('no `latest` on gitea — an untagged install resolves to nothing, silently');
+  }
+  if (!entry.localPublished.gitea && !entry.localPublished.npmjs) {
+    notes.push(`local ${entry.local} is on neither registry`);
+  } else if (entry.localPublished.gitea && !entry.localPublished.npmjs) {
+    notes.push(`local ${entry.local} is testable on gitea, not yet released to npmjs`);
+  }
+  for (const note of notes) console.log(`  ! ${note}`);
+}
+
+const testable = report.filter((entry) => entry.giteaOnly.length > 0);
+console.log(
+  testable.length > 0
+    ? `\n${testable.length} of ${report.length} packages have versions on gitea that npmjs does not.` +
+        '\nInstall one with an explicit tag, e.g. `npm i -g @bitsquare/nopy@main` — see README.PUBLISH.md.'
+    : '\nEvery version on gitea is also on npmjs.'
+);