@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/openclaw-root-BNWw3cXT.js

@@ -0,0 +1,69 @@
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import "node:fs/promises";
+const CORE_PACKAGE_NAMES = /* @__PURE__ */ new Set(["openclaw"]);
+function parsePackageName(raw) {
+  const parsed = JSON.parse(raw);
+  return typeof parsed.name === "string" ? parsed.name : null;
+}
+function readPackageNameSync(dir) {
+  try {
+    return parsePackageName(fs.readFileSync(path.join(dir, "package.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function findPackageRootSync(startDir, maxDepth = 12) {
+  for (const current of iterAncestorDirs(startDir, maxDepth)) {
+    const name = readPackageNameSync(current);
+    if (name && CORE_PACKAGE_NAMES.has(name)) return current;
+  }
+  return null;
+}
+function* iterAncestorDirs(startDir, maxDepth) {
+  let current = path.resolve(startDir);
+  for (let i = 0; i < maxDepth; i += 1) {
+    yield current;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+}
+function candidateDirsFromArgv1(argv1) {
+  const normalized = path.resolve(argv1);
+  const candidates = [path.dirname(normalized)];
+  try {
+    const resolved = fs.realpathSync(normalized);
+    if (resolved !== normalized) candidates.push(path.dirname(resolved));
+  } catch {
+  }
+  const parts = normalized.split(path.sep);
+  const binIndex = parts.lastIndexOf(".bin");
+  if (binIndex > 0 && parts[binIndex - 1] === "node_modules") {
+    const binName = path.basename(normalized);
+    const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
+    candidates.push(path.join(nodeModulesDir, binName));
+  }
+  return candidates;
+}
+function resolveOpenClawPackageRootSync(opts) {
+  for (const candidate of buildCandidates(opts)) {
+    const found = findPackageRootSync(candidate);
+    if (found) return found;
+  }
+  return null;
+}
+function buildCandidates(opts) {
+  const candidates = [];
+  if (opts.moduleUrl) try {
+    candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));
+  } catch {
+  }
+  if (opts.argv1) candidates.push(...candidateDirsFromArgv1(opts.argv1));
+  if (opts.cwd) candidates.push(opts.cwd);
+  return candidates;
+}
+export {
+  resolveOpenClawPackageRootSync as n
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/order-6WHL2fZu.js

@@ -0,0 +1,26 @@
+import "./subsystem-BHv2zSx6.js";
+import "./utils-DGFSjtQF.js";
+import "./provider-env-vars-DDfJbkrO.js";
+import "./redact-D4nea1HF.js";
+import "./paths-LCYGfrV7.js";
+import "./file-lock-D016H3tC.js";
+import "node:fs";
+import "node:path";
+import "node:crypto";
+import "./provider-runtime-O-n0cjZo.js";
+import "node:child_process";
+import "./workspace-oVBetctb.js";
+import "./model-selection-cli-U7l5Ifek.js";
+const FAILURE_REASON_PRIORITY = [
+  "auth_permanent",
+  "auth",
+  "billing",
+  "format",
+  "model_not_found",
+  "overloaded",
+  "timeout",
+  "rate_limit",
+  "unknown"
+];
+new Set(FAILURE_REASON_PRIORITY);
+new Map(FAILURE_REASON_PRIORITY.map((reason, index) => [reason, index]));

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/parse-duration-amE_QFsj.js

@@ -0,0 +1,42 @@
+import { i as normalizeLowercaseStringOrEmpty, s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+const DURATION_MULTIPLIERS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseDurationMs(raw, opts) {
+  const trimmed = normalizeLowercaseStringOrEmpty(normalizeOptionalString(raw) ?? "");
+  if (!trimmed) throw new Error("invalid duration (empty)");
+  const single = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/.exec(trimmed);
+  if (single) {
+    const value = Number(single[1]);
+    if (!Number.isFinite(value) || value < 0) throw new Error(`invalid duration: ${raw}`);
+    const unit = single[2] ?? opts?.defaultUnit ?? "ms";
+    const ms2 = Math.round(value * DURATION_MULTIPLIERS[unit]);
+    if (!Number.isFinite(ms2)) throw new Error(`invalid duration: ${raw}`);
+    return ms2;
+  }
+  let totalMs = 0;
+  let consumed = 0;
+  for (const match of trimmed.matchAll(/(\d+(?:\.\d+)?)(ms|s|m|h|d)/g)) {
+    const [full, valueRaw, unitRaw] = match;
+    const index = match.index ?? -1;
+    if (!full || !valueRaw || !unitRaw || index < 0) throw new Error(`invalid duration: ${raw}`);
+    if (index !== consumed) throw new Error(`invalid duration: ${raw}`);
+    const value = Number(valueRaw);
+    if (!Number.isFinite(value) || value < 0) throw new Error(`invalid duration: ${raw}`);
+    const multiplier = DURATION_MULTIPLIERS[unitRaw];
+    if (!multiplier) throw new Error(`invalid duration: ${raw}`);
+    totalMs += value * multiplier;
+    consumed += full.length;
+  }
+  if (consumed !== trimmed.length || consumed === 0) throw new Error(`invalid duration: ${raw}`);
+  const ms = Math.round(totalMs);
+  if (!Number.isFinite(ms)) throw new Error(`invalid duration: ${raw}`);
+  return ms;
+}
+export {
+  parseDurationMs as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/path-safety-CKqzLERR.js

@@ -0,0 +1,308 @@
+import { s as normalizeOptionalString, i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+import { l as isRecord } from "./utils-DGFSjtQF.js";
+import { c as isPathInside$1 } from "./file-identity-sp9axE-E.js";
+import { i as openBoundaryFileSync, n as matchBoundaryFileOpenFailure } from "./boundary-file-read-BymsBHso.js";
+import { t as DEFAULT_PLUGIN_ENTRY_CANDIDATES } from "./manifest-CjPIwluH.js";
+import fs from "node:fs";
+import path from "node:path";
+import lib from "../node_modules/json5/dist/index.js";
+const CODEX_BUNDLE_MANIFEST_RELATIVE_PATH = ".codex-plugin/plugin.json";
+const CLAUDE_BUNDLE_MANIFEST_RELATIVE_PATH = ".claude-plugin/plugin.json";
+const CURSOR_BUNDLE_MANIFEST_RELATIVE_PATH = ".cursor-plugin/plugin.json";
+function normalizePathList(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? [trimmed] : [];
+  }
+  if (!Array.isArray(value)) return [];
+  return value.map((entry) => normalizeOptionalString(entry)).filter((entry) => Boolean(entry));
+}
+function normalizeBundlePathList(value) {
+  return Array.from(new Set(normalizePathList(value)));
+}
+function mergeBundlePathLists(...groups) {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const group of groups) for (const entry of group) {
+    if (seen.has(entry)) continue;
+    seen.add(entry);
+    merged.push(entry);
+  }
+  return merged;
+}
+function hasInlineCapabilityValue(value) {
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (isRecord(value)) return Object.keys(value).length > 0;
+  return value === true;
+}
+function slugifyPluginId(raw, rootDir) {
+  const fallback = path.basename(rootDir);
+  return (normalizeLowercaseStringOrEmpty(raw) || normalizeLowercaseStringOrEmpty(fallback)).replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "") || "bundle-plugin";
+}
+function loadBundleManifestFile(params) {
+  const manifestPath = path.join(params.rootDir, params.manifestRelativePath);
+  const opened = openBoundaryFileSync({
+    absolutePath: manifestPath,
+    rootPath: params.rootDir,
+    boundaryLabel: "plugin root",
+    rejectHardlinks: params.rejectHardlinks
+  });
+  if (!opened.ok) return matchBoundaryFileOpenFailure(opened, {
+    path: () => {
+      if (params.allowMissing) return {
+        ok: true,
+        raw: {},
+        manifestPath
+      };
+      return {
+        ok: false,
+        error: `plugin manifest not found: ${manifestPath}`,
+        manifestPath
+      };
+    },
+    fallback: (failure) => ({
+      ok: false,
+      error: `unsafe plugin manifest path: ${manifestPath} (${failure.reason})`,
+      manifestPath
+    })
+  });
+  try {
+    const raw = lib.parse(fs.readFileSync(opened.fd, "utf-8"));
+    if (!isRecord(raw)) return {
+      ok: false,
+      error: "plugin manifest must be an object",
+      manifestPath
+    };
+    return {
+      ok: true,
+      raw,
+      manifestPath
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: `failed to parse plugin manifest: ${String(err)}`,
+      manifestPath
+    };
+  } finally {
+    fs.closeSync(opened.fd);
+  }
+}
+function resolveCodexSkillDirs(raw, rootDir) {
+  const declared = normalizeBundlePathList(raw.skills);
+  if (declared.length > 0) return declared;
+  return fs.existsSync(path.join(rootDir, "skills")) ? ["skills"] : [];
+}
+function resolveCodexHookDirs(raw, rootDir) {
+  const declared = normalizeBundlePathList(raw.hooks);
+  if (declared.length > 0) return declared;
+  return fs.existsSync(path.join(rootDir, "hooks")) ? ["hooks"] : [];
+}
+function resolveCursorSkillsRootDirs(raw, rootDir) {
+  const declared = normalizeBundlePathList(raw.skills);
+  return mergeBundlePathLists(fs.existsSync(path.join(rootDir, "skills")) ? ["skills"] : [], declared);
+}
+function resolveCursorCommandRootDirs(raw, rootDir) {
+  const declared = normalizeBundlePathList(raw.commands);
+  return mergeBundlePathLists(fs.existsSync(path.join(rootDir, ".cursor", "commands")) ? [".cursor/commands"] : [], declared);
+}
+function resolveCursorSkillDirs(raw, rootDir) {
+  return mergeBundlePathLists(resolveCursorSkillsRootDirs(raw, rootDir), resolveCursorCommandRootDirs(raw, rootDir));
+}
+function resolveCursorAgentDirs(raw, rootDir) {
+  const declared = normalizeBundlePathList(raw.subagents ?? raw.agents);
+  return mergeBundlePathLists(fs.existsSync(path.join(rootDir, ".cursor", "agents")) ? [".cursor/agents"] : [], declared);
+}
+function hasCursorHookCapability(raw, rootDir) {
+  return hasInlineCapabilityValue(raw.hooks) || fs.existsSync(path.join(rootDir, ".cursor", "hooks.json"));
+}
+function hasCursorRulesCapability(raw, rootDir) {
+  return hasInlineCapabilityValue(raw.rules) || fs.existsSync(path.join(rootDir, ".cursor", "rules"));
+}
+function hasCursorMcpCapability(raw, rootDir) {
+  return hasInlineCapabilityValue(raw.mcpServers) || fs.existsSync(path.join(rootDir, ".mcp.json"));
+}
+function resolveClaudeComponentPaths(raw, key, rootDir, defaults) {
+  const declared = normalizeBundlePathList(raw[key]);
+  return mergeBundlePathLists(defaults.filter((candidate) => fs.existsSync(path.join(rootDir, candidate))), declared);
+}
+function resolveClaudeSkillsRootDirs(raw, rootDir) {
+  return resolveClaudeComponentPaths(raw, "skills", rootDir, ["skills"]);
+}
+function resolveClaudeCommandRootDirs(raw, rootDir) {
+  return resolveClaudeComponentPaths(raw, "commands", rootDir, ["commands"]);
+}
+function resolveClaudeSkillDirs(raw, rootDir) {
+  return mergeBundlePathLists(resolveClaudeSkillsRootDirs(raw, rootDir), resolveClaudeCommandRootDirs(raw, rootDir), resolveClaudeAgentDirs(raw, rootDir), resolveClaudeOutputStylePaths(raw, rootDir));
+}
+function resolveClaudeAgentDirs(raw, rootDir) {
+  return resolveClaudeComponentPaths(raw, "agents", rootDir, ["agents"]);
+}
+function resolveClaudeHookPaths(raw, rootDir) {
+  return resolveClaudeComponentPaths(raw, "hooks", rootDir, ["hooks/hooks.json"]);
+}
+function resolveClaudeMcpPaths(raw, rootDir) {
+  return resolveClaudeComponentPaths(raw, "mcpServers", rootDir, [".mcp.json"]);
+}
+function resolveClaudeLspPaths(raw, rootDir) {
+  return resolveClaudeComponentPaths(raw, "lspServers", rootDir, [".lsp.json"]);
+}
+function resolveClaudeOutputStylePaths(raw, rootDir) {
+  return resolveClaudeComponentPaths(raw, "outputStyles", rootDir, ["output-styles"]);
+}
+function resolveClaudeSettingsFiles(_raw, rootDir) {
+  return fs.existsSync(path.join(rootDir, "settings.json")) ? ["settings.json"] : [];
+}
+function hasClaudeHookCapability(raw, rootDir) {
+  return hasInlineCapabilityValue(raw.hooks) || resolveClaudeHookPaths(raw, rootDir).length > 0;
+}
+function buildCodexCapabilities(raw, rootDir) {
+  const capabilities = [];
+  if (resolveCodexSkillDirs(raw, rootDir).length > 0) capabilities.push("skills");
+  if (resolveCodexHookDirs(raw, rootDir).length > 0) capabilities.push("hooks");
+  if (hasInlineCapabilityValue(raw.mcpServers) || fs.existsSync(path.join(rootDir, ".mcp.json"))) capabilities.push("mcpServers");
+  if (hasInlineCapabilityValue(raw.apps) || fs.existsSync(path.join(rootDir, ".app.json"))) capabilities.push("apps");
+  return capabilities;
+}
+function buildClaudeCapabilities(raw, rootDir) {
+  const capabilities = [];
+  if (resolveClaudeSkillDirs(raw, rootDir).length > 0) capabilities.push("skills");
+  if (resolveClaudeCommandRootDirs(raw, rootDir).length > 0) capabilities.push("commands");
+  if (resolveClaudeAgentDirs(raw, rootDir).length > 0) capabilities.push("agents");
+  if (hasClaudeHookCapability(raw, rootDir)) capabilities.push("hooks");
+  if (hasInlineCapabilityValue(raw.mcpServers) || resolveClaudeMcpPaths(raw, rootDir).length > 0) capabilities.push("mcpServers");
+  if (hasInlineCapabilityValue(raw.lspServers) || resolveClaudeLspPaths(raw, rootDir).length > 0) capabilities.push("lspServers");
+  if (hasInlineCapabilityValue(raw.outputStyles) || resolveClaudeOutputStylePaths(raw, rootDir).length > 0) capabilities.push("outputStyles");
+  if (resolveClaudeSettingsFiles(raw, rootDir).length > 0) capabilities.push("settings");
+  return capabilities;
+}
+function buildCursorCapabilities(raw, rootDir) {
+  const capabilities = [];
+  if (resolveCursorSkillDirs(raw, rootDir).length > 0) capabilities.push("skills");
+  if (resolveCursorCommandRootDirs(raw, rootDir).length > 0) capabilities.push("commands");
+  if (resolveCursorAgentDirs(raw, rootDir).length > 0) capabilities.push("agents");
+  if (hasCursorHookCapability(raw, rootDir)) capabilities.push("hooks");
+  if (hasCursorRulesCapability(raw, rootDir)) capabilities.push("rules");
+  if (hasCursorMcpCapability(raw, rootDir)) capabilities.push("mcpServers");
+  return capabilities;
+}
+function loadBundleManifest(params) {
+  const rejectHardlinks = params.rejectHardlinks ?? true;
+  const manifestRelativePath = params.bundleFormat === "codex" ? CODEX_BUNDLE_MANIFEST_RELATIVE_PATH : params.bundleFormat === "cursor" ? CURSOR_BUNDLE_MANIFEST_RELATIVE_PATH : CLAUDE_BUNDLE_MANIFEST_RELATIVE_PATH;
+  const loaded = loadBundleManifestFile({
+    rootDir: params.rootDir,
+    manifestRelativePath,
+    rejectHardlinks,
+    allowMissing: params.bundleFormat === "claude"
+  });
+  if (!loaded.ok) return loaded;
+  const raw = loaded.raw;
+  const interfaceRecord = isRecord(raw.interface) ? raw.interface : void 0;
+  const name = normalizeOptionalString(raw.name);
+  const description = normalizeOptionalString(raw.description) ?? normalizeOptionalString(raw.shortDescription) ?? normalizeOptionalString(interfaceRecord?.shortDescription);
+  const version = normalizeOptionalString(raw.version);
+  if (params.bundleFormat === "codex") {
+    const skills = resolveCodexSkillDirs(raw, params.rootDir);
+    const hooks = resolveCodexHookDirs(raw, params.rootDir);
+    return {
+      ok: true,
+      manifest: {
+        id: slugifyPluginId(name, params.rootDir),
+        name,
+        description,
+        version,
+        skills,
+        settingsFiles: [],
+        hooks,
+        bundleFormat: "codex",
+        capabilities: buildCodexCapabilities(raw, params.rootDir)
+      },
+      manifestPath: loaded.manifestPath
+    };
+  }
+  if (params.bundleFormat === "cursor") return {
+    ok: true,
+    manifest: {
+      id: slugifyPluginId(name, params.rootDir),
+      name,
+      description,
+      version,
+      skills: resolveCursorSkillDirs(raw, params.rootDir),
+      settingsFiles: [],
+      hooks: [],
+      bundleFormat: "cursor",
+      capabilities: buildCursorCapabilities(raw, params.rootDir)
+    },
+    manifestPath: loaded.manifestPath
+  };
+  return {
+    ok: true,
+    manifest: {
+      id: slugifyPluginId(name, params.rootDir),
+      name,
+      description,
+      version,
+      skills: resolveClaudeSkillDirs(raw, params.rootDir),
+      settingsFiles: resolveClaudeSettingsFiles(raw, params.rootDir),
+      hooks: resolveClaudeHookPaths(raw, params.rootDir),
+      bundleFormat: "claude",
+      capabilities: buildClaudeCapabilities(raw, params.rootDir)
+    },
+    manifestPath: loaded.manifestPath
+  };
+}
+function detectBundleManifestFormat(rootDir) {
+  if (fs.existsSync(path.join(rootDir, ".codex-plugin/plugin.json"))) return "codex";
+  if (fs.existsSync(path.join(rootDir, ".cursor-plugin/plugin.json"))) return "cursor";
+  if (fs.existsSync(path.join(rootDir, ".claude-plugin/plugin.json"))) return "claude";
+  if (fs.existsSync(path.join(rootDir, "openclaw.plugin.json"))) return null;
+  if (DEFAULT_PLUGIN_ENTRY_CANDIDATES.some((candidate) => fs.existsSync(path.join(rootDir, candidate)))) return null;
+  if ([
+    path.join(rootDir, "skills"),
+    path.join(rootDir, "commands"),
+    path.join(rootDir, "agents"),
+    path.join(rootDir, "hooks", "hooks.json"),
+    path.join(rootDir, ".mcp.json"),
+    path.join(rootDir, ".lsp.json"),
+    path.join(rootDir, "settings.json")
+  ].some((candidate) => fs.existsSync(candidate))) return "claude";
+  return null;
+}
+function isPathInside(baseDir, targetPath) {
+  return isPathInside$1(baseDir, targetPath);
+}
+function safeRealpathSync(targetPath, cache) {
+  const cached = cache?.get(targetPath);
+  if (cached) return cached;
+  try {
+    const resolved = fs.realpathSync(targetPath);
+    cache?.set(targetPath, resolved);
+    return resolved;
+  } catch {
+    return null;
+  }
+}
+function safeStatSync(targetPath) {
+  try {
+    return fs.statSync(targetPath);
+  } catch {
+    return null;
+  }
+}
+function formatPosixMode(mode) {
+  return (mode & 511).toString(8).padStart(3, "0");
+}
+export {
+  CLAUDE_BUNDLE_MANIFEST_RELATIVE_PATH as a,
+  detectBundleManifestFormat as c,
+  normalizeBundlePathList as d,
+  safeStatSync as i,
+  loadBundleManifest as l,
+  isPathInside as n,
+  CODEX_BUNDLE_MANIFEST_RELATIVE_PATH as o,
+  safeRealpathSync as r,
+  CURSOR_BUNDLE_MANIFEST_RELATIVE_PATH as s,
+  formatPosixMode as t,
+  mergeBundlePathLists as u
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/paths-LCYGfrV7.js

@@ -0,0 +1,95 @@
+import { r as resolveHomeRelativePath, o as resolveRequiredHomeDir } from "./home-dir-BEqRdfoa.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+function resolveIsNixMode(env = process.env) {
+  return env.OPENCLAW_NIX_MODE === "1";
+}
+resolveIsNixMode();
+const LEGACY_STATE_DIRNAMES = [".clawdbot"];
+const NEW_STATE_DIRNAME = ".openclaw";
+const CONFIG_FILENAME = "openclaw.json";
+const LEGACY_CONFIG_FILENAMES = ["clawdbot.json"];
+function resolveDefaultHomeDir() {
+  return resolveRequiredHomeDir(process.env, os.homedir);
+}
+function envHomedir(env) {
+  return () => resolveRequiredHomeDir(env, os.homedir);
+}
+function legacyStateDirs(homedir = resolveDefaultHomeDir) {
+  return LEGACY_STATE_DIRNAMES.map((dir) => path.join(homedir(), dir));
+}
+function newStateDir(homedir = resolveDefaultHomeDir) {
+  return path.join(homedir(), NEW_STATE_DIRNAME);
+}
+function resolveStateDir(env = process.env, homedir = envHomedir(env)) {
+  const effectiveHomedir = () => resolveRequiredHomeDir(env, homedir);
+  const override = env.OPENCLAW_STATE_DIR?.trim();
+  if (override) return resolveUserPath(override, env, effectiveHomedir);
+  const newDir = newStateDir(effectiveHomedir);
+  if (env.OPENCLAW_TEST_FAST === "1") return newDir;
+  const legacyDirs = legacyStateDirs(effectiveHomedir);
+  if (fs.existsSync(newDir)) return newDir;
+  const existingLegacy = legacyDirs.find((dir) => {
+    try {
+      return fs.existsSync(dir);
+    } catch {
+      return false;
+    }
+  });
+  if (existingLegacy) return existingLegacy;
+  return newDir;
+}
+function resolveUserPath(input, env = process.env, homedir = envHomedir(env)) {
+  return resolveHomeRelativePath(input, {
+    env,
+    homedir
+  });
+}
+const STATE_DIR = resolveStateDir();
+function resolveCanonicalConfigPath(env = process.env, stateDir = resolveStateDir(env, envHomedir(env))) {
+  const override = env.OPENCLAW_CONFIG_PATH?.trim();
+  if (override) return resolveUserPath(override, env, envHomedir(env));
+  return path.join(stateDir, CONFIG_FILENAME);
+}
+function resolveConfigPathCandidate(env = process.env, homedir = envHomedir(env)) {
+  if (env.OPENCLAW_TEST_FAST === "1") return resolveCanonicalConfigPath(env, resolveStateDir(env, homedir));
+  const existing = resolveDefaultConfigCandidates(env, homedir).find((candidate) => {
+    try {
+      return fs.existsSync(candidate);
+    } catch {
+      return false;
+    }
+  });
+  if (existing) return existing;
+  return resolveCanonicalConfigPath(env, resolveStateDir(env, homedir));
+}
+resolveConfigPathCandidate();
+function resolveDefaultConfigCandidates(env = process.env, homedir = envHomedir(env)) {
+  const effectiveHomedir = () => resolveRequiredHomeDir(env, homedir);
+  const explicit = env.OPENCLAW_CONFIG_PATH?.trim();
+  if (explicit) return [resolveUserPath(explicit, env, effectiveHomedir)];
+  const candidates = [];
+  const openclawStateDir = env.OPENCLAW_STATE_DIR?.trim();
+  if (openclawStateDir) {
+    const resolved = resolveUserPath(openclawStateDir, env, effectiveHomedir);
+    candidates.push(path.join(resolved, CONFIG_FILENAME));
+    candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => path.join(resolved, name)));
+  }
+  const defaultDirs = [newStateDir(effectiveHomedir), ...legacyStateDirs(effectiveHomedir)];
+  for (const dir of defaultDirs) {
+    candidates.push(path.join(dir, CONFIG_FILENAME));
+    candidates.push(...LEGACY_CONFIG_FILENAMES.map((name) => path.join(dir, name)));
+  }
+  return candidates;
+}
+const DEFAULT_GATEWAY_PORT = 18789;
+export {
+  resolveStateDir as _,
+  resolveCanonicalConfigPath as a,
+  resolveDefaultConfigCandidates as c,
+  resolveIsNixMode as d,
+  DEFAULT_GATEWAY_PORT as n,
+  STATE_DIR as r,
+  resolveConfigPathCandidate as s
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/process-scoped-map-Cv-PkzaO.js

@@ -0,0 +1,11 @@
+function resolveProcessScopedMap(key) {
+  const proc = process;
+  const existing = proc[key];
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Map();
+  proc[key] = created;
+  return created;
+}
+export {
+  resolveProcessScopedMap as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/profile-utils-Dh8DVvPv.js

@@ -0,0 +1,17 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+const PROFILE_NAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
+function isValidProfileName(value) {
+  if (!value) return false;
+  return PROFILE_NAME_RE.test(value);
+}
+function normalizeProfileName(raw) {
+  const profile = raw?.trim();
+  if (!profile) return null;
+  if (normalizeLowercaseStringOrEmpty(profile) === "default") return null;
+  if (!isValidProfileName(profile)) return null;
+  return profile;
+}
+export {
+  normalizeProfileName as n,
+  isValidProfileName as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/prototype-keys-BKGE_uzN.js

@@ -0,0 +1,11 @@
+const BLOCKED_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+function isBlockedObjectKey(key) {
+  return BLOCKED_OBJECT_KEYS.has(key);
+}
+export {
+  isBlockedObjectKey as t
+};