@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/discovery-Cgp95o2R.js

@@ -0,0 +1,649 @@
+import { s as normalizeOptionalString, i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+import { m as resolveUserPath, f as resolveConfigDir } from "./utils-DGFSjtQF.js";
+import { i as openBoundaryFileSync, n as matchBoundaryFileOpenFailure } from "./boundary-file-read-BymsBHso.js";
+import { a as resolvePackageExtensionEntries, r as getPackageManifestMetadata, t as DEFAULT_PLUGIN_ENTRY_CANDIDATES, i as loadPluginManifest } from "./manifest-CjPIwluH.js";
+import { r as safeRealpathSync, c as detectBundleManifestFormat, l as loadBundleManifest, t as formatPosixMode, n as isPathInside, i as safeStatSync } from "./path-safety-CKqzLERR.js";
+import { t as resolveBundledPluginsDir } from "./bundled-dir-Cq5y_NKM.js";
+import fs from "node:fs";
+import path from "node:path";
+function resolvePluginSourceRoots(params) {
+  const env = params.env ?? process.env;
+  const workspaceRoot = params.workspaceDir ? resolveUserPath(params.workspaceDir, env) : void 0;
+  return {
+    stock: resolveBundledPluginsDir(env),
+    global: path.join(resolveConfigDir(env), "extensions"),
+    workspace: workspaceRoot ? path.join(workspaceRoot, ".openclaw", "extensions") : void 0
+  };
+}
+function resolvePluginCacheInputs(params) {
+  const env = params.env ?? process.env;
+  return {
+    roots: resolvePluginSourceRoots({
+      workspaceDir: params.workspaceDir,
+      env
+    }),
+    loadPaths: (params.loadPaths ?? []).filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean).map((entry) => resolveUserPath(entry, env))
+  };
+}
+const EXTENSION_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".js",
+  ".mts",
+  ".cts",
+  ".mjs",
+  ".cjs"
+]);
+const SCANNED_DIRECTORY_IGNORE_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".turbo",
+  ".yarn",
+  ".yarn-cache",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+const discoveryCache = /* @__PURE__ */ new Map();
+const DEFAULT_DISCOVERY_CACHE_MS = 1e3;
+function resolveDiscoveryCacheMs(env) {
+  const raw = env.OPENCLAW_PLUGIN_DISCOVERY_CACHE_MS?.trim();
+  if (raw === "" || raw === "0") return 0;
+  if (!raw) return DEFAULT_DISCOVERY_CACHE_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed)) return DEFAULT_DISCOVERY_CACHE_MS;
+  return Math.max(0, parsed);
+}
+function shouldUseDiscoveryCache(env) {
+  if (env.OPENCLAW_DISABLE_PLUGIN_DISCOVERY_CACHE?.trim()) return false;
+  return resolveDiscoveryCacheMs(env) > 0;
+}
+function buildDiscoveryCacheKey(params) {
+  const { roots, loadPaths } = resolvePluginCacheInputs({
+    workspaceDir: params.workspaceDir,
+    loadPaths: params.extraPaths,
+    env: params.env
+  });
+  const workspaceKey = roots.workspace ?? "";
+  const configExtensionsRoot = roots.global ?? "";
+  const bundledRoot = roots.stock ?? "";
+  return `${workspaceKey}::${params.ownershipUid ?? currentUid() ?? "none"}::${configExtensionsRoot}::${bundledRoot}::${JSON.stringify(loadPaths)}`;
+}
+function currentUid(overrideUid) {
+  if (overrideUid !== void 0) return overrideUid;
+  if (process.platform === "win32") return null;
+  if (typeof process.getuid !== "function") return null;
+  return process.getuid();
+}
+function checkSourceEscapesRoot(params) {
+  const sourceRealPath = safeRealpathSync(params.source);
+  const rootRealPath = safeRealpathSync(params.rootDir);
+  if (!sourceRealPath || !rootRealPath) return null;
+  if (isPathInside(rootRealPath, sourceRealPath)) return null;
+  return {
+    reason: "source_escapes_root",
+    sourcePath: params.source,
+    rootPath: params.rootDir,
+    targetPath: params.source,
+    sourceRealPath,
+    rootRealPath
+  };
+}
+function checkPathStatAndPermissions(params) {
+  if (process.platform === "win32") return null;
+  const pathsToCheck = [params.rootDir, params.source];
+  const seen = /* @__PURE__ */ new Set();
+  for (const targetPath of pathsToCheck) {
+    const normalized = path.resolve(targetPath);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    let stat = safeStatSync(targetPath);
+    if (!stat) return {
+      reason: "path_stat_failed",
+      sourcePath: params.source,
+      rootPath: params.rootDir,
+      targetPath
+    };
+    let modeBits = stat.mode & 511;
+    if ((modeBits & 2) !== 0 && params.origin === "bundled") try {
+      fs.chmodSync(targetPath, modeBits & -19);
+      const repairedStat = safeStatSync(targetPath);
+      if (!repairedStat) return {
+        reason: "path_stat_failed",
+        sourcePath: params.source,
+        rootPath: params.rootDir,
+        targetPath
+      };
+      stat = repairedStat;
+      modeBits = repairedStat.mode & 511;
+    } catch {
+    }
+    if ((modeBits & 2) !== 0) return {
+      reason: "path_world_writable",
+      sourcePath: params.source,
+      rootPath: params.rootDir,
+      targetPath,
+      modeBits
+    };
+    if (params.origin !== "bundled" && params.uid !== null && typeof stat.uid === "number" && stat.uid !== params.uid && stat.uid !== 0) return {
+      reason: "path_suspicious_ownership",
+      sourcePath: params.source,
+      rootPath: params.rootDir,
+      targetPath,
+      foundUid: stat.uid,
+      expectedUid: params.uid
+    };
+  }
+  return null;
+}
+function findCandidateBlockIssue(params) {
+  const escaped = checkSourceEscapesRoot({
+    source: params.source,
+    rootDir: params.rootDir
+  });
+  if (escaped) return escaped;
+  return checkPathStatAndPermissions({
+    source: params.source,
+    rootDir: params.rootDir,
+    origin: params.origin,
+    uid: currentUid(params.ownershipUid)
+  });
+}
+function formatCandidateBlockMessage(issue) {
+  if (issue.reason === "source_escapes_root") return `blocked plugin candidate: source escapes plugin root (${issue.sourcePath} -> ${issue.sourceRealPath}; root=${issue.rootRealPath})`;
+  if (issue.reason === "path_stat_failed") return `blocked plugin candidate: cannot stat path (${issue.targetPath})`;
+  if (issue.reason === "path_world_writable") return `blocked plugin candidate: world-writable path (${issue.targetPath}, mode=${formatPosixMode(issue.modeBits ?? 0)})`;
+  return `blocked plugin candidate: suspicious ownership (${issue.targetPath}, uid=${issue.foundUid}, expected uid=${issue.expectedUid} or root)`;
+}
+function isUnsafePluginCandidate(params) {
+  const issue = findCandidateBlockIssue({
+    source: params.source,
+    rootDir: params.rootDir,
+    origin: params.origin,
+    ownershipUid: params.ownershipUid
+  });
+  if (!issue) return false;
+  params.diagnostics.push({
+    level: "warn",
+    source: issue.targetPath,
+    message: formatCandidateBlockMessage(issue)
+  });
+  return true;
+}
+function isExtensionFile(filePath) {
+  const ext = path.extname(filePath);
+  if (!EXTENSION_EXTS.has(ext)) return false;
+  if (filePath.endsWith(".d.ts")) return false;
+  const baseName = normalizeLowercaseStringOrEmpty(path.basename(filePath));
+  return !baseName.includes(".test.") && !baseName.includes(".live.test.") && !baseName.includes(".e2e.test.");
+}
+function shouldIgnoreScannedDirectory(dirName) {
+  const normalized = normalizeLowercaseStringOrEmpty(dirName);
+  if (!normalized) return true;
+  if (SCANNED_DIRECTORY_IGNORE_NAMES.has(normalized)) return true;
+  if (normalized.endsWith(".bak")) return true;
+  if (normalized.includes(".backup-")) return true;
+  if (normalized.includes(".disabled")) return true;
+  return false;
+}
+function resolvesToSameDirectory(left, right) {
+  if (!left || !right) return false;
+  const leftRealPath = safeRealpathSync(left);
+  const rightRealPath = safeRealpathSync(right);
+  if (leftRealPath && rightRealPath) return leftRealPath === rightRealPath;
+  return path.resolve(left) === path.resolve(right);
+}
+function readPackageManifest(dir, rejectHardlinks = true) {
+  const opened = openBoundaryFileSync({
+    absolutePath: path.join(dir, "package.json"),
+    rootPath: dir,
+    boundaryLabel: "plugin package directory",
+    rejectHardlinks
+  });
+  if (!opened.ok) return null;
+  try {
+    const raw = fs.readFileSync(opened.fd, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  } finally {
+    fs.closeSync(opened.fd);
+  }
+}
+function deriveIdHint(params) {
+  const base = path.basename(params.filePath, path.extname(params.filePath));
+  const rawManifestId = params.manifestId?.trim();
+  if (rawManifestId) return params.hasMultipleExtensions ? `${rawManifestId}/${base}` : rawManifestId;
+  const rawPackageName = params.packageName?.trim();
+  if (!rawPackageName) return base;
+  const unscoped = rawPackageName.includes("/") ? rawPackageName.split("/").pop() ?? rawPackageName : rawPackageName;
+  const normalizedPackageId = unscoped.endsWith("-provider") && unscoped.length > 9 ? unscoped.slice(0, -9) : unscoped;
+  if (!params.hasMultipleExtensions) return normalizedPackageId;
+  return `${normalizedPackageId}/${base}`;
+}
+function resolveIdHintManifestId(rootDir, rejectHardlinks) {
+  const manifest = loadPluginManifest(rootDir, rejectHardlinks);
+  return manifest.ok ? manifest.manifest.id : void 0;
+}
+function addCandidate(params) {
+  const resolved = path.resolve(params.source);
+  if (params.seen.has(resolved)) return;
+  const resolvedRoot = safeRealpathSync(params.rootDir) ?? path.resolve(params.rootDir);
+  if (isUnsafePluginCandidate({
+    source: resolved,
+    rootDir: resolvedRoot,
+    origin: params.origin,
+    diagnostics: params.diagnostics,
+    ownershipUid: params.ownershipUid
+  })) return;
+  params.seen.add(resolved);
+  const manifest = params.manifest ?? null;
+  params.candidates.push({
+    idHint: params.idHint,
+    source: resolved,
+    setupSource: params.setupSource,
+    rootDir: resolvedRoot,
+    origin: params.origin,
+    format: params.format ?? "openclaw",
+    bundleFormat: params.bundleFormat,
+    workspaceDir: params.workspaceDir,
+    packageName: normalizeOptionalString(manifest?.name),
+    packageVersion: normalizeOptionalString(manifest?.version),
+    packageDescription: normalizeOptionalString(manifest?.description),
+    packageDir: params.packageDir,
+    packageManifest: getPackageManifestMetadata(manifest ?? void 0),
+    bundledManifest: params.bundledManifest,
+    bundledManifestPath: params.bundledManifestPath
+  });
+}
+function discoverBundleInRoot(params) {
+  const bundleFormat = detectBundleManifestFormat(params.rootDir);
+  if (!bundleFormat) return "none";
+  const bundleManifest = loadBundleManifest({
+    rootDir: params.rootDir,
+    bundleFormat,
+    rejectHardlinks: params.origin !== "bundled"
+  });
+  if (!bundleManifest.ok) {
+    params.diagnostics.push({
+      level: "error",
+      message: bundleManifest.error,
+      source: bundleManifest.manifestPath
+    });
+    return "invalid";
+  }
+  addCandidate({
+    candidates: params.candidates,
+    diagnostics: params.diagnostics,
+    seen: params.seen,
+    idHint: bundleManifest.manifest.id,
+    source: params.rootDir,
+    rootDir: params.rootDir,
+    origin: params.origin,
+    format: "bundle",
+    bundleFormat,
+    ownershipUid: params.ownershipUid,
+    workspaceDir: params.workspaceDir
+  });
+  return "added";
+}
+function resolvePackageEntrySource(params) {
+  const source = path.resolve(params.packageDir, params.entryPath);
+  const rejectHardlinks = params.rejectHardlinks ?? true;
+  const candidates = [source];
+  const openCandidate = (absolutePath) => {
+    const opened = openBoundaryFileSync({
+      absolutePath,
+      rootPath: params.packageDir,
+      boundaryLabel: "plugin package directory",
+      rejectHardlinks
+    });
+    if (!opened.ok) return matchBoundaryFileOpenFailure(opened, {
+      path: () => null,
+      io: () => {
+        params.diagnostics.push({
+          level: "warn",
+          message: `extension entry unreadable (I/O error): ${params.entryPath}`,
+          source: params.sourceLabel
+        });
+        return null;
+      },
+      fallback: () => {
+        params.diagnostics.push({
+          level: "error",
+          message: `extension entry escapes package directory: ${params.entryPath}`,
+          source: params.sourceLabel
+        });
+        return null;
+      }
+    });
+    const safeSource = opened.path;
+    fs.closeSync(opened.fd);
+    return safeSource;
+  };
+  if (!rejectHardlinks) {
+    const builtCandidate = source.replace(/\.[^.]+$/u, ".js");
+    if (builtCandidate !== source) candidates.push(builtCandidate);
+  }
+  for (const candidate of new Set(candidates)) {
+    if (!fs.existsSync(candidate)) continue;
+    return openCandidate(candidate);
+  }
+  return openCandidate(source);
+}
+function discoverInDirectory(params) {
+  if (!fs.existsSync(params.dir)) return;
+  const resolvedDir = safeRealpathSync(params.dir) ?? path.resolve(params.dir);
+  if (params.recurseDirectories) {
+    if (params.visitedDirectories?.has(resolvedDir)) return;
+    params.visitedDirectories?.add(resolvedDir);
+  }
+  let entries = [];
+  try {
+    entries = fs.readdirSync(params.dir, { withFileTypes: true });
+  } catch (err) {
+    params.diagnostics.push({
+      level: "warn",
+      message: `failed to read extensions dir: ${params.dir} (${String(err)})`,
+      source: params.dir
+    });
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(params.dir, entry.name);
+    if (entry.isFile()) {
+      if (!isExtensionFile(fullPath)) continue;
+      addCandidate({
+        candidates: params.candidates,
+        diagnostics: params.diagnostics,
+        seen: params.seen,
+        idHint: path.basename(entry.name, path.extname(entry.name)),
+        source: fullPath,
+        rootDir: path.dirname(fullPath),
+        origin: params.origin,
+        ownershipUid: params.ownershipUid,
+        workspaceDir: params.workspaceDir
+      });
+    }
+    if (!entry.isDirectory()) continue;
+    if (params.skipDirectories?.has(entry.name)) continue;
+    if (shouldIgnoreScannedDirectory(entry.name)) continue;
+    const rejectHardlinks = params.origin !== "bundled";
+    const manifest = readPackageManifest(fullPath, rejectHardlinks);
+    const extensionResolution = resolvePackageExtensionEntries(manifest ?? void 0);
+    const extensions = extensionResolution.status === "ok" ? extensionResolution.entries : [];
+    const manifestId = resolveIdHintManifestId(fullPath, rejectHardlinks);
+    const setupEntryPath = getPackageManifestMetadata(manifest ?? void 0)?.setupEntry;
+    const setupSource = typeof setupEntryPath === "string" && setupEntryPath.trim().length > 0 ? resolvePackageEntrySource({
+      packageDir: fullPath,
+      entryPath: setupEntryPath,
+      sourceLabel: fullPath,
+      diagnostics: params.diagnostics,
+      rejectHardlinks
+    }) : null;
+    if (extensions.length > 0) {
+      for (const extPath of extensions) {
+        const resolved = resolvePackageEntrySource({
+          packageDir: fullPath,
+          entryPath: extPath,
+          sourceLabel: fullPath,
+          diagnostics: params.diagnostics,
+          rejectHardlinks
+        });
+        if (!resolved) continue;
+        addCandidate({
+          candidates: params.candidates,
+          diagnostics: params.diagnostics,
+          seen: params.seen,
+          idHint: deriveIdHint({
+            filePath: resolved,
+            manifestId,
+            packageName: manifest?.name,
+            hasMultipleExtensions: extensions.length > 1
+          }),
+          source: resolved,
+          ...setupSource ? { setupSource } : {},
+          rootDir: fullPath,
+          origin: params.origin,
+          ownershipUid: params.ownershipUid,
+          workspaceDir: params.workspaceDir,
+          manifest,
+          packageDir: fullPath
+        });
+      }
+      continue;
+    }
+    if (discoverBundleInRoot({
+      rootDir: fullPath,
+      origin: params.origin,
+      ownershipUid: params.ownershipUid,
+      workspaceDir: params.workspaceDir,
+      candidates: params.candidates,
+      diagnostics: params.diagnostics,
+      seen: params.seen
+    }) === "added") continue;
+    const indexFile = [...DEFAULT_PLUGIN_ENTRY_CANDIDATES].map((candidate) => path.join(fullPath, candidate)).find((candidate) => fs.existsSync(candidate));
+    if (indexFile && isExtensionFile(indexFile)) {
+      addCandidate({
+        candidates: params.candidates,
+        diagnostics: params.diagnostics,
+        seen: params.seen,
+        idHint: entry.name,
+        source: indexFile,
+        ...setupSource ? { setupSource } : {},
+        rootDir: fullPath,
+        origin: params.origin,
+        ownershipUid: params.ownershipUid,
+        workspaceDir: params.workspaceDir,
+        manifest,
+        packageDir: fullPath
+      });
+      continue;
+    }
+    if (params.recurseDirectories) discoverInDirectory({
+      ...params,
+      dir: fullPath
+    });
+  }
+}
+function discoverFromPath(params) {
+  const resolved = resolveUserPath(params.rawPath, params.env);
+  if (!fs.existsSync(resolved)) {
+    params.diagnostics.push({
+      level: "error",
+      message: `plugin path not found: ${resolved}`,
+      source: resolved
+    });
+    return;
+  }
+  const stat = fs.statSync(resolved);
+  if (stat.isFile()) {
+    if (!isExtensionFile(resolved)) {
+      params.diagnostics.push({
+        level: "error",
+        message: `plugin path is not a supported file: ${resolved}`,
+        source: resolved
+      });
+      return;
+    }
+    addCandidate({
+      candidates: params.candidates,
+      diagnostics: params.diagnostics,
+      seen: params.seen,
+      idHint: path.basename(resolved, path.extname(resolved)),
+      source: resolved,
+      rootDir: path.dirname(resolved),
+      origin: params.origin,
+      ownershipUid: params.ownershipUid,
+      workspaceDir: params.workspaceDir
+    });
+    return;
+  }
+  if (stat.isDirectory()) {
+    const rejectHardlinks = params.origin !== "bundled";
+    const manifest = readPackageManifest(resolved, rejectHardlinks);
+    const extensionResolution = resolvePackageExtensionEntries(manifest ?? void 0);
+    const extensions = extensionResolution.status === "ok" ? extensionResolution.entries : [];
+    const manifestId = resolveIdHintManifestId(resolved, rejectHardlinks);
+    const setupEntryPath = getPackageManifestMetadata(manifest ?? void 0)?.setupEntry;
+    const setupSource = typeof setupEntryPath === "string" && setupEntryPath.trim().length > 0 ? resolvePackageEntrySource({
+      packageDir: resolved,
+      entryPath: setupEntryPath,
+      sourceLabel: resolved,
+      diagnostics: params.diagnostics,
+      rejectHardlinks
+    }) : null;
+    if (extensions.length > 0) {
+      for (const extPath of extensions) {
+        const source = resolvePackageEntrySource({
+          packageDir: resolved,
+          entryPath: extPath,
+          sourceLabel: resolved,
+          diagnostics: params.diagnostics,
+          rejectHardlinks
+        });
+        if (!source) continue;
+        addCandidate({
+          candidates: params.candidates,
+          diagnostics: params.diagnostics,
+          seen: params.seen,
+          idHint: deriveIdHint({
+            filePath: source,
+            manifestId,
+            packageName: manifest?.name,
+            hasMultipleExtensions: extensions.length > 1
+          }),
+          source,
+          ...setupSource ? { setupSource } : {},
+          rootDir: resolved,
+          origin: params.origin,
+          ownershipUid: params.ownershipUid,
+          workspaceDir: params.workspaceDir,
+          manifest,
+          packageDir: resolved
+        });
+      }
+      return;
+    }
+    if (discoverBundleInRoot({
+      rootDir: resolved,
+      origin: params.origin,
+      ownershipUid: params.ownershipUid,
+      workspaceDir: params.workspaceDir,
+      candidates: params.candidates,
+      diagnostics: params.diagnostics,
+      seen: params.seen
+    }) === "added") return;
+    const indexFile = [...DEFAULT_PLUGIN_ENTRY_CANDIDATES].map((candidate) => path.join(resolved, candidate)).find((candidate) => fs.existsSync(candidate));
+    if (indexFile && isExtensionFile(indexFile)) {
+      addCandidate({
+        candidates: params.candidates,
+        diagnostics: params.diagnostics,
+        seen: params.seen,
+        idHint: path.basename(resolved),
+        source: indexFile,
+        ...setupSource ? { setupSource } : {},
+        rootDir: resolved,
+        origin: params.origin,
+        ownershipUid: params.ownershipUid,
+        workspaceDir: params.workspaceDir,
+        manifest,
+        packageDir: resolved
+      });
+      return;
+    }
+    discoverInDirectory({
+      dir: resolved,
+      origin: params.origin,
+      ownershipUid: params.ownershipUid,
+      workspaceDir: params.workspaceDir,
+      candidates: params.candidates,
+      diagnostics: params.diagnostics,
+      seen: params.seen
+    });
+    return;
+  }
+}
+function discoverOpenClawPlugins(params) {
+  const env = params.env ?? process.env;
+  const cacheEnabled = params.cache !== false && shouldUseDiscoveryCache(env);
+  const cacheKey = buildDiscoveryCacheKey({
+    workspaceDir: params.workspaceDir,
+    extraPaths: params.extraPaths,
+    ownershipUid: params.ownershipUid,
+    env
+  });
+  if (cacheEnabled) {
+    const cached = discoveryCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) return cached.result;
+  }
+  const candidates = [];
+  const diagnostics = [];
+  const seen = /* @__PURE__ */ new Set();
+  const workspaceDir = normalizeOptionalString(params.workspaceDir);
+  const workspaceRoot = workspaceDir ? resolveUserPath(workspaceDir, env) : void 0;
+  const roots = resolvePluginSourceRoots({
+    workspaceDir: workspaceRoot,
+    env
+  });
+  const extra = params.extraPaths ?? [];
+  for (const extraPath of extra) {
+    if (typeof extraPath !== "string") continue;
+    const trimmed = extraPath.trim();
+    if (!trimmed) continue;
+    discoverFromPath({
+      rawPath: trimmed,
+      origin: "config",
+      ownershipUid: params.ownershipUid,
+      workspaceDir,
+      env,
+      candidates,
+      diagnostics,
+      seen
+    });
+  }
+  const workspaceMatchesBundledRoot = resolvesToSameDirectory(workspaceRoot, roots.stock);
+  if (roots.workspace && workspaceRoot && !workspaceMatchesBundledRoot) discoverInDirectory({
+    dir: roots.workspace,
+    origin: "workspace",
+    ownershipUid: params.ownershipUid,
+    workspaceDir: workspaceRoot,
+    candidates,
+    diagnostics,
+    seen
+  });
+  if (roots.stock) discoverInDirectory({
+    dir: roots.stock,
+    origin: "bundled",
+    ownershipUid: params.ownershipUid,
+    candidates,
+    diagnostics,
+    seen
+  });
+  discoverInDirectory({
+    dir: roots.global,
+    origin: "global",
+    ownershipUid: params.ownershipUid,
+    candidates,
+    diagnostics,
+    seen
+  });
+  const result = {
+    candidates,
+    diagnostics
+  };
+  if (cacheEnabled) {
+    const ttl = resolveDiscoveryCacheMs(env);
+    if (ttl > 0) discoveryCache.set(cacheKey, {
+      expiresAt: Date.now() + ttl,
+      result
+    });
+  }
+  return result;
+}
+export {
+  resolvePluginSourceRoots as i,
+  discoverOpenClawPlugins as n,
+  resolvePluginCacheInputs as r
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/dispatch-2DAqwFVE.js

@@ -0,0 +1,33 @@
+import "./redact-D4nea1HF.js";
+import { n as resolveGlobalSingleton } from "./global-singleton-DhGoboiG.js";
+import "./utils-DGFSjtQF.js";
+import "./logger-BMuqDP66.js";
+import "./theme-CVJvORNs.js";
+import "./bundled-Cuj8sKt6.js";
+import "./registry-DE4nHTjg.js";
+import "./ids-By7Nkc8R.js";
+import "./subsystem-BHv2zSx6.js";
+import "./paths-LCYGfrV7.js";
+import "./workspace-oVBetctb.js";
+import "node:fs";
+import "node:path";
+import "./message-channel-DXsjCySM.js";
+import { n as resolveGlobalDedupeCache } from "./dedupe-DM7iBj7C.js";
+import "./internal-hooks-D52pUqod.js";
+import "./io-DDkf_FUu.js";
+import "./zod-schema-Cpw1qu03.js";
+import "node:os";
+import "node:crypto";
+import "./session-write-lock-Dk7FbMr_.js";
+import "node:fs/promises";
+import "./facade-runtime-B04URCVZ.js";
+import "./conversation-binding-C3EIaK9Z.js";
+const DEFAULT_INBOUND_DEDUPE_TTL_MS = 20 * 6e4;
+const DEFAULT_INBOUND_DEDUPE_MAX = 5e3;
+const INBOUND_DEDUPE_CACHE_KEY = Symbol.for("openclaw.inboundDedupeCache");
+const INBOUND_DEDUPE_INFLIGHT_KEY = Symbol.for("openclaw.inboundDedupeInflight");
+resolveGlobalDedupeCache(INBOUND_DEDUPE_CACHE_KEY, {
+  ttlMs: DEFAULT_INBOUND_DEDUPE_TTL_MS,
+  maxSize: DEFAULT_INBOUND_DEDUPE_MAX
+});
+resolveGlobalSingleton(INBOUND_DEDUPE_INFLIGHT_KEY, () => /* @__PURE__ */ new Set());

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/errors-Dyla6m1G.js

@@ -0,0 +1,13 @@
+const ACP_ERROR_CODES = [
+  "ACP_BACKEND_MISSING",
+  "ACP_BACKEND_UNAVAILABLE",
+  "ACP_BACKEND_UNSUPPORTED_CONTROL",
+  "ACP_DISPATCH_DISABLED",
+  "ACP_INVALID_RUNTIME_OPTION",
+  "ACP_SESSION_INIT_FAILED",
+  "ACP_TURN_FAILED"
+];
+new Set(ACP_ERROR_CODES);
+export {
+  ACP_ERROR_CODES as t
+};