@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-safe-bin-trust-DOmID2EO.js

@@ -0,0 +1,638 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+import "node:path";
+import "node:os";
+import "node:fs";
+const NO_FLAGS$1 = /* @__PURE__ */ new Set();
+const toFlagSet = (flags) => {
+  if (!flags || flags.length === 0) return NO_FLAGS$1;
+  return new Set(flags);
+};
+function collectKnownLongFlags(allowedValueFlags, deniedFlags) {
+  const known = /* @__PURE__ */ new Set();
+  for (const flag of allowedValueFlags) if (flag.startsWith("--")) known.add(flag);
+  for (const flag of deniedFlags) if (flag.startsWith("--")) known.add(flag);
+  return Array.from(known);
+}
+function buildLongFlagPrefixMap(knownLongFlags) {
+  const prefixMap = /* @__PURE__ */ new Map();
+  for (const flag of knownLongFlags) {
+    if (!flag.startsWith("--") || flag.length <= 2) continue;
+    for (let length = 3; length <= flag.length; length += 1) {
+      const prefix = flag.slice(0, length);
+      const existing = prefixMap.get(prefix);
+      if (existing === void 0) {
+        prefixMap.set(prefix, flag);
+        continue;
+      }
+      if (existing !== flag) prefixMap.set(prefix, null);
+    }
+  }
+  return prefixMap;
+}
+function compileSafeBinProfile(fixture) {
+  const allowedValueFlags = toFlagSet(fixture.allowedValueFlags);
+  const deniedFlags = toFlagSet(fixture.deniedFlags);
+  const knownLongFlags = collectKnownLongFlags(allowedValueFlags, deniedFlags);
+  return {
+    minPositional: fixture.minPositional,
+    maxPositional: fixture.maxPositional,
+    allowedValueFlags,
+    deniedFlags,
+    knownLongFlags,
+    knownLongFlagsSet: new Set(knownLongFlags),
+    longFlagPrefixMap: buildLongFlagPrefixMap(knownLongFlags)
+  };
+}
+function compileSafeBinProfiles(fixtures) {
+  return Object.fromEntries(Object.entries(fixtures).map(([name, fixture]) => [name, compileSafeBinProfile(fixture)]));
+}
+compileSafeBinProfiles({
+  jq: {
+    maxPositional: 1,
+    allowedValueFlags: [
+      "--arg",
+      "--argjson",
+      "--argstr"
+    ],
+    deniedFlags: [
+      "--argfile",
+      "--rawfile",
+      "--slurpfile",
+      "--from-file",
+      "--library-path",
+      "-L",
+      "-f"
+    ]
+  },
+  grep: {
+    maxPositional: 0,
+    allowedValueFlags: [
+      "--regexp",
+      "--max-count",
+      "--after-context",
+      "--before-context",
+      "--context",
+      "--devices",
+      "--binary-files",
+      "--exclude",
+      "--include",
+      "--label",
+      "-e",
+      "-m",
+      "-A",
+      "-B",
+      "-C",
+      "-D"
+    ],
+    deniedFlags: [
+      "--file",
+      "--exclude-from",
+      "--dereference-recursive",
+      "--directories",
+      "--recursive",
+      "-f",
+      "-d",
+      "-r",
+      "-R"
+    ]
+  },
+  cut: {
+    maxPositional: 0,
+    allowedValueFlags: [
+      "--bytes",
+      "--characters",
+      "--fields",
+      "--delimiter",
+      "--output-delimiter",
+      "-b",
+      "-c",
+      "-f",
+      "-d"
+    ]
+  },
+  sort: {
+    maxPositional: 0,
+    allowedValueFlags: [
+      "--key",
+      "--field-separator",
+      "--buffer-size",
+      "--parallel",
+      "--batch-size",
+      "-k",
+      "-t",
+      "-S"
+    ],
+    deniedFlags: [
+      "--compress-program",
+      "--files0-from",
+      "--output",
+      "--random-source",
+      "--temporary-directory",
+      "-T",
+      "-o"
+    ]
+  },
+  uniq: {
+    maxPositional: 0,
+    allowedValueFlags: [
+      "--skip-fields",
+      "--skip-chars",
+      "--check-chars",
+      "--group",
+      "-f",
+      "-s",
+      "-w"
+    ]
+  },
+  head: {
+    maxPositional: 0,
+    allowedValueFlags: [
+      "--lines",
+      "--bytes",
+      "-n",
+      "-c"
+    ]
+  },
+  tail: {
+    maxPositional: 0,
+    allowedValueFlags: [
+      "--lines",
+      "--bytes",
+      "--sleep-interval",
+      "--max-unchanged-stats",
+      "--pid",
+      "-n",
+      "-c"
+    ]
+  },
+  tr: {
+    minPositional: 1,
+    maxPositional: 2
+  },
+  wc: {
+    maxPositional: 0,
+    deniedFlags: ["--files0-from"]
+  }
+});
+const ENV_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-u",
+  "--unset",
+  "-c",
+  "--chdir",
+  "-s",
+  "--split-string",
+  "--default-signal",
+  "--ignore-signal",
+  "--block-signal"
+]);
+const ENV_INLINE_VALUE_PREFIXES = [
+  "-u",
+  "-c",
+  "-s",
+  "--unset=",
+  "--chdir=",
+  "--split-string=",
+  "--default-signal=",
+  "--ignore-signal=",
+  "--block-signal="
+];
+const ENV_FLAG_OPTIONS = /* @__PURE__ */ new Set([
+  "-i",
+  "--ignore-environment",
+  "-0",
+  "--null"
+]);
+const NICE_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-n",
+  "--adjustment",
+  "--priority"
+]);
+const CAFFEINATE_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set(["-t", "-w"]);
+const STDBUF_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-i",
+  "--input",
+  "-o",
+  "--output",
+  "-e",
+  "--error"
+]);
+const TIME_FLAG_OPTIONS = /* @__PURE__ */ new Set([
+  "-a",
+  "--append",
+  "-h",
+  "--help",
+  "-l",
+  "-p",
+  "-q",
+  "--quiet",
+  "-v",
+  "--verbose",
+  "-V",
+  "--version"
+]);
+const TIME_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-f",
+  "--format",
+  "-o",
+  "--output"
+]);
+const BSD_SCRIPT_FLAG_OPTIONS = /* @__PURE__ */ new Set([
+  "-a",
+  "-d",
+  "-k",
+  "-p",
+  "-q",
+  "-r"
+]);
+const BSD_SCRIPT_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set(["-F", "-t"]);
+const SANDBOX_EXEC_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-f",
+  "-p",
+  "-d"
+]);
+const TIMEOUT_FLAG_OPTIONS = /* @__PURE__ */ new Set([
+  "--foreground",
+  "--preserve-status",
+  "-v",
+  "--verbose"
+]);
+const TIMEOUT_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-k",
+  "--kill-after",
+  "-s",
+  "--signal"
+]);
+const XCRUN_FLAG_OPTIONS = /* @__PURE__ */ new Set([
+  "-k",
+  "--kill-cache",
+  "-l",
+  "--log",
+  "-n",
+  "--no-cache",
+  "-r",
+  "--run",
+  "-v",
+  "--verbose"
+]);
+function isArchSelectorToken(token) {
+  return /^-[A-Za-z0-9_]+$/.test(token);
+}
+function isKnownArchSelectorToken(token) {
+  return token === "-arm64" || token === "-arm64e" || token === "-i386" || token === "-x86_64" || token === "-x86_64h";
+}
+function isKnownArchNameToken(token) {
+  return isKnownArchSelectorToken(`-${token}`);
+}
+function withWindowsExeAliases$1(names) {
+  const expanded = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    expanded.add(name);
+    expanded.add(`${name}.exe`);
+  }
+  return Array.from(expanded);
+}
+function isEnvAssignment(token) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token);
+}
+function hasEnvInlineValuePrefix(lower) {
+  for (const prefix of ENV_INLINE_VALUE_PREFIXES) if (lower.startsWith(prefix)) return true;
+  return false;
+}
+function scanWrapperInvocation(argv, params) {
+  let idx = 1;
+  let expectsOptionValue = false;
+  while (idx < argv.length) {
+    const token = argv[idx]?.trim() ?? "";
+    if (!token) {
+      idx += 1;
+      continue;
+    }
+    if (expectsOptionValue) {
+      expectsOptionValue = false;
+      idx += 1;
+      continue;
+    }
+    if (params.separators?.has(token)) {
+      idx += 1;
+      break;
+    }
+    const directive = params.onToken(token, normalizeLowercaseStringOrEmpty(token));
+    if (directive === "stop") break;
+    if (directive === "invalid") return null;
+    if (directive === "consume-next") expectsOptionValue = true;
+    idx += 1;
+  }
+  if (expectsOptionValue) return null;
+  const commandIndex = params.adjustCommandIndex ? params.adjustCommandIndex(idx, argv) : idx;
+  if (commandIndex === null || commandIndex >= argv.length) return null;
+  return argv.slice(commandIndex);
+}
+function unwrapEnvInvocation(argv) {
+  const parsed = parseEnvInvocationPrelude(argv);
+  return parsed ? argv.slice(parsed.commandIndex) : null;
+}
+function parseEnvInvocationPrelude(argv) {
+  let idx = 1;
+  let expectsOptionValue = false;
+  const assignmentKeys = [];
+  while (idx < argv.length) {
+    const token = argv[idx]?.trim() ?? "";
+    if (!token) {
+      idx += 1;
+      continue;
+    }
+    if (expectsOptionValue) {
+      expectsOptionValue = false;
+      idx += 1;
+      continue;
+    }
+    if (token === "--" || token === "-") {
+      idx += 1;
+      break;
+    }
+    if (isEnvAssignment(token)) {
+      const delimiter = token.indexOf("=");
+      if (delimiter > 0) assignmentKeys.push(token.slice(0, delimiter));
+      idx += 1;
+      continue;
+    }
+    if (!token.startsWith("-") || token === "-") break;
+    const lower = normalizeLowercaseStringOrEmpty(token);
+    const [flag] = lower.split("=", 2);
+    if (ENV_FLAG_OPTIONS.has(flag)) {
+      idx += 1;
+      continue;
+    }
+    if (ENV_OPTIONS_WITH_VALUE.has(flag)) {
+      if (lower.includes("=")) {
+        idx += 1;
+        continue;
+      }
+      expectsOptionValue = true;
+      idx += 1;
+      continue;
+    }
+    if (hasEnvInlineValuePrefix(lower)) {
+      idx += 1;
+      continue;
+    }
+    return null;
+  }
+  if (expectsOptionValue || idx >= argv.length) return null;
+  return {
+    assignmentKeys,
+    commandIndex: idx
+  };
+}
+function envInvocationUsesModifiers(argv) {
+  let idx = 1;
+  let expectsOptionValue = false;
+  while (idx < argv.length) {
+    const token = argv[idx]?.trim() ?? "";
+    if (!token) {
+      idx += 1;
+      continue;
+    }
+    if (expectsOptionValue) return true;
+    if (token === "--" || token === "-") {
+      idx += 1;
+      break;
+    }
+    if (isEnvAssignment(token)) return true;
+    if (!token.startsWith("-") || token === "-") break;
+    const lower = normalizeLowercaseStringOrEmpty(token);
+    const [flag] = lower.split("=", 2);
+    if (ENV_FLAG_OPTIONS.has(flag)) return true;
+    if (ENV_OPTIONS_WITH_VALUE.has(flag)) {
+      if (lower.includes("=")) return true;
+      expectsOptionValue = true;
+      idx += 1;
+      continue;
+    }
+    if (hasEnvInlineValuePrefix(lower)) return true;
+    return true;
+  }
+  return false;
+}
+function unwrapDashOptionInvocation(argv, params) {
+  return scanWrapperInvocation(argv, {
+    separators: /* @__PURE__ */ new Set(["--"]),
+    onToken: (token, lower) => {
+      if (!token.startsWith("-") || token === "-") return "stop";
+      const [flag] = lower.split("=", 2);
+      return params.onFlag(flag, lower);
+    },
+    adjustCommandIndex: params.adjustCommandIndex
+  });
+}
+function unwrapNiceInvocation(argv) {
+  return unwrapDashOptionInvocation(argv, { onFlag: (flag, lower) => {
+    if (/^-\d+$/.test(lower)) return "continue";
+    if (NICE_OPTIONS_WITH_VALUE.has(flag)) return lower.includes("=") || lower !== flag ? "continue" : "consume-next";
+    if (lower.startsWith("-n") && lower.length > 2) return "continue";
+    return "invalid";
+  } });
+}
+function unwrapCaffeinateInvocation(argv) {
+  return unwrapDashOptionInvocation(argv, { onFlag: (flag, lower) => {
+    if (flag === "-d" || flag === "-i" || flag === "-m" || flag === "-s" || flag === "-u") return "continue";
+    if (CAFFEINATE_OPTIONS_WITH_VALUE.has(flag)) return lower !== flag || lower.includes("=") ? "continue" : "consume-next";
+    return "invalid";
+  } });
+}
+function unwrapNohupInvocation(argv) {
+  return scanWrapperInvocation(argv, {
+    separators: /* @__PURE__ */ new Set(["--"]),
+    onToken: (token, lower) => {
+      if (!token.startsWith("-") || token === "-") return "stop";
+      return lower === "--help" || lower === "--version" ? "continue" : "invalid";
+    }
+  });
+}
+function unwrapSandboxExecInvocation(argv) {
+  return unwrapDashOptionInvocation(argv, { onFlag: (flag, lower) => {
+    if (SANDBOX_EXEC_OPTIONS_WITH_VALUE.has(flag)) return lower !== flag || lower.includes("=") ? "continue" : "consume-next";
+    return "invalid";
+  } });
+}
+function unwrapStdbufInvocation(argv) {
+  return unwrapDashOptionInvocation(argv, { onFlag: (flag, lower) => {
+    if (!STDBUF_OPTIONS_WITH_VALUE.has(flag)) return "invalid";
+    return lower.includes("=") ? "continue" : "consume-next";
+  } });
+}
+function unwrapTimeInvocation(argv) {
+  return unwrapDashOptionInvocation(argv, { onFlag: (flag, lower) => {
+    if (TIME_FLAG_OPTIONS.has(flag)) return "continue";
+    if (TIME_OPTIONS_WITH_VALUE.has(flag)) return lower.includes("=") ? "continue" : "consume-next";
+    return "invalid";
+  } });
+}
+function supportsScriptPositionalCommand(platform = process.platform) {
+  return platform === "darwin" || platform === "freebsd";
+}
+function unwrapScriptInvocation(argv) {
+  if (!supportsScriptPositionalCommand()) return null;
+  return scanWrapperInvocation(argv, {
+    separators: /* @__PURE__ */ new Set(["--"]),
+    onToken: (token, lower) => {
+      if (!lower.startsWith("-") || lower === "-") return "stop";
+      const [flag] = token.split("=", 2);
+      if (BSD_SCRIPT_OPTIONS_WITH_VALUE.has(flag)) return token.includes("=") ? "continue" : "consume-next";
+      if (BSD_SCRIPT_FLAG_OPTIONS.has(flag)) return "continue";
+      return "invalid";
+    },
+    adjustCommandIndex: (commandIndex, currentArgv) => {
+      let sawTranscript = false;
+      for (let idx = commandIndex; idx < currentArgv.length; idx += 1) {
+        if (!(currentArgv[idx]?.trim() ?? "")) continue;
+        if (!sawTranscript) {
+          sawTranscript = true;
+          continue;
+        }
+        return idx;
+      }
+      return null;
+    }
+  });
+}
+function unwrapTimeoutInvocation(argv) {
+  return unwrapDashOptionInvocation(argv, {
+    onFlag: (flag, lower) => {
+      if (TIMEOUT_FLAG_OPTIONS.has(flag)) return "continue";
+      if (TIMEOUT_OPTIONS_WITH_VALUE.has(flag)) return lower.includes("=") ? "continue" : "consume-next";
+      return "invalid";
+    },
+    adjustCommandIndex: (commandIndex, currentArgv) => {
+      const wrappedCommandIndex = commandIndex + 1;
+      return wrappedCommandIndex < currentArgv.length ? wrappedCommandIndex : null;
+    }
+  });
+}
+function unwrapArchInvocation(argv) {
+  let expectsArchName = false;
+  return scanWrapperInvocation(argv, { onToken: (token, lower) => {
+    if (expectsArchName) {
+      expectsArchName = false;
+      return isKnownArchNameToken(lower) ? "continue" : "invalid";
+    }
+    if (!token.startsWith("-") || token === "-") return "stop";
+    if (lower === "-32" || lower === "-64") return "continue";
+    if (lower === "-arch") {
+      expectsArchName = true;
+      return "continue";
+    }
+    if (lower === "-c" || lower === "-d" || lower === "-e" || lower === "-h") return "invalid";
+    return isArchSelectorToken(token) && isKnownArchSelectorToken(lower) ? "continue" : "invalid";
+  } });
+}
+function supportsArchDispatchWrapper(platform = process.platform) {
+  return platform === "darwin";
+}
+function supportsXcrunDispatchWrapper(platform = process.platform) {
+  return platform === "darwin";
+}
+function unwrapXcrunInvocation(argv) {
+  return scanWrapperInvocation(argv, { onToken: (token, lower) => {
+    if (!token.startsWith("-") || token === "-") return "stop";
+    if (XCRUN_FLAG_OPTIONS.has(lower)) return "continue";
+    return "invalid";
+  } });
+}
+const DISPATCH_WRAPPER_SPECS = [
+  {
+    name: "arch",
+    unwrap: (argv, platform) => supportsArchDispatchWrapper(platform) ? unwrapArchInvocation(argv) : null,
+    transparentUsage: (_argv, platform) => supportsArchDispatchWrapper(platform)
+  },
+  {
+    name: "caffeinate",
+    unwrap: unwrapCaffeinateInvocation,
+    transparentUsage: true
+  },
+  { name: "chrt" },
+  { name: "doas" },
+  {
+    name: "env",
+    unwrap: unwrapEnvInvocation,
+    transparentUsage: (argv) => !envInvocationUsesModifiers(argv)
+  },
+  { name: "ionice" },
+  {
+    name: "nice",
+    unwrap: unwrapNiceInvocation,
+    transparentUsage: true
+  },
+  {
+    name: "nohup",
+    unwrap: unwrapNohupInvocation,
+    transparentUsage: true
+  },
+  {
+    name: "sandbox-exec",
+    unwrap: unwrapSandboxExecInvocation,
+    transparentUsage: true
+  },
+  {
+    name: "script",
+    unwrap: unwrapScriptInvocation,
+    transparentUsage: true
+  },
+  { name: "setsid" },
+  {
+    name: "stdbuf",
+    unwrap: unwrapStdbufInvocation,
+    transparentUsage: true
+  },
+  { name: "sudo" },
+  { name: "taskset" },
+  {
+    name: "time",
+    unwrap: unwrapTimeInvocation,
+    transparentUsage: true
+  },
+  {
+    name: "timeout",
+    unwrap: unwrapTimeoutInvocation,
+    transparentUsage: true
+  },
+  {
+    name: "xcrun",
+    unwrap: (argv, platform) => supportsXcrunDispatchWrapper(platform) ? unwrapXcrunInvocation(argv) : null,
+    transparentUsage: (_argv, platform) => supportsXcrunDispatchWrapper(platform)
+  }
+];
+new Map(DISPATCH_WRAPPER_SPECS.map((spec) => [spec.name, spec]));
+new Set(withWindowsExeAliases$1(DISPATCH_WRAPPER_SPECS.map((spec) => spec.name)));
+const POSIX_SHELL_WRAPPER_NAMES = [
+  "ash",
+  "bash",
+  "dash",
+  "fish",
+  "ksh",
+  "sh",
+  "zsh"
+];
+const WINDOWS_CMD_WRAPPER_NAMES = ["cmd"];
+const POWERSHELL_WRAPPER_NAMES = ["powershell", "pwsh"];
+const SHELL_MULTIPLEXER_WRAPPER_NAMES = ["busybox", "toybox"];
+function withWindowsExeAliases(names) {
+  const expanded = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    expanded.add(name);
+    expanded.add(`${name}.exe`);
+  }
+  return Array.from(expanded);
+}
+new Set(POSIX_SHELL_WRAPPER_NAMES);
+new Set(withWindowsExeAliases(WINDOWS_CMD_WRAPPER_NAMES));
+new Set(withWindowsExeAliases(POWERSHELL_WRAPPER_NAMES));
+new Set(POSIX_SHELL_WRAPPER_NAMES);
+new Set(WINDOWS_CMD_WRAPPER_NAMES);
+new Set(POWERSHELL_WRAPPER_NAMES);
+new Set(SHELL_MULTIPLEXER_WRAPPER_NAMES);
+/* @__PURE__ */ new Set([
+  ...POSIX_SHELL_WRAPPER_NAMES,
+  ...WINDOWS_CMD_WRAPPER_NAMES,
+  ...POWERSHELL_WRAPPER_NAMES
+]);

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-safety-C8v0dsfc.js

@@ -0,0 +1,24 @@
+const SHELL_METACHARS = /[;&|`$<>]/;
+const CONTROL_CHARS = /[\r\n]/;
+const QUOTE_CHARS = /["']/;
+const BARE_NAME_PATTERN = /^[A-Za-z0-9._+-]+$/;
+function isLikelyPath(value) {
+  if (value.startsWith(".") || value.startsWith("~")) return true;
+  if (value.includes("/") || value.includes("\\")) return true;
+  return /^[A-Za-z]:[\\/]/.test(value);
+}
+function isSafeExecutableValue(value) {
+  if (!value) return false;
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  if (trimmed.includes("\0")) return false;
+  if (CONTROL_CHARS.test(trimmed)) return false;
+  if (SHELL_METACHARS.test(trimmed)) return false;
+  if (QUOTE_CHARS.test(trimmed)) return false;
+  if (isLikelyPath(trimmed)) return true;
+  if (trimmed.startsWith("-")) return false;
+  return BARE_NAME_PATTERN.test(trimmed);
+}
+export {
+  isSafeExecutableValue as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/facade-loader-B83leEeb.js

@@ -0,0 +1,10 @@
+import "node:fs";
+import "node:path";
+import "node:os";
+import "node:fs/promises";
+import "./bundled-dir-Cq5y_NKM.js";
+import "./sdk-alias-Bo1huP7M.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+fileURLToPath(import.meta.url);
+createRequire(import.meta.url);

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/facade-runtime-B04URCVZ.js

@@ -0,0 +1,14 @@
+import "./bundled-dir-Cq5y_NKM.js";
+import { l as resolveLoaderPackageRoot } from "./sdk-alias-Bo1huP7M.js";
+import "node:fs";
+import path from "node:path";
+import "./facade-loader-B83leEeb.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+const OPENCLAW_PACKAGE_ROOT = resolveLoaderPackageRoot({
+  modulePath: fileURLToPath(import.meta.url),
+  moduleUrl: import.meta.url
+}) ?? fileURLToPath(new URL("../..", import.meta.url));
+fileURLToPath(import.meta.url);
+path.resolve(OPENCLAW_PACKAGE_ROOT, "extensions");
+createRequire(import.meta.url);