@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/manifest-registry-CK0zNybm.js

@@ -0,0 +1,394 @@
+import { s as normalizeOptionalString, o as normalizeOptionalLowercaseString } from "./string-coerce-BUSzWgUA.js";
+import "./ids-By7Nkc8R.js";
+import { m as resolveUserPath } from "./utils-DGFSjtQF.js";
+import { o as resolveCompatibilityHostVersion } from "./version-b06Uhxnq.js";
+import { a as normalizeOptionalTrimmedStringList } from "./string-normalization-DIJRAo0o.js";
+import { i as loadPluginManifest } from "./manifest-CjPIwluH.js";
+import { l as loadBundleManifest, r as safeRealpathSync, n as isPathInside } from "./path-safety-CKqzLERR.js";
+import { n as discoverOpenClawPlugins, r as resolvePluginCacheInputs } from "./discovery-Cgp95o2R.js";
+import { n as defaultSlotIdForKey } from "./slots-PynIdqZ_.js";
+import { t as checkMinHostVersion } from "./min-host-version-CmguvhGB.js";
+import fs from "node:fs";
+import path from "node:path";
+const identityNormalizePluginId = (id) => id.trim();
+function normalizeList(value, normalizePluginId) {
+  if (!Array.isArray(value)) return [];
+  return value.map((entry) => typeof entry === "string" ? normalizePluginId(entry) : "").filter(Boolean);
+}
+function normalizeSlotValue(value) {
+  const trimmed = normalizeOptionalString(value);
+  if (!trimmed) return;
+  if (normalizeOptionalLowercaseString(trimmed) === "none") return null;
+  return trimmed;
+}
+function normalizePluginEntries(entries, normalizePluginId) {
+  if (!entries || typeof entries !== "object" || Array.isArray(entries)) return {};
+  const normalized = {};
+  for (const [key, value] of Object.entries(entries)) {
+    const normalizedKey = normalizePluginId(key);
+    if (!normalizedKey) continue;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      normalized[normalizedKey] = {};
+      continue;
+    }
+    const entry = value;
+    const hooksRaw = entry.hooks;
+    const hooks = hooksRaw && typeof hooksRaw === "object" && !Array.isArray(hooksRaw) ? { allowPromptInjection: hooksRaw.allowPromptInjection } : void 0;
+    const normalizedHooks = hooks && typeof hooks.allowPromptInjection === "boolean" ? { allowPromptInjection: hooks.allowPromptInjection } : void 0;
+    const subagentRaw = entry.subagent;
+    const subagent = subagentRaw && typeof subagentRaw === "object" && !Array.isArray(subagentRaw) ? {
+      allowModelOverride: subagentRaw.allowModelOverride,
+      hasAllowedModelsConfig: Array.isArray(subagentRaw.allowedModels),
+      allowedModels: Array.isArray(subagentRaw.allowedModels) ? subagentRaw.allowedModels.map((model) => normalizeOptionalString(model)).filter((model) => Boolean(model)) : void 0
+    } : void 0;
+    const normalizedSubagent = subagent && (typeof subagent.allowModelOverride === "boolean" || subagent.hasAllowedModelsConfig || Array.isArray(subagent.allowedModels) && subagent.allowedModels.length > 0) ? {
+      ...typeof subagent.allowModelOverride === "boolean" ? { allowModelOverride: subagent.allowModelOverride } : {},
+      ...subagent.hasAllowedModelsConfig ? { hasAllowedModelsConfig: true } : {},
+      ...Array.isArray(subagent.allowedModels) && subagent.allowedModels.length > 0 ? { allowedModels: subagent.allowedModels } : {}
+    } : void 0;
+    normalized[normalizedKey] = {
+      ...normalized[normalizedKey],
+      enabled: typeof entry.enabled === "boolean" ? entry.enabled : normalized[normalizedKey]?.enabled,
+      hooks: normalizedHooks ?? normalized[normalizedKey]?.hooks,
+      subagent: normalizedSubagent ?? normalized[normalizedKey]?.subagent,
+      config: "config" in entry ? entry.config : normalized[normalizedKey]?.config
+    };
+  }
+  return normalized;
+}
+function normalizePluginsConfigWithResolver$1(config, normalizePluginId = identityNormalizePluginId) {
+  const memorySlot = normalizeSlotValue(config?.slots?.memory);
+  return {
+    enabled: config?.enabled !== false,
+    allow: normalizeList(config?.allow, normalizePluginId),
+    deny: normalizeList(config?.deny, normalizePluginId),
+    loadPaths: normalizeList(config?.load?.paths, identityNormalizePluginId),
+    slots: {
+      memory: memorySlot === void 0 ? defaultSlotIdForKey("memory") : memorySlot,
+      contextEngine: normalizeSlotValue(config?.slots?.contextEngine)
+    },
+    entries: normalizePluginEntries(config?.entries, normalizePluginId)
+  };
+}
+function normalizePluginsConfigWithResolver(config, normalizePluginId = identityNormalizePluginId) {
+  return normalizePluginsConfigWithResolver$1(config, normalizePluginId);
+}
+const pluginManifestRegistryCache = /* @__PURE__ */ new Map();
+const PLUGIN_ORIGIN_RANK = {
+  config: 0,
+  workspace: 1,
+  global: 2,
+  bundled: 3
+};
+const registryCache = pluginManifestRegistryCache;
+const DEFAULT_MANIFEST_CACHE_MS = 1e3;
+function listContractValues(plugin, contract) {
+  return plugin.contracts?.[contract] ?? [];
+}
+function resolveManifestContractOwnerPluginId(params) {
+  const normalizedValue = normalizeOptionalLowercaseString(params.value);
+  if (!normalizedValue) return;
+  return loadPluginManifestRegistry({
+    config: params.config,
+    workspaceDir: params.workspaceDir,
+    env: params.env
+  }).plugins.find((plugin) => (!params.origin || plugin.origin === params.origin) && listContractValues(plugin, params.contract).some((candidate) => normalizeOptionalLowercaseString(candidate) === normalizedValue))?.id;
+}
+function resolveManifestCacheMs(env) {
+  const raw = env.OPENCLAW_PLUGIN_MANIFEST_CACHE_MS?.trim();
+  if (raw === "" || raw === "0") return 0;
+  if (!raw) return DEFAULT_MANIFEST_CACHE_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed)) return DEFAULT_MANIFEST_CACHE_MS;
+  return Math.max(0, parsed);
+}
+function shouldUseManifestCache(env) {
+  if (env.OPENCLAW_DISABLE_PLUGIN_MANIFEST_CACHE?.trim()) return false;
+  return resolveManifestCacheMs(env) > 0;
+}
+function buildCacheKey(params) {
+  const { roots, loadPaths } = resolvePluginCacheInputs({
+    workspaceDir: params.workspaceDir,
+    loadPaths: params.plugins.loadPaths,
+    env: params.env
+  });
+  return `${roots.workspace ?? ""}::${roots.global}::${roots.stock ?? ""}::${resolveCompatibilityHostVersion(params.env)}::${JSON.stringify(loadPaths)}`;
+}
+function safeStatMtimeMs(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function normalizePreferredPluginIds(raw) {
+  return normalizeOptionalTrimmedStringList(raw);
+}
+function mergePackageChannelMetaIntoChannelConfigs(params) {
+  const channelId = params.packageChannel?.id?.trim();
+  if (!channelId || !params.channelConfigs?.[channelId]) return params.channelConfigs;
+  const existing = params.channelConfigs[channelId];
+  const label = existing.label ?? normalizeOptionalString(params.packageChannel?.label) ?? "";
+  const description = existing.description ?? normalizeOptionalString(params.packageChannel?.blurb) ?? "";
+  const preferOver = existing.preferOver ?? normalizePreferredPluginIds(params.packageChannel?.preferOver);
+  return {
+    ...params.channelConfigs,
+    [channelId]: {
+      ...existing,
+      ...label ? { label } : {},
+      ...description ? { description } : {},
+      ...preferOver?.length ? { preferOver } : {}
+    }
+  };
+}
+function buildRecord(params) {
+  const channelConfigs = mergePackageChannelMetaIntoChannelConfigs({
+    channelConfigs: params.manifest.channelConfigs,
+    packageChannel: params.candidate.packageManifest?.channel
+  });
+  return {
+    id: params.manifest.id,
+    name: normalizeOptionalString(params.manifest.name) ?? params.candidate.packageName,
+    description: normalizeOptionalString(params.manifest.description) ?? params.candidate.packageDescription,
+    version: normalizeOptionalString(params.manifest.version) ?? params.candidate.packageVersion,
+    enabledByDefault: params.manifest.enabledByDefault === true ? true : void 0,
+    autoEnableWhenConfiguredProviders: params.manifest.autoEnableWhenConfiguredProviders,
+    legacyPluginIds: params.manifest.legacyPluginIds,
+    format: params.candidate.format ?? "openclaw",
+    bundleFormat: params.candidate.bundleFormat,
+    kind: params.manifest.kind,
+    channels: params.manifest.channels ?? [],
+    providers: params.manifest.providers ?? [],
+    providerDiscoverySource: params.manifest.providerDiscoveryEntry ? path.resolve(params.candidate.rootDir, params.manifest.providerDiscoveryEntry) : void 0,
+    modelSupport: params.manifest.modelSupport,
+    cliBackends: params.manifest.cliBackends ?? [],
+    commandAliases: params.manifest.commandAliases,
+    providerAuthEnvVars: params.manifest.providerAuthEnvVars,
+    providerAuthAliases: params.manifest.providerAuthAliases,
+    channelEnvVars: params.manifest.channelEnvVars,
+    providerAuthChoices: params.manifest.providerAuthChoices,
+    activation: params.manifest.activation,
+    setup: params.manifest.setup,
+    skills: params.manifest.skills ?? [],
+    settingsFiles: [],
+    hooks: [],
+    origin: params.candidate.origin,
+    workspaceDir: params.candidate.workspaceDir,
+    rootDir: params.candidate.rootDir,
+    source: params.candidate.source,
+    setupSource: params.candidate.setupSource,
+    startupDeferConfiguredChannelFullLoadUntilAfterListen: params.candidate.packageManifest?.startup?.deferConfiguredChannelFullLoadUntilAfterListen === true,
+    manifestPath: params.manifestPath,
+    schemaCacheKey: params.schemaCacheKey,
+    configSchema: params.configSchema,
+    configUiHints: params.manifest.uiHints,
+    contracts: params.manifest.contracts,
+    configContracts: params.manifest.configContracts,
+    channelConfigs,
+    ...params.candidate.packageManifest?.channel?.id ? { channelCatalogMeta: {
+      id: params.candidate.packageManifest.channel.id,
+      ...typeof params.candidate.packageManifest.channel.label === "string" ? { label: params.candidate.packageManifest.channel.label } : {},
+      ...typeof params.candidate.packageManifest.channel.blurb === "string" ? { blurb: params.candidate.packageManifest.channel.blurb } : {},
+      ...params.candidate.packageManifest.channel.preferOver ? { preferOver: params.candidate.packageManifest.channel.preferOver } : {}
+    } } : {}
+  };
+}
+function buildBundleRecord(params) {
+  return {
+    id: params.manifest.id,
+    name: normalizeOptionalString(params.manifest.name) ?? params.candidate.idHint,
+    description: normalizeOptionalString(params.manifest.description),
+    version: normalizeOptionalString(params.manifest.version),
+    format: "bundle",
+    bundleFormat: params.candidate.bundleFormat,
+    bundleCapabilities: params.manifest.capabilities,
+    channels: [],
+    providers: [],
+    cliBackends: [],
+    skills: params.manifest.skills ?? [],
+    settingsFiles: params.manifest.settingsFiles ?? [],
+    hooks: params.manifest.hooks ?? [],
+    origin: params.candidate.origin,
+    workspaceDir: params.candidate.workspaceDir,
+    rootDir: params.candidate.rootDir,
+    source: params.candidate.source,
+    manifestPath: params.manifestPath,
+    schemaCacheKey: void 0,
+    configSchema: void 0,
+    configUiHints: void 0,
+    configContracts: void 0,
+    channelConfigs: void 0
+  };
+}
+function matchesInstalledPluginRecord(params) {
+  if (params.candidate.origin !== "global") return false;
+  const record = params.config?.plugins?.installs?.[params.pluginId];
+  if (!record) return false;
+  const candidateSource = resolveUserPath(params.candidate.source, params.env);
+  const trackedPaths = [record.installPath, record.sourcePath].filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => resolveUserPath(entry, params.env));
+  if (trackedPaths.length === 0) return false;
+  return trackedPaths.some((trackedPath) => {
+    return candidateSource === trackedPath || isPathInside(trackedPath, candidateSource);
+  });
+}
+function resolveDuplicatePrecedenceRank(params) {
+  if (params.candidate.origin === "config") return 0;
+  if (params.candidate.origin === "global" && matchesInstalledPluginRecord({
+    pluginId: params.pluginId,
+    candidate: params.candidate,
+    config: params.config,
+    env: params.env
+  })) return 1;
+  if (params.candidate.origin === "bundled") return 2;
+  if (params.candidate.origin === "workspace") return 3;
+  return 4;
+}
+function loadPluginManifestRegistry(params = {}) {
+  const config = params.config ?? {};
+  const normalized = normalizePluginsConfigWithResolver(config.plugins);
+  const env = params.env ?? process.env;
+  const cacheKey = buildCacheKey({
+    workspaceDir: params.workspaceDir,
+    plugins: normalized,
+    env
+  });
+  const cacheEnabled = params.cache !== false && shouldUseManifestCache(env);
+  if (cacheEnabled) {
+    const cached = registryCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) return cached.registry;
+  }
+  const discovery = params.candidates ? {
+    candidates: params.candidates,
+    diagnostics: params.diagnostics ?? []
+  } : discoverOpenClawPlugins({
+    workspaceDir: params.workspaceDir,
+    extraPaths: normalized.loadPaths,
+    cache: params.cache,
+    env
+  });
+  const diagnostics = [...discovery.diagnostics];
+  const candidates = discovery.candidates;
+  const records = [];
+  const seenIds = /* @__PURE__ */ new Map();
+  const realpathCache = /* @__PURE__ */ new Map();
+  const currentHostVersion = resolveCompatibilityHostVersion(env);
+  for (const candidate of candidates) {
+    const rejectHardlinks = candidate.origin !== "bundled";
+    const isBundleRecord = (candidate.format ?? "openclaw") === "bundle";
+    const manifestRes = candidate.origin === "bundled" && candidate.bundledManifest && candidate.bundledManifestPath ? {
+      ok: true,
+      manifest: candidate.bundledManifest,
+      manifestPath: candidate.bundledManifestPath
+    } : isBundleRecord && candidate.bundleFormat ? loadBundleManifest({
+      rootDir: candidate.rootDir,
+      bundleFormat: candidate.bundleFormat,
+      rejectHardlinks
+    }) : loadPluginManifest(candidate.rootDir, rejectHardlinks);
+    if (!manifestRes.ok) {
+      diagnostics.push({
+        level: "error",
+        message: manifestRes.error,
+        source: manifestRes.manifestPath
+      });
+      continue;
+    }
+    const manifest = manifestRes.manifest;
+    const minHostVersionCheck = checkMinHostVersion({
+      currentVersion: currentHostVersion,
+      minHostVersion: candidate.packageManifest?.install?.minHostVersion
+    });
+    if (!minHostVersionCheck.ok) {
+      const packageManifestSource = path.join(candidate.packageDir ?? candidate.rootDir, "package.json");
+      diagnostics.push({
+        level: minHostVersionCheck.kind === "unknown_host_version" ? "warn" : "error",
+        pluginId: manifest.id,
+        source: packageManifestSource,
+        message: minHostVersionCheck.kind === "invalid" ? `plugin manifest invalid | ${minHostVersionCheck.error}` : minHostVersionCheck.kind === "unknown_host_version" ? `plugin requires OpenClaw >=${minHostVersionCheck.requirement.minimumLabel}, but this host version could not be determined; skipping load` : `plugin requires OpenClaw >=${minHostVersionCheck.requirement.minimumLabel}, but this host is ${minHostVersionCheck.currentVersion}; skipping load`
+      });
+      continue;
+    }
+    const configSchema = "configSchema" in manifest ? manifest.configSchema : void 0;
+    const schemaCacheKey = (() => {
+      if (!configSchema) return;
+      const manifestMtime = safeStatMtimeMs(manifestRes.manifestPath);
+      return manifestMtime ? `${manifestRes.manifestPath}:${manifestMtime}` : manifestRes.manifestPath;
+    })();
+    const existing = seenIds.get(manifest.id);
+    if (existing) {
+      const samePath = existing.candidate.rootDir === candidate.rootDir;
+      if ((() => {
+        if (samePath) return true;
+        const existingReal = safeRealpathSync(existing.candidate.rootDir, realpathCache);
+        const candidateReal = safeRealpathSync(candidate.rootDir, realpathCache);
+        return Boolean(existingReal && candidateReal && existingReal === candidateReal);
+      })()) {
+        if (PLUGIN_ORIGIN_RANK[candidate.origin] < PLUGIN_ORIGIN_RANK[existing.candidate.origin]) {
+          records[existing.recordIndex] = isBundleRecord ? buildBundleRecord({
+            manifest,
+            candidate,
+            manifestPath: manifestRes.manifestPath
+          }) : buildRecord({
+            manifest,
+            candidate,
+            manifestPath: manifestRes.manifestPath,
+            schemaCacheKey,
+            configSchema
+          });
+          seenIds.set(manifest.id, {
+            candidate,
+            recordIndex: existing.recordIndex
+          });
+        }
+        continue;
+      }
+      diagnostics.push({
+        level: "warn",
+        pluginId: manifest.id,
+        source: candidate.source,
+        message: resolveDuplicatePrecedenceRank({
+          pluginId: manifest.id,
+          candidate,
+          config,
+          env
+        }) < resolveDuplicatePrecedenceRank({
+          pluginId: manifest.id,
+          candidate: existing.candidate,
+          config,
+          env
+        }) ? `duplicate plugin id detected; ${existing.candidate.origin} plugin will be overridden by ${candidate.origin} plugin (${candidate.source})` : `duplicate plugin id detected; ${candidate.origin} plugin will be overridden by ${existing.candidate.origin} plugin (${candidate.source})`
+      });
+    } else seenIds.set(manifest.id, {
+      candidate,
+      recordIndex: records.length
+    });
+    records.push(isBundleRecord ? buildBundleRecord({
+      manifest,
+      candidate,
+      manifestPath: manifestRes.manifestPath
+    }) : buildRecord({
+      manifest,
+      candidate,
+      manifestPath: manifestRes.manifestPath,
+      schemaCacheKey,
+      configSchema
+    }));
+  }
+  const registry = {
+    plugins: records,
+    diagnostics
+  };
+  if (cacheEnabled) {
+    const ttl = resolveManifestCacheMs(env);
+    if (ttl > 0) registryCache.set(cacheKey, {
+      expiresAt: Date.now() + ttl,
+      registry
+    });
+  }
+  return registry;
+}
+export {
+  normalizePluginsConfigWithResolver$1 as f,
+  resolveManifestContractOwnerPluginId as n,
+  normalizePluginsConfigWithResolver as s,
+  loadPluginManifestRegistry as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/map-size-DhG4ditB.js

@@ -0,0 +1,15 @@
+function pruneMapToMaxSize(map, maxSize) {
+  const limit = Math.max(0, Math.floor(maxSize));
+  if (limit <= 0) {
+    map.clear();
+    return;
+  }
+  while (map.size > limit) {
+    const oldest = map.keys().next();
+    if (oldest.done) break;
+    map.delete(oldest.value);
+  }
+}
+export {
+  pruneMapToMaxSize as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/message-channel-DXsjCySM.js

@@ -0,0 +1,32 @@
+import "./ids-By7Nkc8R.js";
+import "./registry-DE4nHTjg.js";
+const GATEWAY_CLIENT_IDS = {
+  WEBCHAT_UI: "webchat-ui",
+  CONTROL_UI: "openclaw-control-ui",
+  TUI: "openclaw-tui",
+  WEBCHAT: "webchat",
+  CLI: "cli",
+  GATEWAY_CLIENT: "gateway-client",
+  MACOS_APP: "openclaw-macos",
+  IOS_APP: "openclaw-ios",
+  ANDROID_APP: "openclaw-android",
+  NODE_HOST: "node-host",
+  TEST: "test",
+  FINGERPRINT: "fingerprint",
+  PROBE: "openclaw-probe"
+};
+const GATEWAY_CLIENT_MODES = {
+  WEBCHAT: "webchat",
+  CLI: "cli",
+  UI: "ui",
+  BACKEND: "backend",
+  NODE: "node",
+  PROBE: "probe",
+  TEST: "test"
+};
+new Set(Object.values(GATEWAY_CLIENT_IDS));
+new Set(Object.values(GATEWAY_CLIENT_MODES));
+export {
+  GATEWAY_CLIENT_MODES as h,
+  GATEWAY_CLIENT_IDS as m
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/mime-BjR-Aw-Q.js

@@ -0,0 +1,42 @@
+import "node:path";
+const EXT_BY_MIME = {
+  "image/heic": ".heic",
+  "image/heif": ".heif",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "audio/ogg": ".ogg",
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav",
+  "audio/flac": ".flac",
+  "audio/aac": ".aac",
+  "audio/opus": ".opus",
+  "audio/x-m4a": ".m4a",
+  "audio/mp4": ".m4a",
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "application/pdf": ".pdf",
+  "application/json": ".json",
+  "application/zip": ".zip",
+  "application/gzip": ".gz",
+  "application/x-tar": ".tar",
+  "application/x-7z-compressed": ".7z",
+  "application/vnd.rar": ".rar",
+  "application/msword": ".doc",
+  "application/vnd.ms-excel": ".xls",
+  "application/vnd.ms-powerpoint": ".ppt",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+  "text/csv": ".csv",
+  "text/plain": ".txt",
+  "text/markdown": ".md",
+  "text/html": ".html",
+  "text/xml": ".xml",
+  "text/css": ".css",
+  "application/xml": ".xml"
+};
+({
+  ...Object.fromEntries(Object.entries(EXT_BY_MIME).map(([mime, ext]) => [ext, mime]))
+});

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/min-host-version-CmguvhGB.js

@@ -0,0 +1,49 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import { a as parseSemver, n as isAtLeast } from "./runtime-guard-DqVOvWAZ.js";
+const MIN_HOST_VERSION_FORMAT = 'openclaw.install.minHostVersion must use a semver floor in the form ">=x.y.z"';
+const MIN_HOST_VERSION_RE = /^>=(\d+)\.(\d+)\.(\d+)$/;
+function parseMinHostVersionRequirement(raw) {
+  if (typeof raw !== "string") return null;
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(MIN_HOST_VERSION_RE);
+  if (!match) return null;
+  const minimumLabel = `${match[1]}.${match[2]}.${match[3]}`;
+  if (!parseSemver(minimumLabel)) return null;
+  return {
+    raw: trimmed,
+    minimumLabel
+  };
+}
+function checkMinHostVersion(params) {
+  if (params.minHostVersion === void 0) return {
+    ok: true,
+    requirement: null
+  };
+  const requirement = parseMinHostVersionRequirement(params.minHostVersion);
+  if (!requirement) return {
+    ok: false,
+    kind: "invalid",
+    error: MIN_HOST_VERSION_FORMAT
+  };
+  const currentVersion = normalizeOptionalString(params.currentVersion) || "unknown";
+  const currentSemver = parseSemver(currentVersion);
+  if (!currentSemver) return {
+    ok: false,
+    kind: "unknown_host_version",
+    requirement
+  };
+  if (!isAtLeast(currentSemver, parseSemver(requirement.minimumLabel))) return {
+    ok: false,
+    kind: "incompatible",
+    requirement,
+    currentVersion
+  };
+  return {
+    ok: true,
+    requirement
+  };
+}
+export {
+  checkMinHostVersion as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/model-auth-markers-YVQDqG1J.js

@@ -0,0 +1,8 @@
+import { a as resolveProviderAuthEnvVarCandidates } from "./provider-env-vars-DDfJbkrO.js";
+function resolveProviderEnvApiKeyCandidates(params) {
+  return resolveProviderAuthEnvVarCandidates(params);
+}
+resolveProviderEnvApiKeyCandidates();
+export {
+  resolveProviderEnvApiKeyCandidates as _
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/model-selection-cli-U7l5Ifek.js

@@ -0,0 +1,14 @@
+import "./subsystem-BHv2zSx6.js";
+import "./ids-By7Nkc8R.js";
+import "./utils-DGFSjtQF.js";
+import "./version-b06Uhxnq.js";
+import "node:fs";
+import "node:path";
+import "node:os";
+import "node:fs/promises";
+import "./bundled-dir-Cq5y_NKM.js";
+import "node:process";
+import { createRequire } from "node:module";
+createRequire(import.meta.url);
+createRequire(import.meta.url);
+createRequire(import.meta.url);

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/models-config-B-YHRI3g.js

@@ -0,0 +1,40 @@
+import "./redact-D4nea1HF.js";
+import "./subsystem-BHv2zSx6.js";
+import "./utils-DGFSjtQF.js";
+import "./host-env-security-B-Ebh6At.js";
+import "./paths-LCYGfrV7.js";
+import "node:fs";
+import path from "node:path";
+import "../node_modules/dotenv/lib/main.js";
+import "./io-DDkf_FUu.js";
+import "./zod-schema.core-BrzjtZhM.js";
+import "./bundled-plugin-metadata-BJMD48hn.js";
+import "./bundled-dir-Cq5y_NKM.js";
+import "./file-lock-D016H3tC.js";
+import "node:crypto";
+import "./provider-runtime-O-n0cjZo.js";
+import "node:child_process";
+import "./ids-By7Nkc8R.js";
+import "./version-b06Uhxnq.js";
+import "node:os";
+import "node:fs/promises";
+import "node:process";
+import "./registry-DE4nHTjg.js";
+import "./bundled-Cuj8sKt6.js";
+import "./setup-registry-BPL6c_Zk.js";
+import "./model-auth-markers-YVQDqG1J.js";
+import "./workspace-oVBetctb.js";
+import "./model-selection-cli-U7l5Ifek.js";
+import "./provider-env-vars-DDfJbkrO.js";
+import "./facade-loader-B83leEeb.js";
+import "node:url";
+const MODELS_JSON_STATE_KEY = Symbol.for("openclaw.modelsJsonState");
+(() => {
+  const globalState = globalThis;
+  if (!globalState[MODELS_JSON_STATE_KEY]) globalState[MODELS_JSON_STATE_KEY] = {
+    writeLocks: /* @__PURE__ */ new Map(),
+    readyCache: /* @__PURE__ */ new Map()
+  };
+  return globalState[MODELS_JSON_STATE_KEY];
+})();
+path.resolve(import.meta.dirname, "../..");

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/native-command-session-targets-BW3SPx-T.js

@@ -0,0 +1,11 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+function resolveNativeCommandSessionTargets(params) {
+  const rawSessionKey = params.boundSessionKey ?? `agent:${params.agentId}:${params.sessionPrefix}:${params.userId}`;
+  return {
+    sessionKey: params.lowercaseSessionKey ? normalizeLowercaseStringOrEmpty(rawSessionKey) : rawSessionKey,
+    commandTargetSessionKey: params.boundSessionKey ?? params.targetSessionKey
+  };
+}
+export {
+  resolveNativeCommandSessionTargets as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/network-mode-D3yzFBsD.js

@@ -0,0 +1,15 @@
+import { o as normalizeOptionalLowercaseString } from "./string-coerce-BUSzWgUA.js";
+function normalizeNetworkMode(network) {
+  return normalizeOptionalLowercaseString(network) || void 0;
+}
+function getBlockedNetworkModeReason(params) {
+  const normalized = normalizeNetworkMode(params.network);
+  if (!normalized) return null;
+  if (normalized === "host") return "host";
+  if (normalized.startsWith("container:") && params.allowContainerNamespaceJoin !== true) return "container_namespace_join";
+  return null;
+}
+export {
+  normalizeNetworkMode as r,
+  getBlockedNetworkModeReason as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/node-require-DvwmVoHm.js

@@ -0,0 +1,14 @@
+function resolveNodeRequireFromMeta(metaUrl) {
+  const getBuiltinModule = process.getBuiltinModule;
+  if (typeof getBuiltinModule !== "function") return null;
+  try {
+    const moduleNamespace = getBuiltinModule("module");
+    const createRequire = typeof moduleNamespace.createRequire === "function" ? moduleNamespace.createRequire : null;
+    return createRequire ? createRequire(metaUrl) : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  resolveNodeRequireFromMeta as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/node-sqlite-FGjwOqiS.js

@@ -0,0 +1,3 @@
+import "./redact-D4nea1HF.js";
+import { createRequire } from "node:module";
+createRequire(import.meta.url);