Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

scripts/e2e/lib/plugins/npm-registry-server.mjs

@@ -0,0 +1,120 @@
+// Fixture npm registry server for plugin E2E scenarios.
+import crypto from "node:crypto";
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+
+const [portFile, ...packageArgs] = process.argv.slice(2);
+
+if (!portFile || packageArgs.length === 0 || packageArgs.length % 3 !== 0) {
+  console.error(
+    "usage: npm-registry-server.mjs <port-file> <package-name> <version> <tarball-path> [...]",
+  );
+  process.exit(1);
+}
+
+const packages = new Map();
+for (let index = 0; index < packageArgs.length; index += 3) {
+  const packageName = packageArgs[index];
+  const version = packageArgs[index + 1];
+  const tarballPath = packageArgs[index + 2];
+  const archive = fs.readFileSync(tarballPath);
+  const existing = packages.get(packageName) ?? {
+    encodedPackageName: encodeURIComponent(packageName).replace("%40", "@"),
+    packageName,
+    latestVersion: version,
+    versions: new Map(),
+  };
+  existing.latestVersion = version;
+  existing.versions.set(version, {
+    archive,
+    dependencies: packageName === "@openclaw/demo-plugin-npm" ? { "is-number": "7.0.0" } : {},
+    integrity: `sha512-${crypto.createHash("sha512").update(archive).digest("base64")}`,
+    shasum: crypto.createHash("sha1").update(archive).digest("hex"),
+    tarballName: path.basename(tarballPath),
+    version,
+  });
+  packages.set(packageName, existing);
+}
+
+const metadataFor = (entry, baseUrl) => ({
+  name: entry.packageName,
+  "dist-tags": { latest: entry.latestVersion },
+  versions: Object.fromEntries(
+    [...entry.versions.entries()].map(([version, versionEntry]) => [
+      version,
+      {
+        dependencies: versionEntry.dependencies,
+        name: entry.packageName,
+        version,
+        dist: {
+          integrity: versionEntry.integrity,
+          shasum: versionEntry.shasum,
+          tarball: `${baseUrl}/${entry.encodedPackageName}/-/${versionEntry.tarballName}`,
+        },
+      },
+    ]),
+  ),
+});
+
+function decodePackagePath(pathname) {
+  try {
+    return decodeURIComponent(pathname.slice(1));
+  } catch {
+    return undefined;
+  }
+}
+
+function findPackageForPath(pathname) {
+  const packageName = decodePackagePath(pathname);
+  return packageName === undefined ? undefined : packages.get(packageName);
+}
+
+function findTarballForPath(pathname) {
+  for (const entry of packages.values()) {
+    const prefix = `/${entry.encodedPackageName}/-/`;
+    if (!pathname.toLowerCase().startsWith(prefix.toLowerCase())) {
+      continue;
+    }
+    for (const versionEntry of entry.versions.values()) {
+      if (pathname.endsWith(`/${versionEntry.tarballName}`)) {
+        return versionEntry;
+      }
+    }
+  }
+  return undefined;
+}
+
+const server = http.createServer((request, response) => {
+  const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  const baseUrl = `http://127.0.0.1:${server.address().port}`;
+  if (request.method !== "GET") {
+    response.writeHead(405, { "content-type": "text/plain" });
+    response.end("method not allowed");
+    return;
+  }
+
+  const packageEntry = findPackageForPath(url.pathname);
+  if (packageEntry) {
+    response.writeHead(200, { "content-type": "application/json" });
+    response.end(`${JSON.stringify(metadataFor(packageEntry, baseUrl))}\n`);
+    return;
+  }
+
+  const tarballEntry = findTarballForPath(url.pathname);
+  if (tarballEntry) {
+    response.writeHead(200, {
+      "content-type": "application/octet-stream",
+      "content-length": String(tarballEntry.archive.length),
+    });
+    response.end(tarballEntry.archive);
+    return;
+  }
+
+  response.writeHead(404, { "content-type": "text/plain" });
+  response.end(`not found: ${url.pathname}`);
+});
+
+server.listen(0, "127.0.0.1", () => {
+  fs.writeFileSync(portFile, String(server.address().port));
+});