@workclaw/openclaw-workclaw 1.0.30 → 1.0.33

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/channel-entry-contract-BoTfqLnn.js

@@ -0,0 +1,176 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+import { i as openBoundaryFileSync } from "./boundary-file-read-BymsBHso.js";
+import { u as resolvePluginLoaderJitiConfig, n as buildPluginLoaderJitiOptions, l as resolveLoaderPackageRoot } from "./sdk-alias-Bo1huP7M.js";
+import "./config-schema-DB8FqQH8.js";
+import { createRequire } from "node:module";
+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 nodeRequire = createRequire(import.meta.url);
+const jitiLoaders = /* @__PURE__ */ new Map();
+const loadedModuleExports = /* @__PURE__ */ new Map();
+const disableBundledEntrySourceFallbackEnv = "OPENCLAW_DISABLE_BUNDLED_ENTRY_SOURCE_FALLBACK";
+function isTruthyEnvFlag(value) {
+  return value !== void 0 && !/^(?:0|false)$/iu.test(value.trim());
+}
+function resolveSpecifierCandidates(modulePath) {
+  const ext = normalizeLowercaseStringOrEmpty(path.extname(modulePath));
+  if (ext === ".js") return [modulePath, modulePath.slice(0, -3) + ".ts"];
+  if (ext === ".mjs") return [modulePath, modulePath.slice(0, -4) + ".mts"];
+  if (ext === ".cjs") return [modulePath, modulePath.slice(0, -4) + ".cts"];
+  return [modulePath];
+}
+function resolveEntryBoundaryRoot(importMetaUrl) {
+  return path.dirname(fileURLToPath(importMetaUrl));
+}
+function addBundledEntryCandidates(candidates, basePath, boundaryRoot) {
+  for (const candidate of resolveSpecifierCandidates(basePath)) {
+    if (candidates.some((entry) => entry.path === candidate && entry.boundaryRoot === boundaryRoot)) continue;
+    candidates.push({
+      path: candidate,
+      boundaryRoot
+    });
+  }
+}
+function resolveBundledEntryModuleCandidates(importMetaUrl, specifier) {
+  const importerPath = fileURLToPath(importMetaUrl);
+  const importerDir = path.dirname(importerPath);
+  const boundaryRoot = resolveEntryBoundaryRoot(importMetaUrl);
+  const candidates = [];
+  addBundledEntryCandidates(candidates, path.resolve(importerDir, specifier), boundaryRoot);
+  const sourceRelativeSpecifier = specifier.replace(/^\.\/src\//u, "./");
+  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path.resolve(importerDir, sourceRelativeSpecifier), boundaryRoot);
+  const packageRoot = resolveLoaderPackageRoot({
+    modulePath: importerPath,
+    moduleUrl: importMetaUrl,
+    cwd: importerDir,
+    argv1: process.argv[1]
+  });
+  if (!packageRoot) return candidates;
+  const distExtensionsRoot = path.join(packageRoot, "dist", "extensions") + path.sep;
+  if (!importerPath.startsWith(distExtensionsRoot)) return candidates;
+  if (isTruthyEnvFlag(process.env[disableBundledEntrySourceFallbackEnv])) return candidates;
+  const pluginDirName = path.basename(importerDir);
+  const sourcePluginRoot = path.join(packageRoot, "extensions", pluginDirName);
+  if (sourcePluginRoot === boundaryRoot) return candidates;
+  addBundledEntryCandidates(candidates, path.resolve(sourcePluginRoot, specifier), sourcePluginRoot);
+  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path.resolve(sourcePluginRoot, sourceRelativeSpecifier), sourcePluginRoot);
+  return candidates;
+}
+function formatBundledEntryUnknownError(error) {
+  if (typeof error === "string") return error;
+  if (error === void 0) return "boundary validation failed";
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return "non-serializable error";
+  }
+}
+function formatBundledEntryModuleOpenFailure(params) {
+  const importerPath = fileURLToPath(params.importMetaUrl);
+  const errorDetail = params.failure.error instanceof Error ? params.failure.error.message : formatBundledEntryUnknownError(params.failure.error);
+  return [
+    `bundled plugin entry "${params.specifier}" failed to open`,
+    `from "${importerPath}"`,
+    `(resolved "${params.resolvedPath}", plugin root "${params.boundaryRoot}",`,
+    `reason "${params.failure.reason}"): ${errorDetail}`
+  ].join(" ");
+}
+function resolveBundledEntryModulePath(importMetaUrl, specifier) {
+  const candidates = resolveBundledEntryModuleCandidates(importMetaUrl, specifier);
+  const fallbackCandidate = candidates[0] ?? {
+    path: path.resolve(path.dirname(fileURLToPath(importMetaUrl)), specifier),
+    boundaryRoot: resolveEntryBoundaryRoot(importMetaUrl)
+  };
+  let firstFailure = null;
+  for (const candidate of candidates) {
+    const opened = openBoundaryFileSync({
+      absolutePath: candidate.path,
+      rootPath: candidate.boundaryRoot,
+      boundaryLabel: "plugin root",
+      rejectHardlinks: false,
+      skipLexicalRootCheck: true
+    });
+    if (opened.ok) {
+      fs.closeSync(opened.fd);
+      return opened.path;
+    }
+    firstFailure ??= {
+      candidate,
+      failure: opened
+    };
+  }
+  const failure = firstFailure;
+  if (!failure) throw new Error(formatBundledEntryModuleOpenFailure({
+    importMetaUrl,
+    specifier,
+    resolvedPath: fallbackCandidate.path,
+    boundaryRoot: fallbackCandidate.boundaryRoot,
+    failure: {
+      ok: false,
+      reason: "path",
+      error: /* @__PURE__ */ new Error(`ENOENT: no such file or directory, lstat '${fallbackCandidate.path}'`)
+    }
+  }));
+  throw new Error(formatBundledEntryModuleOpenFailure({
+    importMetaUrl,
+    specifier,
+    resolvedPath: failure.candidate.path,
+    boundaryRoot: failure.candidate.boundaryRoot,
+    failure: failure.failure
+  }));
+}
+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 loadBundledEntryModuleSync(importMetaUrl, specifier) {
+  const modulePath = resolveBundledEntryModulePath(importMetaUrl, specifier);
+  const cached = loadedModuleExports.get(modulePath);
+  if (cached !== void 0) return cached;
+  let loaded;
+  if (process.platform === "win32" && modulePath.includes(`${path.sep}dist${path.sep}`) && [
+    ".js",
+    ".mjs",
+    ".cjs"
+  ].includes(normalizeLowercaseStringOrEmpty(path.extname(modulePath)))) try {
+    loaded = nodeRequire(modulePath);
+  } catch {
+    loaded = getJiti(modulePath)(modulePath);
+  }
+  else loaded = getJiti(modulePath)(modulePath);
+  loadedModuleExports.set(modulePath, loaded);
+  return loaded;
+}
+function loadBundledEntryExportSync(importMetaUrl, reference) {
+  const loaded = loadBundledEntryModuleSync(importMetaUrl, reference.specifier);
+  const resolved = loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
+  if (!reference.exportName) return resolved;
+  const record = resolved ?? loaded;
+  if (!record || !(reference.exportName in record)) throw new Error(`missing export "${reference.exportName}" from bundled entry module ${reference.specifier}`);
+  return record[reference.exportName];
+}
+function defineBundledChannelSetupEntry({ importMetaUrl, plugin, secrets }) {
+  return {
+    kind: "bundled-channel-setup-entry",
+    loadSetupPlugin: () => loadBundledEntryExportSync(importMetaUrl, plugin),
+    ...secrets ? { loadSetupSecrets: () => loadBundledEntryExportSync(importMetaUrl, secrets) } : {}
+  };
+}
+export {
+  defineBundledChannelSetupEntry as n,
+  loadBundledEntryExportSync as r
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/cli-name-DPC4W7Fo.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+const DEFAULT_CLI_NAME = "openclaw";
+const KNOWN_CLI_NAMES = /* @__PURE__ */ new Set([DEFAULT_CLI_NAME]);
+const CLI_PREFIX_RE = /^(?:((?:pnpm|npm|bunx|npx)\s+))?(openclaw)\b/;
+function resolveCliName(argv = process.argv) {
+  const argv1 = argv[1];
+  if (!argv1) return DEFAULT_CLI_NAME;
+  const base = path.basename(argv1).trim();
+  if (KNOWN_CLI_NAMES.has(base)) return base;
+  return DEFAULT_CLI_NAME;
+}
+function replaceCliName(command, cliName = resolveCliName()) {
+  if (!command.trim()) return command;
+  if (!CLI_PREFIX_RE.test(command)) return command;
+  return command.replace(CLI_PREFIX_RE, (_match, runner) => {
+    return `${runner ?? ""}${cliName}`;
+  });
+}
+export {
+  resolveCliName as n,
+  replaceCliName as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/command-format-LqDv8ows.js

@@ -0,0 +1,24 @@
+import { n as normalizeProfileName } from "./profile-utils-Dh8DVvPv.js";
+import { t as replaceCliName, n as resolveCliName } from "./cli-name-DPC4W7Fo.js";
+const CLI_PREFIX_RE = /^(?:pnpm|npm|bunx|npx)\s+openclaw\b|^openclaw\b/;
+const CONTAINER_FLAG_RE = /(?:^|\s)--container(?:\s|=|$)/;
+const PROFILE_FLAG_RE = /(?:^|\s)--profile(?:\s|=|$)/;
+const DEV_FLAG_RE = /(?:^|\s)--dev(?:\s|$)/;
+const UPDATE_COMMAND_RE = /^(?:pnpm|npm|bunx|npx)\s+openclaw\b.*(?:^|\s)update(?:\s|$)|^openclaw\b.*(?:^|\s)update(?:\s|$)/;
+const CONTAINER_HINT_RE = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/;
+function formatCliCommand(command, env = process.env) {
+  const normalizedCommand = replaceCliName(command, resolveCliName());
+  const rawContainer = env.OPENCLAW_CONTAINER_HINT?.trim();
+  const container = rawContainer && CONTAINER_HINT_RE.test(rawContainer) ? rawContainer : void 0;
+  const profile = normalizeProfileName(env.OPENCLAW_PROFILE);
+  if (!container && !profile) return normalizedCommand;
+  if (!CLI_PREFIX_RE.test(normalizedCommand)) return normalizedCommand;
+  const additions = [];
+  if (container && !CONTAINER_FLAG_RE.test(normalizedCommand) && !UPDATE_COMMAND_RE.test(normalizedCommand)) additions.push(`--container ${container}`);
+  if (!container && profile && !PROFILE_FLAG_RE.test(normalizedCommand) && !DEV_FLAG_RE.test(normalizedCommand)) additions.push(`--profile ${profile}`);
+  if (additions.length === 0) return normalizedCommand;
+  return normalizedCommand.replace(CLI_PREFIX_RE, (match) => `${match} ${additions.join(" ")}`);
+}
+export {
+  formatCliCommand as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/command-registration-Dxq1bCXM.js

@@ -0,0 +1,16 @@
+import { n as resolveGlobalSingleton } from "./global-singleton-DhGoboiG.js";
+import "./logger-BMuqDP66.js";
+import "./theme-CVJvORNs.js";
+import "./bundled-Cuj8sKt6.js";
+import "./registry-DE4nHTjg.js";
+import "./ids-By7Nkc8R.js";
+const PLUGIN_COMMAND_STATE_KEY = Symbol.for("openclaw.pluginCommandsState");
+const getState = () => resolveGlobalSingleton(PLUGIN_COMMAND_STATE_KEY, () => ({
+  pluginCommands: /* @__PURE__ */ new Map(),
+  registryLocked: false
+}));
+const getPluginCommandMap = () => getState().pluginCommands;
+new Proxy(/* @__PURE__ */ new Map(), { get(_target, property) {
+  const value = Reflect.get(getPluginCommandMap(), property, getPluginCommandMap());
+  return typeof value === "function" ? value.bind(getPluginCommandMap()) : value;
+} });

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/commands-registry-normalize-Bk0WYUI0.js

@@ -0,0 +1,94 @@
+import { i as normalizeLowercaseStringOrEmpty, o as normalizeOptionalLowercaseString, s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import { c as escapeRegExp } from "./utils-DGFSjtQF.js";
+import { t as getChatCommands } from "./commands-registry.data-D99VdOlX.js";
+let cachedTextAliasMap = null;
+let cachedTextAliasCommands = null;
+let cachedDetection;
+let cachedDetectionCommands = null;
+function getTextAliasMap() {
+  const commands = getChatCommands();
+  if (cachedTextAliasMap && cachedTextAliasCommands === commands) return cachedTextAliasMap;
+  const map = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const canonical = normalizeOptionalString(command.textAliases[0]) || `/${command.key}`;
+    const acceptsArgs = Boolean(command.acceptsArgs);
+    for (const alias of command.textAliases) {
+      const normalized = normalizeOptionalLowercaseString(alias);
+      if (!normalized) continue;
+      if (!map.has(normalized)) map.set(normalized, {
+        key: command.key,
+        canonical,
+        acceptsArgs
+      });
+    }
+  }
+  cachedTextAliasMap = map;
+  cachedTextAliasCommands = commands;
+  return map;
+}
+function normalizeCommandBody(raw, options) {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("/")) return trimmed;
+  const newline = trimmed.indexOf("\n");
+  const singleLine = newline === -1 ? trimmed : trimmed.slice(0, newline).trim();
+  const colonMatch = singleLine.match(/^\/([^\s:]+)\s*:(.*)$/);
+  const normalized = colonMatch ? (() => {
+    const [, command, rest2] = colonMatch;
+    const normalizedRest2 = rest2.trimStart();
+    return normalizedRest2 ? `/${command} ${normalizedRest2}` : `/${command}`;
+  })() : singleLine;
+  const normalizedBotUsername = normalizeOptionalLowercaseString(options?.botUsername);
+  const mentionMatch = normalizedBotUsername ? normalized.match(/^\/([^\s@]+)@([^\s]+)(.*)$/) : null;
+  const commandBody = mentionMatch && normalizeLowercaseStringOrEmpty(mentionMatch[2]) === normalizedBotUsername ? `/${mentionMatch[1]}${mentionMatch[3] ?? ""}` : normalized;
+  const lowered = normalizeLowercaseStringOrEmpty(commandBody);
+  const textAliasMap = getTextAliasMap();
+  const exact = textAliasMap.get(lowered);
+  if (exact) return exact.canonical;
+  const tokenMatch = commandBody.match(/^\/([^\s]+)(?:\s+([\s\S]+))?$/);
+  if (!tokenMatch) return commandBody;
+  const [, token, rest] = tokenMatch;
+  const tokenKey = `/${normalizeLowercaseStringOrEmpty(token)}`;
+  const tokenSpec = textAliasMap.get(tokenKey);
+  if (!tokenSpec) return commandBody;
+  if (rest && !tokenSpec.acceptsArgs) return commandBody;
+  const normalizedRest = rest?.trimStart();
+  return normalizedRest ? `${tokenSpec.canonical} ${normalizedRest}` : tokenSpec.canonical;
+}
+function getCommandDetection(_cfg) {
+  const commands = getChatCommands();
+  if (cachedDetection && cachedDetectionCommands === commands) return cachedDetection;
+  const exact = /* @__PURE__ */ new Set();
+  const patterns = [];
+  for (const cmd of commands) for (const alias of cmd.textAliases) {
+    const normalized = normalizeOptionalLowercaseString(alias);
+    if (!normalized) continue;
+    exact.add(normalized);
+    const escaped = escapeRegExp(normalized);
+    if (!escaped) continue;
+    if (cmd.acceptsArgs) patterns.push(`${escaped}(?:\\s+.+|\\s*:\\s*.*)?`);
+    else patterns.push(`${escaped}(?:\\s*:\\s*)?`);
+  }
+  cachedDetection = {
+    exact,
+    regex: patterns.length ? new RegExp(`^(?:${patterns.join("|")})$`, "i") : /$^/
+  };
+  cachedDetectionCommands = commands;
+  return cachedDetection;
+}
+function maybeResolveTextAlias(raw, cfg) {
+  const trimmed = normalizeCommandBody(raw).trim();
+  if (!trimmed.startsWith("/")) return null;
+  const detection = getCommandDetection();
+  const normalized = normalizeLowercaseStringOrEmpty(trimmed);
+  if (detection.exact.has(normalized)) return normalized;
+  if (!detection.regex.test(normalized)) return null;
+  const tokenMatch = normalized.match(/^\/([^\s:]+)(?:\s|$)/);
+  if (!tokenMatch) return null;
+  const tokenKey = `/${tokenMatch[1]}`;
+  return getTextAliasMap().has(tokenKey) ? tokenKey : null;
+}
+export {
+  maybeResolveTextAlias as n,
+  normalizeCommandBody as r,
+  getCommandDetection as t
+};