@deeplake/hivemind 0.7.60 → 0.7.62

package/mcp/bundle/server.js

@@ -23683,6 +23683,9 @@ function traceSql(msg) {
     log3(msg);
 }
 var _signalledBalanceExhausted = false;
+var _signalledLowBalance = false;
+var LOW_BALANCE_THRESHOLD_CENTS = 200;
+var BALANCE_HEADER = "X-Activeloop-Balance-Cents";
 function maybeSignalBalanceExhausted(status, bodyText) {
   if (status !== 402)
     return;
@@ -23703,6 +23706,35 @@ function maybeSignalBalanceExhausted(status, bodyText) {
     log3(`enqueue balance-exhausted failed: ${e instanceof Error ? e.message : String(e)}`);
   });
 }
+function signalLowBalanceFromHeader(resp) {
+  if (_signalledLowBalance)
+    return;
+  const raw = resp.headers?.get?.(BALANCE_HEADER);
+  if (!raw)
+    return;
+  if (!/^-?\d+$/.test(raw.trim()))
+    return;
+  const balance = Number(raw.trim());
+  if (!Number.isFinite(balance))
+    return;
+  if (balance >= LOW_BALANCE_THRESHOLD_CENTS)
+    return;
+  if (balance <= 0)
+    return;
+  _signalledLowBalance = true;
+  log3(`balance below threshold (${balance}\xA2) \u2014 enqueuing low-balance banner`);
+  enqueueNotification({
+    id: "low-balance-warning",
+    severity: "warn",
+    transient: true,
+    title: "Your org's Hivemind balance is running low",
+    body: `Only $${(balance / 100).toFixed(2)} of prepaid balance remains. Admins can top up at ${billingUrl()}; otherwise ask an org admin to top up before requests start failing.`,
+    dedupKey: { reason: "low-balance" }
+  }).catch((e) => {
+    _signalledLowBalance = false;
+    log3(`enqueue low-balance failed: ${e instanceof Error ? e.message : String(e)}`);
+  });
+}
 function billingUrl() {
   try {
     const c = loadCredentials();
@@ -23828,6 +23860,7 @@ var DeeplakeApi = class {
         }
         throw lastError;
       }
+      signalLowBalanceFromHeader(resp);
       if (resp.ok) {
         const raw = await resp.json();
         if (!raw?.rows || !raw?.columns)
@@ -23988,6 +24021,7 @@ var DeeplakeApi = class {
             ...deeplakeClientHeader()
           }
         });
+        signalLowBalanceFromHeader(resp);
         if (resp.ok) {
           const data = await resp.json();
           return {

package/openclaw/dist/index.js

@@ -494,6 +494,9 @@ function traceSql(msg) {
   if (globalThis.__hivemind_tuning__.HIVEMIND_DEBUG === "1") log3(msg);
 }
 var _signalledBalanceExhausted = false;
+var _signalledLowBalance = false;
+var LOW_BALANCE_THRESHOLD_CENTS = 200;
+var BALANCE_HEADER = "X-Activeloop-Balance-Cents";
 function maybeSignalBalanceExhausted(status, bodyText) {
   if (status !== 402) return;
   if (!bodyText.includes("balance_cents")) return;
@@ -511,6 +514,29 @@ function maybeSignalBalanceExhausted(status, bodyText) {
     log3(`enqueue balance-exhausted failed: ${e instanceof Error ? e.message : String(e)}`);
   });
 }
+function signalLowBalanceFromHeader(resp) {
+  if (_signalledLowBalance) return;
+  const raw = resp.headers?.get?.(BALANCE_HEADER);
+  if (!raw) return;
+  if (!/^-?\d+$/.test(raw.trim())) return;
+  const balance = Number(raw.trim());
+  if (!Number.isFinite(balance)) return;
+  if (balance >= LOW_BALANCE_THRESHOLD_CENTS) return;
+  if (balance <= 0) return;
+  _signalledLowBalance = true;
+  log3(`balance below threshold (${balance}\xA2) \u2014 enqueuing low-balance banner`);
+  enqueueNotification({
+    id: "low-balance-warning",
+    severity: "warn",
+    transient: true,
+    title: "Your org's Hivemind balance is running low",
+    body: `Only $${(balance / 100).toFixed(2)} of prepaid balance remains. Admins can top up at ${billingUrl()}; otherwise ask an org admin to top up before requests start failing.`,
+    dedupKey: { reason: "low-balance" }
+  }).catch((e) => {
+    _signalledLowBalance = false;
+    log3(`enqueue low-balance failed: ${e instanceof Error ? e.message : String(e)}`);
+  });
+}
 function billingUrl() {
   try {
     const c = loadCredentials();
@@ -636,6 +662,7 @@ var DeeplakeApi = class {
         }
         throw lastError;
       }
+      signalLowBalanceFromHeader(resp);
       if (resp.ok) {
         const raw = await resp.json();
         if (!raw?.rows || !raw?.columns) return [];
@@ -797,6 +824,7 @@ var DeeplakeApi = class {
             ...deeplakeClientHeader()
           }
         });
+        signalLowBalanceFromHeader(resp);
         if (resp.ok) {
           const data = await resp.json();
           return {
@@ -1795,7 +1823,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.7.60".length > 0 ? "0.7.60" : null;
+  return "0.7.62".length > 0 ? "0.7.62" : null;
 }
 function isNewer(latest, current) {
   const parse = (v) => v.replace(/-.*$/, "").split(".").map(Number);

package/openclaw/openclaw.plugin.json

@@ -54,5 +54,5 @@
       }
     }
   },
-  "version": "0.7.60"
+  "version": "0.7.62"
 }

package/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivemind",
-  "version": "0.7.60",
+  "version": "0.7.62",
   "type": "module",
   "description": "Hivemind — cloud-backed persistent shared memory for AI agents, powered by DeepLake",
   "license": "Apache-2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeplake/hivemind",
-  "version": "0.7.60",
+  "version": "0.7.62",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "repository": {
@@ -26,6 +26,7 @@
     "openclaw/openclaw.plugin.json",
     "openclaw/package.json",
     ".claude-plugin",
+    "scripts",
     "README.md",
     "LICENSE"
   ],

package/scripts/audit-openclaw-bundle.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * Local replication of ClawHub's static-analysis scanner against the openclaw
+ * plugin bundle. Runs the same per-file regex rules ClawHub uses at publish
+ * time so we can see flags BEFORE shipping a release instead of after.
+ *
+ * Rules are replicated (not imported) from openclaw's skill-scanner — that
+ * code lives in our research-reference checkout under ~/al-projects/ext/ and
+ * is third-party we don't own. Re-sync these rules if upstream changes them.
+ *
+ *   Reference: openclaw repo, src/security/skill-scanner.ts:147-206
+ *
+ * Usage:
+ *   node scripts/audit-openclaw-bundle.mjs           # scan openclaw/dist
+ *   node scripts/audit-openclaw-bundle.mjs <path>    # scan a specific dir
+ *
+ * Exits non-zero if any "critical" or "warn" finding is reported.
+ */
+
+import { readFileSync, statSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, extname } from "node:path";
+
+// Parse args: positional SCAN_DIR + optional --criticals-only flag.
+//
+// --criticals-only exits non-zero only on `critical` findings, treating
+// `warn` as advisory. Used by the CI release gate so we block on
+// definitively-malicious patterns but tolerate fundamental warns like
+// the worker's "readFileSync + fetch in same file" — irreducible without
+// splitting the worker into multiple shipped files. Local dev still
+// runs with the default strict mode (exits on any finding) so we
+// surface every drift before it ships.
+const rawArgs = process.argv.slice(2);
+const STRICT_MODE = !rawArgs.includes("--criticals-only");
+const SCAN_DIR = rawArgs.find(a => !a.startsWith("--")) ?? "openclaw/dist";
+const SCANNABLE_EXT = new Set([".js", ".mjs", ".cjs"]);
+const MAX_FILE_BYTES = 1024 * 1024; // 1MB; matches upstream default
+
+// ---- LINE_RULES (per-line; both pattern AND requiresContext must match) ----
+const LINE_RULES = [
+  {
+    ruleId: "dangerous-exec",
+    severity: "critical",
+    message: "Shell command execution detected (child_process)",
+    pattern: /\b(exec|execSync|spawn|spawnSync|execFile|execFileSync)\s*\(/,
+    requiresContext: /child_process/,
+  },
+  {
+    ruleId: "dynamic-code-execution",
+    severity: "critical",
+    message: "Dynamic code execution detected",
+    pattern: /\beval\s*\(|new\s+Function\s*\(/,
+  },
+  {
+    ruleId: "crypto-mining",
+    severity: "critical",
+    message: "Possible crypto-mining reference detected",
+    pattern: /stratum\+tcp|stratum\+ssl|coinhive|cryptonight|xmrig/i,
+  },
+  {
+    ruleId: "suspicious-network",
+    severity: "warn",
+    message: "WebSocket connection to non-standard port",
+    pattern: /new\s+WebSocket\s*\(\s*["']wss?:\/\/[^"']*:(\d+)/,
+    portCheck: true,
+  },
+];
+
+const STANDARD_PORTS = new Set([80, 443, 8080, 8443, 3000]);
+const NETWORK_SEND = /\bfetch\s*\(|\bpost\s*\(|\.\s*post\s*\(|http\.request\s*\(/i;
+
+// ---- SOURCE_RULES (whole file; both pattern AND requiresContext must match) ----
+const SOURCE_RULES = [
+  {
+    ruleId: "potential-exfiltration",
+    severity: "warn",
+    message: "File read combined with network send (possible exfiltration)",
+    pattern: /readFileSync|readFile/,
+    requiresContext: NETWORK_SEND,
+  },
+  {
+    ruleId: "obfuscated-code-hex",
+    severity: "warn",
+    message: "Hex-encoded string sequence detected (possible obfuscation)",
+    pattern: /(\\x[0-9a-fA-F]{2}){6,}/,
+  },
+  {
+    ruleId: "obfuscated-code-base64",
+    severity: "warn",
+    message: "Large base64 payload with decode call detected (possible obfuscation)",
+    pattern: /(?:atob|Buffer\.from)\s*\(\s*["'][A-Za-z0-9+/=]{200,}["']/,
+  },
+  {
+    ruleId: "env-harvesting",
+    severity: "critical",
+    message: "Environment variable access combined with network send (possible credential harvesting)",
+    pattern: /process\.env/,
+    requiresContext: NETWORK_SEND,
+  },
+];
+
+function truncate(s, n = 120) { return s.length <= n ? s : s.slice(0, n) + "…"; }
+
+function scanFile(path) {
+  const stat = statSync(path);
+  if (stat.size > MAX_FILE_BYTES) {
+    return [{ ruleId: "file-too-large", severity: "info", file: path, line: 0, message: `Skipped (${stat.size} bytes > ${MAX_FILE_BYTES} byte limit)`, evidence: "" }];
+  }
+  const source = readFileSync(path, "utf-8");
+  const lines = source.split("\n");
+  const findings = [];
+
+  for (const rule of LINE_RULES) {
+    if (rule.requiresContext && !rule.requiresContext.test(source)) continue;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const m = rule.pattern.exec(line);
+      if (!m) continue;
+      if (rule.portCheck) {
+        const port = Number.parseInt(m[1], 10);
+        if (STANDARD_PORTS.has(port)) continue;
+      }
+      findings.push({ ruleId: rule.ruleId, severity: rule.severity, file: path, line: i + 1, message: rule.message, evidence: truncate(line.trim()) });
+      break; // one finding per line-rule per file
+    }
+  }
+
+  for (const rule of SOURCE_RULES) {
+    if (!rule.pattern.test(source)) continue;
+    if (rule.requiresContext && !rule.requiresContext.test(source)) continue;
+    let matchLine = 0, matchEvidence = "";
+    for (let i = 0; i < lines.length; i++) {
+      if (rule.pattern.test(lines[i])) { matchLine = i + 1; matchEvidence = lines[i].trim(); break; }
+    }
+    if (matchLine === 0) { matchLine = 1; matchEvidence = source.slice(0, 120); }
+    findings.push({ ruleId: rule.ruleId, severity: rule.severity, file: path, line: matchLine, message: rule.message, evidence: truncate(matchEvidence) });
+  }
+
+  return findings;
+}
+
+async function* walk(dir) {
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const p = join(dir, entry.name);
+    if (entry.isDirectory()) yield* walk(p);
+    else if (entry.isFile() && SCANNABLE_EXT.has(extname(entry.name).toLowerCase())) yield p;
+  }
+}
+
+const SEVERITY_RANK = { info: 0, warn: 1, critical: 2 };
+const SEVERITY_ICON = { info: "·", warn: "!", critical: "✗" };
+
+const allFindings = [];
+let scannedFiles = 0;
+for await (const file of walk(SCAN_DIR)) {
+  scannedFiles++;
+  for (const f of scanFile(file)) allFindings.push(f);
+}
+
+const counts = { info: 0, warn: 0, critical: 0 };
+for (const f of allFindings) counts[f.severity] = (counts[f.severity] ?? 0) + 1;
+
+console.log(`\nScanned ${scannedFiles} file(s) under ${SCAN_DIR}/\n`);
+
+if (allFindings.length === 0) {
+  console.log("✓ No findings. Bundle is clean against ClawHub's static-analysis rules.\n");
+  process.exit(0);
+}
+
+allFindings.sort((a, b) => (SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]) || a.file.localeCompare(b.file) || a.line - b.line);
+for (const f of allFindings) {
+  console.log(`${SEVERITY_ICON[f.severity]} [${f.severity.toUpperCase()}] ${f.ruleId}`);
+  console.log(`    ${f.file}:${f.line}`);
+  console.log(`    ${f.message}`);
+  if (f.evidence) console.log(`    > ${f.evidence}`);
+  console.log();
+}
+
+const summary = `${counts.critical} critical, ${counts.warn} warn, ${counts.info} info`;
+console.log(`Summary: ${summary}\n`);
+if (!STRICT_MODE && counts.critical === 0 && counts.warn > 0) {
+  console.log(`(--criticals-only: warns are advisory and do NOT block. Re-run without the flag for strict local checks.)\n`);
+}
+const shouldFail = STRICT_MODE
+  ? (counts.critical > 0 || counts.warn > 0)
+  : counts.critical > 0;
+process.exit(shouldFail ? 1 : 0);

package/scripts/ensure-tree-sitter.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// Ensures the native tree-sitter bindings are loadable on this platform / Node ABI.
+//
+// Why this exists: tree-sitter@0.21.x ships no linux-arm64 prebuild, and
+// tree-sitter-typescript@0.23.x ships a mislabeled (x86-64) one. On linux-arm64
+// both must be compiled from source, and under Node >=22 that compile requires C++20
+// (tree-sitter@0.21's binding.gyp does not request it). tree-sitter is declared as an
+// optionalDependency so this expected arm64 build failure does not abort `npm install`;
+// this script then heals it afterwards.
+//
+// On platforms where the shipped prebuilds work (x64 / darwin / CI) this is a fast
+// no-op and never touches anything. It is intentionally non-fatal: if no toolchain is
+// available it warns and exits 0 rather than breaking the install.
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const ROOT = process.cwd();
+const require = createRequire(`${ROOT}/`);
+const PKGS = ['tree-sitter', 'tree-sitter-typescript'];
+
+function bindingsLoad() {
+  try {
+    const Parser = require('tree-sitter');
+    const TS = require('tree-sitter-typescript').typescript;
+    const parser = new Parser();
+    parser.setLanguage(TS);
+    parser.parse('const x = 1;');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (process.env.ENSURE_TS_RUNNING) process.exit(0); // recursion guard for the nested npm calls below
+if (bindingsLoad()) process.exit(0); // healthy prebuild / prior build → nothing to do
+
+console.error('[ensure-tree-sitter] native bindings not loadable on this platform — building from source...');
+
+const pkg = JSON.parse(readFileSync(`${ROOT}/package.json`, 'utf8'));
+const declared = { ...pkg.dependencies, ...pkg.optionalDependencies };
+
+const env = { ...process.env, ENSURE_TS_RUNNING: '1' };
+if (process.platform !== 'win32') {
+  // Node >=22 V8 headers require C++20; tree-sitter@0.21's binding.gyp doesn't request it.
+  env.CXXFLAGS = `${process.env.CXXFLAGS ?? ''} -std=c++20`.trim();
+}
+const run = (cmd) => execSync(cmd, { stdio: 'inherit', env, cwd: ROOT });
+
+try {
+  // 1. Re-fetch any package npm dropped — an optional dependency whose build failed is
+  //    removed from node_modules. --ignore-scripts: fetch only, so the compile below is
+  //    the single source of truth and the project build isn't triggered prematurely.
+  const missing = PKGS.filter((n) => !existsSync(`${ROOT}/node_modules/${n}/package.json`));
+  if (missing.length) {
+    const specs = missing.map((n) => `${n}@${declared[n] ?? 'latest'}`);
+    run(`npm install ${specs.join(' ')} --no-save --ignore-scripts`);
+  }
+
+  // 2. Force a from-source compile. These packages install via node-gyp-build, which uses
+  //    a local prebuild when present and otherwise compiles from source — no network. By
+  //    removing the (absent or wrong-arch) prebuilds plus any stale build, the rebuild is
+  //    guaranteed to compile locally, and node-gyp-build loads build/Release ahead of
+  //    prebuilds, so the correct binary always wins.
+  for (const n of PKGS) {
+    rmSync(`${ROOT}/node_modules/${n}/prebuilds`, { recursive: true, force: true });
+    rmSync(`${ROOT}/node_modules/${n}/build`, { recursive: true, force: true });
+  }
+  run(`npm rebuild ${PKGS.join(' ')}`);
+} catch (err) {
+  console.error('[ensure-tree-sitter] rebuild command failed:', err.message);
+}
+
+if (bindingsLoad()) {
+  console.error('[ensure-tree-sitter] OK — bindings compiled from source and loadable.');
+  process.exit(0);
+}
+
+// Strict mode: turn the warning into a hard failure. Opt-in via
+// HIVEMIND_STRICT_POSTINSTALL=1 — set by this repo's own CI workflows so a
+// heal failure surfaces as a red check on the PR instead of getting swallowed
+// and re-emerging downstream as `tsc: Cannot find module 'tree-sitter'`.
+// Default stays non-fatal so end-user consumers of @deeplake/hivemind never
+// get a hard install break — the runtime check at use-time is enough for them.
+const strict = process.env.HIVEMIND_STRICT_POSTINSTALL === '1';
+console.error(
+  '[ensure-tree-sitter] WARNING: tree-sitter bindings still unavailable. ' +
+    'Install a C/C++ toolchain and re-run `npm run rebuild:native`.' +
+    (strict ? ' (strict mode — failing this install)' : ' (non-fatal)'),
+);
+process.exit(strict ? 1 : 0);

package/scripts/pack-check.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Refuse a publish if `npm pack` would include filenames that should
+// never ship to npm — credentials, CI workflows, git internals.
+// Catches a future PR widening package.json's `files` array (or
+// switching to a permissive .npmignore) before any token is touched.
+
+import { execFileSync } from 'node:child_process';
+
+const FORBIDDEN = [
+  /(^|\/)\.npmrc$/,
+  /(^|\/)\.env($|\.)/,
+  /(^|\/)secrets?(\/|$)/,
+  /(^|\/)\.github(\/|$)/,
+  /(^|\/)\.git(\/|$)/,
+];
+
+const raw = execFileSync('npm', ['pack', '--dry-run', '--json'], {
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'inherit'],
+});
+const entries = JSON.parse(raw)[0].files.map((f) => f.path);
+const hits = entries.filter((p) => FORBIDDEN.some((rx) => rx.test(p)));
+
+if (hits.length) {
+  console.error('Refusing to publish — forbidden filenames in tarball:');
+  for (const h of hits) console.error('  ' + h);
+  process.exit(1);
+}
+console.log(`pack-check OK — ${entries.length} files, no forbidden patterns`);

package/scripts/sync-versions.d.mts

@@ -0,0 +1,15 @@
+export declare const SCALAR_TARGETS: readonly string[];
+export declare const MARKETPLACE_PATH: string;
+
+export interface SyncResult {
+  writes: number;
+  skips: number;
+  version: string;
+}
+
+export interface SyncOptions {
+  root?: string;
+  log?: (msg: string) => void;
+}
+
+export declare function syncVersions(opts?: SyncOptions): SyncResult;

package/scripts/sync-versions.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+// Sync the version field across all manifests from the single source-of-truth
+// in package.json. Runs as a `prebuild` hook so esbuild's version-define
+// inlines the same value into bundles.
+//
+// Idempotent: skips writes when a target already matches.
+// Exits non-zero if any target file is missing or if package.json has no version.
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SOURCE = "package.json";
+
+// Scalar targets: each has a single top-level `version` field tracking package.json.
+export const SCALAR_TARGETS = [
+  ".claude-plugin/plugin.json",
+  "claude-code/.claude-plugin/plugin.json",
+  "openclaw/openclaw.plugin.json",
+  "openclaw/package.json",
+  "codex/package.json",
+];
+
+// Marketplace target: has BOTH metadata.version AND every plugins[].version.
+export const MARKETPLACE_PATH = ".claude-plugin/marketplace.json";
+
+function readJsonAt(root, relPath) {
+  const full = resolve(root, relPath);
+  if (!existsSync(full)) {
+    throw new Error(`sync-versions: missing target ${relPath}`);
+  }
+  return JSON.parse(readFileSync(full, "utf-8"));
+}
+
+function writeJsonAt(root, relPath, obj) {
+  writeFileSync(resolve(root, relPath), JSON.stringify(obj, null, 2) + "\n");
+}
+
+export function syncVersions({ root = process.cwd(), log = (m) => console.error(m) } = {}) {
+  const source = readJsonAt(root, SOURCE);
+  const version = source.version;
+  if (!version || typeof version !== "string") {
+    throw new Error(`sync-versions: ${SOURCE} has no string \`version\` field`);
+  }
+
+  let writes = 0;
+  let skips = 0;
+
+  for (const target of SCALAR_TARGETS) {
+    const data = readJsonAt(root, target);
+    if (data.version === version) {
+      log(`sync-versions: ${target} already at ${version}`);
+      skips++;
+      continue;
+    }
+    const old = data.version;
+    data.version = version;
+    writeJsonAt(root, target, data);
+    log(`sync-versions: ${target}: ${old} -> ${version}`);
+    writes++;
+  }
+
+  const marketplace = readJsonAt(root, MARKETPLACE_PATH);
+  let mpChanged = false;
+  if (marketplace.metadata?.version !== version) {
+    const old = marketplace.metadata?.version;
+    marketplace.metadata = marketplace.metadata || {};
+    marketplace.metadata.version = version;
+    log(`sync-versions: ${MARKETPLACE_PATH} metadata.version: ${old} -> ${version}`);
+    mpChanged = true;
+  }
+  if (Array.isArray(marketplace.plugins)) {
+    for (const plugin of marketplace.plugins) {
+      if (plugin.version !== version) {
+        const old = plugin.version;
+        plugin.version = version;
+        log(`sync-versions: ${MARKETPLACE_PATH} plugins[${plugin.name}].version: ${old} -> ${version}`);
+        mpChanged = true;
+      }
+    }
+  }
+  if (mpChanged) {
+    writeJsonAt(root, MARKETPLACE_PATH, marketplace);
+    writes++;
+  } else {
+    log(`sync-versions: ${MARKETPLACE_PATH} already at ${version}`);
+    skips++;
+  }
+
+  log(`sync-versions: ${writes} written, ${skips} unchanged`);
+  return { writes, skips, version };
+}
+
+// Script mode — only runs when invoked directly, not when imported by tests.
+const __entryUrl = process.argv[1] ? fileURLToPath(import.meta.url) === resolve(process.argv[1]) : false;
+if (__entryUrl) {
+  try {
+    syncVersions();
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}