🎉 init: 小龙的工作空间

2026-06-06 10:40:48 +08:00
commit a188ee1426
3201 changed files with 231817 additions and 0 deletions
@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * Guard 2: Agent Runtime Core Guard
+ * Prevents proliferation beyond the 3 allowed agent runtimes.
+ * 
+ * → Architecture Freeze v2 (PR-1): docs/architecture-freeze-v2.md
+ * → Core: embedded-agent-runner, acp | Experimental: codex-supervisor
+ * 
+ * Allowed agent runtimes (entry points):
+ *   - embedded-agent (built into OpenClaw — Core §2)
+ *   - codex         (codex supervisor/app-server harness — Experimental §5)
+ *   - acp           (ACP agent — Core §2)
+ * 
+ * RUNTIME UTILITY FILES (e.g. auth-profiles.runtime.js) are NOT new runtimes.
+ * Only AGENT ENTRY POINT modules count as runtime cores.
+ * 
+ * FAIL: a 4th agent runtime entry point appears
+ */
+
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const OPENCLAW_HOME = process.env.OPENCLAW_HOME || "/opt/homebrew/lib/node_modules/openclaw";
+const DIST_DIR = join(OPENCLAW_HOME, "dist");
+
+// Known agent runtime core entry points
+const KNOWN_RUNTIME_ENTRIES = new Set([
+  "embedded-agent",       // Embedded agent runner
+  "codex-supervisor",     // Codex app-server harness
+  "acp",                  // ACP agent directory
+]);
+
+// Known runtime UTILITY files (not new runtimes)
+const RUNTIME_UTILITY_PREFIXES = [
+  "auth-profiles",
+  "models-config",
+  "model-catalog",
+  "agent-bundle-mcp",
+  "runtime-",
+  "runtime.",
+];
+
+function isRuntimeUtility(filename) {
+  const name = filename.replace(/\.js$/, "").replace(/\.d\.ts$/, "");
+  return RUNTIME_UTILITY_PREFIXES.some(p => name.startsWith(p) || name.includes(".runtime"));
+}
+
+function guardRuntimeCores() {
+  const issues = [];
+  const foundEntries = [];
+  const utilities = [];
+
+  if (!existsSync(DIST_DIR)) {
+    issues.push({ level: "ERROR", msg: `Dist dir not found: ${DIST_DIR}` });
+    return { pass: false, foundEntries, issues };
+  }
+
+  // 1. Check extensions for agent runtime plugins
+  const extensionsDir = join(DIST_DIR, "extensions");
+  if (existsSync(extensionsDir)) {
+    const extDirs = readdirSync(extensionsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory());
+
+    for (const extDir of extDirs) {
+      const pluginJsonPath = join(extensionsDir, extDir.name, "openclaw.plugin.json");
+      if (!existsSync(pluginJsonPath)) continue;
+
+      try {
+        const plugin = JSON.parse(readFileSync(pluginJsonPath, "utf8"));
+        const id = plugin.id || extDir.name;
+        
+        // Check if this plugin provides agent runtime capabilities
+        const contracts = plugin.contracts || {};
+        const tools = contracts.tools || [];
+        const hasRuntimeTools = tools.some(t => 
+          t.includes("codex_session") || 
+          t.includes("agent_") ||
+          t.includes("acp_")
+        );
+
+        if (hasRuntimeTools) {
+          foundEntries.push({ name: id, source: "plugin.json", type: "extension" });
+        }
+      } catch {}
+    }
+  }
+
+  // 2. Check for embedded-agent directory
+  const agentsDir = join(DIST_DIR, "agents");
+  if (existsSync(agentsDir)) {
+    const agentSubDirs = readdirSync(agentsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory() && d.name.includes("agent"));
+    for (const d of agentSubDirs) {
+      foundEntries.push({ name: d.name, source: `dist/agents/${d.name}`, type: "core" });
+    }
+  }
+
+  // 3. Check for ACP directory
+  const acpDir = join(DIST_DIR, "acp");
+  if (existsSync(acpDir)) {
+    foundEntries.push({ name: "acp", source: "dist/acp/", type: "core" });
+  }
+
+  // 4. Categorize: entries vs utilities
+  const agentRuntimeEntries = foundEntries.filter(e => {
+    const name = e.name;
+    return KNOWN_RUNTIME_ENTRIES.has(name) || 
+           name.includes("embedded-agent") || 
+           name.includes("codex") ||
+           name === "acp";
+  });
+
+  const unknownEntries = foundEntries.filter(e => !agentRuntimeEntries.includes(e));
+
+  console.log(`  Agent runtime entries found: ${agentRuntimeEntries.length}`);
+  console.log(`  Allowed maximum: 3 (embedded, codex, acp)`);
+  
+  for (const e of agentRuntimeEntries) {
+    const known = KNOWN_RUNTIME_ENTRIES.has(e.name) || 
+                  e.name.includes("embedded-agent") || 
+                  e.name.includes("codex") ||
+                  e.name === "acp";
+    const status = known ? "✓" : "?";
+    console.log(`    ${status} ${e.name} (${e.source}, type=${e.type})`);
+  }
+
+  // Check for unknown entries
+  for (const e of unknownEntries) {
+    if (isRuntimeUtility(e.name)) {
+      utilities.push(e);
+      console.log(`    ○ ${e.name} (utility — not a runtime core)`);
+    } else {
+      issues.push({
+        level: "FAIL",
+        msg: `UNEXPECTED agent runtime entry: ${e.name} (${e.source})`
+      });
+    }
+  }
+
+  // Count distinct runtime types
+  const distinctEntries = new Set(
+    agentRuntimeEntries.map(e => {
+      if (e.name.includes("embedded-agent")) return "embedded";
+      if (e.name.includes("codex")) return "codex";
+      if (e.name === "acp") return "acp";
+      return e.name;
+    })
+  );
+
+  if (distinctEntries.size > 3) {
+    issues.push({
+      level: "FAIL",
+      msg: `Runtime entry count ${distinctEntries.size} > allowed maximum 3`
+    });
+  }
+
+  const pass = issues.filter(i => i.level === "FAIL").length === 0;
+  
+  if (utilities.length > 0) {
+    console.log(`  Runtime utility files: ${utilities.length} (not runtime cores)`);
+  }
+
+  return { pass, foundEntries: agentRuntimeEntries, issues, utilities };
+}
+
+// Run
+const result = guardRuntimeCores();
+
+console.log("");
+console.log("═══════════════════════════════════════");
+console.log("  Guard 2: Agent Runtime Core Guard");
+console.log("═══════════════════════════════════════");
+console.log("");
+
+for (const issue of result.issues) {
+  console.log(`  [${issue.level}] ${issue.msg}`);
+}
+
+if (result.pass) {
+  console.log("");
+  console.log("  ✓ PASS: no unexpected agent runtime core detected");
+  console.log(`  Allowed limit: 3 (embedded, codex, acp)`);
+  console.log(`  Found: ${result.foundEntries.length} runtime entries`);
+  process.exit(0);
+} else {
+  console.log("");
+  console.log("  ✗ FAIL: unexpected runtime core(s) detected");
+  process.exit(1);
+}