@workclaw/openclaw-workclaw 1.0.201 → 1.0.331

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/boundary-file-read-BymsBHso.js

@@ -0,0 +1,172 @@
+import { i as resolveBoundaryPathSync, t as sameFileIdentity$1 } from "./file-identity-sp9axE-E.js";
+import fs from "node:fs";
+import path from "node:path";
+function isExpectedPathError(error) {
+  const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+  return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
+}
+function sameFileIdentity(left, right) {
+  return sameFileIdentity$1(left, right);
+}
+function openVerifiedFileSync(params) {
+  const ioFs = params.ioFs ?? fs;
+  const allowedType = params.allowedType ?? "file";
+  const openReadFlags = ioFs.constants.O_RDONLY | (typeof ioFs.constants.O_NOFOLLOW === "number" ? ioFs.constants.O_NOFOLLOW : 0);
+  let fd = null;
+  try {
+    if (params.rejectPathSymlink) {
+      if (ioFs.lstatSync(params.filePath).isSymbolicLink()) return {
+        ok: false,
+        reason: "validation"
+      };
+    }
+    const realPath = params.resolvedPath ?? ioFs.realpathSync(params.filePath);
+    const preOpenStat = ioFs.lstatSync(realPath);
+    if (!isAllowedType(preOpenStat, allowedType)) return {
+      ok: false,
+      reason: "validation"
+    };
+    if (params.rejectHardlinks && preOpenStat.isFile() && preOpenStat.nlink > 1) return {
+      ok: false,
+      reason: "validation"
+    };
+    if (params.maxBytes !== void 0 && preOpenStat.isFile() && preOpenStat.size > params.maxBytes) return {
+      ok: false,
+      reason: "validation"
+    };
+    fd = ioFs.openSync(realPath, openReadFlags);
+    const openedStat = ioFs.fstatSync(fd);
+    if (!isAllowedType(openedStat, allowedType)) return {
+      ok: false,
+      reason: "validation"
+    };
+    if (params.rejectHardlinks && openedStat.isFile() && openedStat.nlink > 1) return {
+      ok: false,
+      reason: "validation"
+    };
+    if (params.maxBytes !== void 0 && openedStat.isFile() && openedStat.size > params.maxBytes) return {
+      ok: false,
+      reason: "validation"
+    };
+    if (!sameFileIdentity(preOpenStat, openedStat)) return {
+      ok: false,
+      reason: "validation"
+    };
+    const opened = {
+      ok: true,
+      path: realPath,
+      fd,
+      stat: openedStat
+    };
+    fd = null;
+    return opened;
+  } catch (error) {
+    if (isExpectedPathError(error)) return {
+      ok: false,
+      reason: "path",
+      error
+    };
+    return {
+      ok: false,
+      reason: "io",
+      error
+    };
+  } finally {
+    if (fd !== null) ioFs.closeSync(fd);
+  }
+}
+function isAllowedType(stat, allowedType) {
+  if (allowedType === "directory") return stat.isDirectory();
+  return stat.isFile();
+}
+function openBoundaryFileSync(params) {
+  const ioFs = params.ioFs ?? fs;
+  const resolved = resolveBoundaryFilePathGeneric({
+    absolutePath: params.absolutePath,
+    resolve: (absolutePath) => resolveBoundaryPathSync({
+      absolutePath,
+      rootPath: params.rootPath,
+      rootCanonicalPath: params.rootRealPath,
+      boundaryLabel: params.boundaryLabel,
+      skipLexicalRootCheck: params.skipLexicalRootCheck
+    })
+  });
+  if (resolved instanceof Promise) return toBoundaryValidationError(/* @__PURE__ */ new Error("Unexpected async boundary resolution"));
+  return finalizeBoundaryFileOpen({
+    resolved,
+    maxBytes: params.maxBytes,
+    rejectHardlinks: params.rejectHardlinks,
+    allowedType: params.allowedType,
+    ioFs
+  });
+}
+function matchBoundaryFileOpenFailure(failure, handlers) {
+  switch (failure.reason) {
+    case "path":
+      return handlers.path ? handlers.path(failure) : handlers.fallback(failure);
+    case "validation":
+      return handlers.validation ? handlers.validation(failure) : handlers.fallback(failure);
+    case "io":
+      return handlers.io ? handlers.io(failure) : handlers.fallback(failure);
+  }
+  return handlers.fallback(failure);
+}
+function openBoundaryFileResolved(params) {
+  const opened = openVerifiedFileSync({
+    filePath: params.absolutePath,
+    resolvedPath: params.resolvedPath,
+    rejectHardlinks: params.rejectHardlinks ?? true,
+    maxBytes: params.maxBytes,
+    allowedType: params.allowedType,
+    ioFs: params.ioFs
+  });
+  if (!opened.ok) return opened;
+  return {
+    ok: true,
+    path: opened.path,
+    fd: opened.fd,
+    stat: opened.stat,
+    rootRealPath: params.rootRealPath
+  };
+}
+function finalizeBoundaryFileOpen(params) {
+  if ("ok" in params.resolved) return params.resolved;
+  return openBoundaryFileResolved({
+    absolutePath: params.resolved.absolutePath,
+    resolvedPath: params.resolved.resolvedPath,
+    rootRealPath: params.resolved.rootRealPath,
+    maxBytes: params.maxBytes,
+    rejectHardlinks: params.rejectHardlinks,
+    allowedType: params.allowedType,
+    ioFs: params.ioFs
+  });
+}
+function toBoundaryValidationError(error) {
+  return {
+    ok: false,
+    reason: "validation",
+    error
+  };
+}
+function mapResolvedBoundaryPath(absolutePath, resolved) {
+  return {
+    absolutePath,
+    resolvedPath: resolved.canonicalPath,
+    rootRealPath: resolved.rootCanonicalPath
+  };
+}
+function resolveBoundaryFilePathGeneric(params) {
+  const absolutePath = path.resolve(params.absolutePath);
+  try {
+    const resolved = params.resolve(absolutePath);
+    if (resolved instanceof Promise) return resolved.then((value) => mapResolvedBoundaryPath(absolutePath, value)).catch((error) => toBoundaryValidationError(error));
+    return mapResolvedBoundaryPath(absolutePath, resolved);
+  } catch (error) {
+    return toBoundaryValidationError(error);
+  }
+}
+export {
+  openVerifiedFileSync as a,
+  openBoundaryFileSync as i,
+  matchBoundaryFileOpenFailure as n
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/bundled-Cuj8sKt6.js

@@ -0,0 +1,18 @@
+import "./redact-D4nea1HF.js";
+import { n as resolveOpenClawPackageRootSync } from "./openclaw-root-BNWw3cXT.js";
+import "./subsystem-BHv2zSx6.js";
+import "node:fs";
+import path from "node:path";
+import "node:os";
+import "node:fs/promises";
+import "./sdk-alias-Bo1huP7M.js";
+import "./bundled-plugin-metadata-BJMD48hn.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import "../node_modules/jiti/dist/jiti.js";
+createRequire(import.meta.url);
+resolveOpenClawPackageRootSync({
+  argv1: process.argv[1],
+  cwd: process.cwd(),
+  moduleUrl: import.meta.url.startsWith("file:") ? import.meta.url : void 0
+}) ?? (import.meta.url.startsWith("file:") ? path.resolve(fileURLToPath(new URL("../../..", import.meta.url))) : process.cwd());

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/bundled-dir-Cq5y_NKM.js

@@ -0,0 +1,109 @@
+import { o as normalizeOptionalLowercaseString } from "./string-coerce-BUSzWgUA.js";
+import { n as resolveOpenClawPackageRootSync } from "./openclaw-root-BNWw3cXT.js";
+import { m as resolveUserPath } from "./utils-DGFSjtQF.js";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const DISABLED_BUNDLED_PLUGINS_DIR = path.join(os.tmpdir(), "openclaw-empty-bundled-plugins");
+function bundledPluginsDisabled(env) {
+  const raw = normalizeOptionalLowercaseString(env.OPENCLAW_DISABLE_BUNDLED_PLUGINS);
+  return raw === "1" || raw === "true";
+}
+function resolveDisabledBundledPluginsDir() {
+  fs.mkdirSync(DISABLED_BUNDLED_PLUGINS_DIR, { recursive: true });
+  return DISABLED_BUNDLED_PLUGINS_DIR;
+}
+function isSourceCheckoutRoot(packageRoot) {
+  return fs.existsSync(path.join(packageRoot, ".git")) && fs.existsSync(path.join(packageRoot, "src")) && fs.existsSync(path.join(packageRoot, "extensions"));
+}
+function hasUsableBundledPluginTree(pluginsDir) {
+  if (!fs.existsSync(pluginsDir)) return false;
+  try {
+    return fs.readdirSync(pluginsDir, { withFileTypes: true }).some((entry) => {
+      if (!entry.isDirectory()) return false;
+      const pluginDir = path.join(pluginsDir, entry.name);
+      return fs.existsSync(path.join(pluginDir, "package.json")) || fs.existsSync(path.join(pluginDir, "openclaw.plugin.json"));
+    });
+  } catch {
+    return false;
+  }
+}
+function runningSourceTypeScriptProcess() {
+  const argv1 = process.argv[1]?.toLowerCase();
+  if (argv1?.endsWith(".ts") || argv1?.endsWith(".tsx") || argv1?.endsWith(".mts") || argv1?.endsWith(".cts")) return true;
+  for (let index = 0; index < process.execArgv.length; index += 1) {
+    const arg = process.execArgv[index]?.toLowerCase();
+    if (!arg) continue;
+    if (arg === "tsx" || arg.includes("tsx/register")) return true;
+    if ((arg === "--import" || arg === "--loader") && process.execArgv[index + 1]) {
+      const next = process.execArgv[index + 1].toLowerCase();
+      if (next === "tsx" || next.includes("tsx/")) return true;
+    }
+  }
+  return false;
+}
+function resolveBundledDirFromPackageRoot(packageRoot, preferSourceCheckout) {
+  const sourceExtensionsDir = path.join(packageRoot, "extensions");
+  const builtExtensionsDir = path.join(packageRoot, "dist", "extensions");
+  const sourceCheckout = isSourceCheckoutRoot(packageRoot);
+  if (preferSourceCheckout && fs.existsSync(sourceExtensionsDir)) return sourceExtensionsDir;
+  const runtimeExtensionsDir = path.join(packageRoot, "dist-runtime", "extensions");
+  const hasUsableRuntimeTree = sourceCheckout ? hasUsableBundledPluginTree(runtimeExtensionsDir) : fs.existsSync(runtimeExtensionsDir);
+  const hasUsableBuiltTree = sourceCheckout ? hasUsableBundledPluginTree(builtExtensionsDir) : fs.existsSync(builtExtensionsDir);
+  if (hasUsableRuntimeTree && hasUsableBuiltTree) return runtimeExtensionsDir;
+  if (hasUsableBuiltTree) return builtExtensionsDir;
+  if (sourceCheckout && fs.existsSync(sourceExtensionsDir)) return sourceExtensionsDir;
+}
+function resolveBundledPluginsDir(env = process.env) {
+  if (bundledPluginsDisabled(env)) return resolveDisabledBundledPluginsDir();
+  const override = env.OPENCLAW_BUNDLED_PLUGINS_DIR?.trim();
+  if (override) {
+    const resolvedOverride = resolveUserPath(override, env);
+    if (fs.existsSync(resolvedOverride)) return resolvedOverride;
+    try {
+      const argvPackageRoot = resolveOpenClawPackageRootSync({ argv1: process.argv[1] });
+      if (argvPackageRoot && !isSourceCheckoutRoot(argvPackageRoot)) {
+        const argvFallback = resolveBundledDirFromPackageRoot(argvPackageRoot, false);
+        if (argvFallback) return argvFallback;
+      }
+    } catch {
+    }
+    return resolvedOverride;
+  }
+  const preferSourceCheckout = Boolean(env.VITEST) || runningSourceTypeScriptProcess();
+  try {
+    const packageRoots = [
+      resolveOpenClawPackageRootSync({ argv1: process.argv[1] }),
+      resolveOpenClawPackageRootSync({ cwd: process.cwd() }),
+      resolveOpenClawPackageRootSync({ moduleUrl: import.meta.url })
+    ].filter((entry, index, all) => Boolean(entry) && all.indexOf(entry) === index);
+    for (const packageRoot of packageRoots) {
+      const bundledDir = resolveBundledDirFromPackageRoot(packageRoot, preferSourceCheckout);
+      if (bundledDir) return bundledDir;
+    }
+  } catch {
+  }
+  try {
+    const execDir = path.dirname(process.execPath);
+    const siblingBuilt = path.join(execDir, "dist", "extensions");
+    if (fs.existsSync(siblingBuilt)) return siblingBuilt;
+    const sibling = path.join(execDir, "extensions");
+    if (fs.existsSync(sibling)) return sibling;
+  } catch {
+  }
+  try {
+    let cursor = path.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i += 1) {
+      const candidate = path.join(cursor, "extensions");
+      if (fs.existsSync(candidate)) return candidate;
+      const parent = path.dirname(cursor);
+      if (parent === cursor) break;
+      cursor = parent;
+    }
+  } catch {
+  }
+}
+export {
+  resolveBundledPluginsDir as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/bundled-plugin-metadata-BJMD48hn.js

@@ -0,0 +1,260 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import { l as normalizeTrimmedStringList } from "./string-normalization-DIJRAo0o.js";
+import { i as loadPluginManifest, r as getPackageManifestMetadata } from "./manifest-CjPIwluH.js";
+import { l as resolveLoaderPackageRoot, u as resolvePluginLoaderJitiConfig, n as buildPluginLoaderJitiOptions } from "./sdk-alias-Bo1huP7M.js";
+import { r as buildChannelConfigSchema } from "./config-schema-DB8FqQH8.js";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import { createJiti } from "../node_modules/jiti/lib/jiti.js";
+const PUBLIC_SURFACE_SOURCE_EXTENSIONS$1 = [
+  ".ts",
+  ".mts",
+  ".js",
+  ".mjs",
+  ".cts",
+  ".cjs"
+];
+const RUNTIME_SIDECAR_ARTIFACTS = /* @__PURE__ */ new Set([
+  "helper-api.js",
+  "light-runtime-api.js",
+  "runtime-api.js",
+  "thread-bindings-runtime.js"
+]);
+function normalizeBundledPluginStringList(value) {
+  return normalizeTrimmedStringList(value);
+}
+function rewriteBundledPluginEntryToBuiltPath(entry) {
+  if (!entry) return;
+  return entry.replace(/^\.\//u, "").replace(/\.[^.]+$/u, ".js");
+}
+function isTopLevelPublicSurfaceSource(name) {
+  if (!PUBLIC_SURFACE_SOURCE_EXTENSIONS$1.includes(path.extname(name))) return false;
+  if (name.startsWith(".") || name.startsWith("test-") || name.includes(".test-")) return false;
+  if (name.endsWith(".d.ts")) return false;
+  if (/^config-api(\.[cm]?[jt]s)$/u.test(name)) return false;
+  return !/(\.test|\.spec)(\.[cm]?[jt]s)$/u.test(name);
+}
+function deriveBundledPluginIdHint(params) {
+  const base = path.basename(params.entryPath, path.extname(params.entryPath));
+  if (!params.hasMultipleExtensions) return params.manifestId;
+  const packageName = normalizeOptionalString(params.packageName);
+  if (!packageName) return `${params.manifestId}/${base}`;
+  return `${packageName.includes("/") ? packageName.split("/").pop() ?? packageName : packageName}/${base}`;
+}
+function collectBundledPluginPublicSurfaceArtifacts(params) {
+  const excluded = new Set(normalizeTrimmedStringList([params.sourceEntry, params.setupEntry]).map((entry) => path.basename(entry)));
+  const artifacts = fs.readdirSync(params.pluginDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter(isTopLevelPublicSurfaceSource).filter((entry) => !excluded.has(entry)).map((entry) => rewriteBundledPluginEntryToBuiltPath(entry)).filter((entry) => typeof entry === "string" && entry.length > 0).toSorted((left, right) => left.localeCompare(right));
+  return artifacts.length > 0 ? artifacts : void 0;
+}
+function collectBundledPluginRuntimeSidecarArtifacts(publicSurfaceArtifacts) {
+  if (!publicSurfaceArtifacts) return;
+  const artifacts = publicSurfaceArtifacts.filter((artifact) => RUNTIME_SIDECAR_ARTIFACTS.has(artifact));
+  return artifacts.length > 0 ? artifacts : void 0;
+}
+function resolveBundledPluginScanDir(params) {
+  const sourceDir = path.join(params.packageRoot, "extensions");
+  const runtimeDir = path.join(params.packageRoot, "dist-runtime", "extensions");
+  const builtDir = path.join(params.packageRoot, "dist", "extensions");
+  if (params.runningFromBuiltArtifact) {
+    if (fs.existsSync(builtDir)) return builtDir;
+    if (fs.existsSync(runtimeDir)) return runtimeDir;
+  }
+  if (fs.existsSync(sourceDir)) return sourceDir;
+  if (fs.existsSync(runtimeDir) && fs.existsSync(builtDir)) return runtimeDir;
+  if (fs.existsSync(builtDir)) return builtDir;
+}
+const PUBLIC_SURFACE_SOURCE_EXTENSIONS = [
+  ".ts",
+  ".mts",
+  ".js",
+  ".mjs",
+  ".cts",
+  ".cjs"
+];
+const SOURCE_CONFIG_SCHEMA_CANDIDATES = [
+  path.join("src", "config-schema.ts"),
+  path.join("src", "config-schema.js"),
+  path.join("src", "config-schema.mts"),
+  path.join("src", "config-schema.mjs"),
+  path.join("src", "config-schema.cts"),
+  path.join("src", "config-schema.cjs")
+];
+const PUBLIC_CONFIG_SURFACE_BASENAMES = [
+  "channel-config-api",
+  "runtime-api",
+  "api"
+];
+const jitiLoaders = /* @__PURE__ */ new Map();
+function isBuiltChannelConfigSchema(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return Boolean(candidate.schema && typeof candidate.schema === "object");
+}
+function resolveConfigSchemaExport(imported) {
+  for (const [name, value] of Object.entries(imported)) if (name.endsWith("ChannelConfigSchema") && isBuiltChannelConfigSchema(value)) return value;
+  for (const [name, value] of Object.entries(imported)) {
+    if (!name.endsWith("ConfigSchema") || name.endsWith("AccountConfigSchema")) continue;
+    if (isBuiltChannelConfigSchema(value)) return value;
+    if (value && typeof value === "object") return buildChannelConfigSchema(value);
+  }
+  for (const value of Object.values(imported)) if (isBuiltChannelConfigSchema(value)) return value;
+  return null;
+}
+function getJiti(modulePath) {
+  const { tryNative, aliasMap, cacheKey } = resolvePluginLoaderJitiConfig({
+    modulePath,
+    argv1: process.argv[1],
+    moduleUrl: import.meta.url,
+    preferBuiltDist: true
+  });
+  const cached = jitiLoaders.get(cacheKey);
+  if (cached) return cached;
+  const loader = createJiti(import.meta.url, {
+    ...buildPluginLoaderJitiOptions(aliasMap),
+    tryNative
+  });
+  jitiLoaders.set(cacheKey, loader);
+  return loader;
+}
+function resolveChannelConfigSchemaModulePath(pluginDir) {
+  for (const relativePath of SOURCE_CONFIG_SCHEMA_CANDIDATES) {
+    const candidate = path.join(pluginDir, relativePath);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const basename of PUBLIC_CONFIG_SURFACE_BASENAMES) for (const extension of PUBLIC_SURFACE_SOURCE_EXTENSIONS) {
+    const candidate = path.join(pluginDir, `${basename}${extension}`);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+}
+function loadChannelConfigSurfaceModuleSync(modulePath) {
+  try {
+    return resolveConfigSchemaExport(getJiti(modulePath)(modulePath));
+  } catch {
+    return null;
+  }
+}
+function resolvePackageChannelMeta(packageManifest, channelId) {
+  const channelMeta = packageManifest?.channel;
+  return channelMeta?.id?.trim() === channelId ? channelMeta : void 0;
+}
+function collectBundledChannelConfigs(params) {
+  const channelIds = normalizeBundledPluginStringList(params.manifest.channels);
+  const existingChannelConfigs = params.manifest.channelConfigs && Object.keys(params.manifest.channelConfigs).length > 0 ? { ...params.manifest.channelConfigs } : {};
+  if (channelIds.length === 0) return Object.keys(existingChannelConfigs).length > 0 ? existingChannelConfigs : void 0;
+  const surfaceModulePath = resolveChannelConfigSchemaModulePath(params.pluginDir);
+  const surface = surfaceModulePath ? loadChannelConfigSurfaceModuleSync(surfaceModulePath) : null;
+  for (const channelId of channelIds) {
+    const existing = existingChannelConfigs[channelId];
+    const channelMeta = resolvePackageChannelMeta(params.packageManifest, channelId);
+    const preferOver = normalizeBundledPluginStringList(channelMeta?.preferOver);
+    const uiHints = surface?.uiHints || existing?.uiHints ? {
+      ...surface?.uiHints && Object.keys(surface.uiHints).length > 0 ? surface.uiHints : {},
+      ...existing?.uiHints && Object.keys(existing.uiHints).length > 0 ? existing.uiHints : {}
+    } : void 0;
+    if (!surface?.schema && !existing?.schema) continue;
+    existingChannelConfigs[channelId] = {
+      schema: surface?.schema ?? existing?.schema ?? {},
+      ...uiHints && Object.keys(uiHints).length > 0 ? { uiHints } : {},
+      ...surface?.runtime ?? existing?.runtime ? { runtime: surface?.runtime ?? existing?.runtime } : {},
+      ...normalizeOptionalString(existing?.label) ?? normalizeOptionalString(channelMeta?.label) ? { label: normalizeOptionalString(existing?.label) ?? normalizeOptionalString(channelMeta?.label) } : {},
+      ...normalizeOptionalString(existing?.description) ?? normalizeOptionalString(channelMeta?.blurb) ? { description: normalizeOptionalString(existing?.description) ?? normalizeOptionalString(channelMeta?.blurb) } : {},
+      ...existing?.preferOver?.length ? { preferOver: existing.preferOver } : preferOver.length > 0 ? { preferOver } : {}
+    };
+  }
+  return Object.keys(existingChannelConfigs).length > 0 ? existingChannelConfigs : void 0;
+}
+const OPENCLAW_PACKAGE_ROOT = resolveLoaderPackageRoot({
+  modulePath: fileURLToPath(import.meta.url),
+  moduleUrl: import.meta.url
+}) ?? fileURLToPath(new URL("../..", import.meta.url));
+const CURRENT_MODULE_PATH = fileURLToPath(import.meta.url);
+const RUNNING_FROM_BUILT_ARTIFACT = CURRENT_MODULE_PATH.includes(`${path.sep}dist${path.sep}`) || CURRENT_MODULE_PATH.includes(`${path.sep}dist-runtime${path.sep}`);
+const bundledPluginMetadataCache = /* @__PURE__ */ new Map();
+function readPackageManifest(pluginDir) {
+  const packagePath = path.join(pluginDir, "package.json");
+  if (!fs.existsSync(packagePath)) return;
+  try {
+    return JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  } catch {
+    return;
+  }
+}
+function collectBundledPluginMetadataForPackageRoot(packageRoot, includeChannelConfigs, includeSyntheticChannelConfigs) {
+  const scanDir = resolveBundledPluginScanDir({
+    packageRoot,
+    runningFromBuiltArtifact: RUNNING_FROM_BUILT_ARTIFACT
+  });
+  if (!scanDir || !fs.existsSync(scanDir)) return [];
+  const entries = [];
+  for (const dirName of fs.readdirSync(scanDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted((left, right) => left.localeCompare(right))) {
+    const pluginDir = path.join(scanDir, dirName);
+    const manifestResult = loadPluginManifest(pluginDir, false);
+    if (!manifestResult.ok) continue;
+    const packageJson = readPackageManifest(pluginDir);
+    const packageManifest = getPackageManifestMetadata(packageJson);
+    const extensions = normalizeBundledPluginStringList(packageManifest?.extensions);
+    if (extensions.length === 0) continue;
+    const sourceEntry = normalizeOptionalString(extensions[0]);
+    const builtEntry = rewriteBundledPluginEntryToBuiltPath(sourceEntry);
+    if (!sourceEntry || !builtEntry) continue;
+    const setupSourcePath = normalizeOptionalString(packageManifest?.setupEntry);
+    const setupSource = setupSourcePath && rewriteBundledPluginEntryToBuiltPath(setupSourcePath) ? {
+      source: setupSourcePath,
+      built: rewriteBundledPluginEntryToBuiltPath(setupSourcePath)
+    } : void 0;
+    const publicSurfaceArtifacts = collectBundledPluginPublicSurfaceArtifacts({
+      pluginDir,
+      sourceEntry,
+      ...setupSourcePath ? { setupEntry: setupSourcePath } : {}
+    });
+    const runtimeSidecarArtifacts = collectBundledPluginRuntimeSidecarArtifacts(publicSurfaceArtifacts);
+    const channelConfigs = manifestResult.manifest.channelConfigs;
+    entries.push({
+      dirName,
+      idHint: deriveBundledPluginIdHint({
+        entryPath: sourceEntry,
+        manifestId: manifestResult.manifest.id,
+        packageName: normalizeOptionalString(packageJson?.name),
+        hasMultipleExtensions: extensions.length > 1
+      }),
+      source: {
+        source: sourceEntry,
+        built: builtEntry
+      },
+      ...setupSource ? { setupSource } : {},
+      ...publicSurfaceArtifacts ? { publicSurfaceArtifacts } : {},
+      ...runtimeSidecarArtifacts ? { runtimeSidecarArtifacts } : {},
+      ...normalizeOptionalString(packageJson?.name) ? { packageName: normalizeOptionalString(packageJson?.name) } : {},
+      ...normalizeOptionalString(packageJson?.version) ? { packageVersion: normalizeOptionalString(packageJson?.version) } : {},
+      ...normalizeOptionalString(packageJson?.description) ? { packageDescription: normalizeOptionalString(packageJson?.description) } : {},
+      ...packageManifest ? { packageManifest } : {},
+      manifest: {
+        ...manifestResult.manifest,
+        ...channelConfigs ? { channelConfigs } : {}
+      }
+    });
+  }
+  return entries;
+}
+function listBundledPluginMetadata(params) {
+  const rootDir = path.resolve(params?.rootDir ?? OPENCLAW_PACKAGE_ROOT);
+  const includeChannelConfigs = params?.includeChannelConfigs;
+  const includeSyntheticChannelConfigs = params?.includeSyntheticChannelConfigs;
+  const cacheKey = JSON.stringify({
+    rootDir,
+    includeChannelConfigs,
+    includeSyntheticChannelConfigs
+  });
+  const cached = bundledPluginMetadataCache.get(cacheKey);
+  if (cached) return cached;
+  const entries = Object.freeze(collectBundledPluginMetadataForPackageRoot(rootDir));
+  bundledPluginMetadataCache.set(cacheKey, entries);
+  return entries;
+}
+export {
+  collectBundledChannelConfigs as a,
+  listBundledPluginMetadata as n,
+  normalizeBundledPluginStringList as o,
+  resolveBundledPluginScanDir as s
+};