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/check-no-monolithic-plugin-sdk-entry-imports.ts

@@ -0,0 +1,161 @@
+// Check No Monolithic Plugin Sdk Entry Imports script supports OpenClaw repository automation.
+import fs from "node:fs";
+import path from "node:path";
+import { discoverOpenClawPlugins } from "../src/plugins/discovery.js";
+import { collectFilesSync, isCodeFile, relativeToCwd } from "./check-file-utils.js";
+
+// Match exact monolithic-root specifier in any code path:
+// imports/exports, require/dynamic import, and test mocks (vi.mock/jest.mock).
+const ROOT_IMPORT_PATTERN = /["']openclaw\/plugin-sdk["']/;
+const LEGACY_COMPAT_IMPORT_PATTERN = /["']openclaw\/plugin-sdk\/compat["']/;
+const LEGACY_BROAD_SUBPATH_PATTERNS = [
+  {
+    pattern: /["']openclaw\/plugin-sdk\/channel-runtime["']/,
+    label: "openclaw/plugin-sdk/channel-runtime",
+  },
+  {
+    pattern: /["']openclaw\/plugin-sdk\/config-runtime["']/,
+    label: "openclaw/plugin-sdk/config-runtime",
+  },
+  {
+    pattern: /["']openclaw\/plugin-sdk\/infra-runtime["']/,
+    label: "openclaw/plugin-sdk/infra-runtime",
+  },
+] as const;
+
+function hasMonolithicRootImport(content: string): boolean {
+  return ROOT_IMPORT_PATTERN.test(content);
+}
+
+function hasLegacyCompatImport(content: string): boolean {
+  return LEGACY_COMPAT_IMPORT_PATTERN.test(content);
+}
+
+function findLegacyBroadSubpathImports(content: string): string[] {
+  return LEGACY_BROAD_SUBPATH_PATTERNS.filter(({ pattern }) => pattern.test(content)).map(
+    ({ label }) => label,
+  );
+}
+
+function collectPluginSourceFiles(rootDir: string): string[] {
+  const srcDir = path.join(rootDir, "src");
+  if (!fs.existsSync(srcDir)) {
+    return [];
+  }
+  return collectFilesSync(srcDir, {
+    includeFile: (filePath) => isCodeFile(filePath),
+    skipDirNames: new Set(["node_modules", "dist", ".git", "coverage"]),
+  });
+}
+
+function collectSharedExtensionSourceFiles(): string[] {
+  return collectPluginSourceFiles(path.join(process.cwd(), "extensions", "shared"));
+}
+
+function collectBundledExtensionSourceFiles(): string[] {
+  const extensionsDir = path.join(process.cwd(), "extensions");
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(extensionsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const files: string[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === "shared") {
+      continue;
+    }
+    for (const srcFile of collectPluginSourceFiles(path.join(extensionsDir, entry.name))) {
+      files.push(srcFile);
+    }
+  }
+  return files;
+}
+
+function main() {
+  const discovery = discoverOpenClawPlugins({});
+  const bundledCandidates = discovery.candidates.filter((c) => c.origin === "bundled");
+  const filesToCheck = new Set<string>();
+  for (const candidate of bundledCandidates) {
+    filesToCheck.add(candidate.source);
+    for (const srcFile of collectPluginSourceFiles(candidate.rootDir)) {
+      filesToCheck.add(srcFile);
+    }
+  }
+  for (const sharedFile of collectSharedExtensionSourceFiles()) {
+    filesToCheck.add(sharedFile);
+  }
+  for (const extensionFile of collectBundledExtensionSourceFiles()) {
+    filesToCheck.add(extensionFile);
+  }
+
+  const monolithicOffenders: string[] = [];
+  const legacyCompatOffenders: string[] = [];
+  const legacyBroadSubpathOffenders = new Map<string, string[]>();
+  for (const entryFile of filesToCheck) {
+    let content;
+    try {
+      content = fs.readFileSync(entryFile, "utf8");
+    } catch {
+      continue;
+    }
+    if (hasMonolithicRootImport(content)) {
+      monolithicOffenders.push(entryFile);
+    }
+    if (hasLegacyCompatImport(content)) {
+      legacyCompatOffenders.push(entryFile);
+    }
+    const legacyBroadSubpaths = findLegacyBroadSubpathImports(content);
+    if (legacyBroadSubpaths.length > 0) {
+      legacyBroadSubpathOffenders.set(entryFile, legacyBroadSubpaths);
+    }
+  }
+
+  if (
+    monolithicOffenders.length > 0 ||
+    legacyCompatOffenders.length > 0 ||
+    legacyBroadSubpathOffenders.size > 0
+  ) {
+    if (monolithicOffenders.length > 0) {
+      console.error("Bundled plugin source files must not import monolithic openclaw/plugin-sdk.");
+      for (const file of monolithicOffenders.toSorted()) {
+        console.error(`- ${relativeToCwd(file)}`);
+      }
+    }
+    if (legacyCompatOffenders.length > 0) {
+      console.error(
+        "Bundled plugin source files must not import legacy openclaw/plugin-sdk/compat.",
+      );
+      for (const file of legacyCompatOffenders.toSorted()) {
+        console.error(`- ${relativeToCwd(file)}`);
+      }
+    }
+    if (legacyBroadSubpathOffenders.size > 0) {
+      console.error(
+        "Bundled plugin source files must not import deprecated broad plugin-sdk subpaths.",
+      );
+      for (const [file, labels] of [...legacyBroadSubpathOffenders.entries()].toSorted(
+        ([left], [right]) => left.localeCompare(right),
+      )) {
+        console.error(`- ${relativeToCwd(file)} (${labels.join(", ")})`);
+      }
+    }
+    if (
+      monolithicOffenders.length > 0 ||
+      legacyCompatOffenders.length > 0 ||
+      legacyBroadSubpathOffenders.size > 0
+    ) {
+      console.error(
+        "Use focused openclaw/plugin-sdk/<domain> subpaths for bundled plugins; root, compat, and broad runtime barrels are legacy surfaces only.",
+      );
+    }
+    process.exit(1);
+  }
+
+  console.log(
+    `OK: bundled plugin source files use scoped plugin-sdk subpaths (${filesToCheck.size} checked).`,
+  );
+}
+
+main();