@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/thinking.shared-Dginn1He.js

@@ -0,0 +1,14 @@
+const NO_THINKING_LEVELS = [...[
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "adaptive"
+]];
+function listThinkingLevels(_provider, _model) {
+  return [...NO_THINKING_LEVELS];
+}
+export {
+  listThinkingLevels as i
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/tmp-openclaw-dir-DrKSsX71.js

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+const POSIX_OPENCLAW_TMP_DIR = "/tmp/openclaw";
+const TMP_DIR_ACCESS_MODE = fs.constants.W_OK | fs.constants.X_OK;
+function isNodeErrorWithCode(err, code) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === code;
+}
+function resolvePreferredOpenClawTmpDir(options = {}) {
+  const accessSync = options.accessSync ?? fs.accessSync;
+  const chmodSync = options.chmodSync ?? fs.chmodSync;
+  const lstatSync = options.lstatSync ?? fs.lstatSync;
+  const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+  const warn = options.warn ?? ((message) => console.warn(message));
+  const getuid = options.getuid ?? (() => {
+    try {
+      return typeof process.getuid === "function" ? process.getuid() : void 0;
+    } catch {
+      return;
+    }
+  });
+  const tmpdir$1 = typeof options.tmpdir === "function" ? options.tmpdir : tmpdir;
+  const uid = getuid();
+  const isSecureDirForUser = (st) => {
+    if (uid === void 0) return true;
+    if (typeof st.uid === "number" && st.uid !== uid) return false;
+    if (typeof st.mode === "number" && (st.mode & 18) !== 0) return false;
+    return true;
+  };
+  const fallback = () => {
+    const base = tmpdir$1();
+    const suffix = uid === void 0 ? "openclaw" : `openclaw-${uid}`;
+    return path.join(base, suffix);
+  };
+  const isTrustedTmpDir = (st) => {
+    return st.isDirectory() && !st.isSymbolicLink() && isSecureDirForUser(st);
+  };
+  const resolveDirState = (candidatePath) => {
+    try {
+      if (!isTrustedTmpDir(lstatSync(candidatePath))) return "invalid";
+      accessSync(candidatePath, TMP_DIR_ACCESS_MODE);
+      return "available";
+    } catch (err) {
+      if (isNodeErrorWithCode(err, "ENOENT")) return "missing";
+      return "invalid";
+    }
+  };
+  const tryRepairWritableBits = (candidatePath) => {
+    try {
+      const st = lstatSync(candidatePath);
+      if (!st.isDirectory() || st.isSymbolicLink()) return false;
+      if (uid !== void 0 && typeof st.uid === "number" && st.uid !== uid) return false;
+      if (typeof st.mode !== "number" || (st.mode & 18) === 0) return false;
+      chmodSync(candidatePath, 448);
+      warn(`[openclaw] tightened permissions on temp dir: ${candidatePath}`);
+      return resolveDirState(candidatePath) === "available";
+    } catch {
+      return false;
+    }
+  };
+  const ensureTrustedFallbackDir = () => {
+    const fallbackPath = fallback();
+    const state = resolveDirState(fallbackPath);
+    if (state === "available") return fallbackPath;
+    if (state === "invalid") {
+      if (tryRepairWritableBits(fallbackPath)) return fallbackPath;
+      throw new Error(`Unsafe fallback OpenClaw temp dir: ${fallbackPath}`);
+    }
+    try {
+      mkdirSync(fallbackPath, {
+        recursive: true,
+        mode: 448
+      });
+      chmodSync(fallbackPath, 448);
+    } catch {
+      throw new Error(`Unable to create fallback OpenClaw temp dir: ${fallbackPath}`);
+    }
+    if (resolveDirState(fallbackPath) !== "available" && !tryRepairWritableBits(fallbackPath)) throw new Error(`Unsafe fallback OpenClaw temp dir: ${fallbackPath}`);
+    return fallbackPath;
+  };
+  const existingPreferredState = resolveDirState(POSIX_OPENCLAW_TMP_DIR);
+  if (existingPreferredState === "available") return POSIX_OPENCLAW_TMP_DIR;
+  if (existingPreferredState === "invalid") {
+    if (tryRepairWritableBits("/tmp/openclaw")) return POSIX_OPENCLAW_TMP_DIR;
+    return ensureTrustedFallbackDir();
+  }
+  try {
+    accessSync("/tmp", TMP_DIR_ACCESS_MODE);
+    mkdirSync(POSIX_OPENCLAW_TMP_DIR, {
+      recursive: true,
+      mode: 448
+    });
+    chmodSync(POSIX_OPENCLAW_TMP_DIR, 448);
+    if (resolveDirState("/tmp/openclaw") !== "available" && !tryRepairWritableBits("/tmp/openclaw")) return ensureTrustedFallbackDir();
+    return POSIX_OPENCLAW_TMP_DIR;
+  } catch {
+    return ensureTrustedFallbackDir();
+  }
+}
+export {
+  resolvePreferredOpenClawTmpDir as n,
+  POSIX_OPENCLAW_TMP_DIR as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/tool-policy-CwZyJfFc.js

@@ -0,0 +1,300 @@
+const EXEC_TOOL_DISPLAY_SUMMARY = "Run shell commands that start now.";
+const PROCESS_TOOL_DISPLAY_SUMMARY = "Inspect and control running exec sessions.";
+const CRON_TOOL_DISPLAY_SUMMARY = "Schedule cron jobs, reminders, and wake events.";
+const SESSIONS_LIST_TOOL_DISPLAY_SUMMARY = "List visible sessions and optional recent messages.";
+const SESSIONS_HISTORY_TOOL_DISPLAY_SUMMARY = "Read sanitized message history for a visible session.";
+const SESSIONS_SEND_TOOL_DISPLAY_SUMMARY = "Send a message to another visible session.";
+const SESSIONS_SPAWN_TOOL_DISPLAY_SUMMARY = "Spawn sub-agent or ACP sessions.";
+const SESSION_STATUS_TOOL_DISPLAY_SUMMARY = "Show session status, usage, and model state.";
+const UPDATE_PLAN_TOOL_DISPLAY_SUMMARY = "Track a short structured work plan.";
+const CORE_TOOL_DEFINITIONS = [
+  {
+    id: "read",
+    label: "read",
+    description: "Read file contents",
+    sectionId: "fs",
+    profiles: ["coding"]
+  },
+  {
+    id: "write",
+    label: "write",
+    description: "Create or overwrite files",
+    sectionId: "fs",
+    profiles: ["coding"]
+  },
+  {
+    id: "edit",
+    label: "edit",
+    description: "Make precise edits",
+    sectionId: "fs",
+    profiles: ["coding"]
+  },
+  {
+    id: "apply_patch",
+    label: "apply_patch",
+    description: "Patch files",
+    sectionId: "fs",
+    profiles: ["coding"]
+  },
+  {
+    id: "exec",
+    label: "exec",
+    description: EXEC_TOOL_DISPLAY_SUMMARY,
+    sectionId: "runtime",
+    profiles: ["coding"]
+  },
+  {
+    id: "process",
+    label: "process",
+    description: PROCESS_TOOL_DISPLAY_SUMMARY,
+    sectionId: "runtime",
+    profiles: ["coding"]
+  },
+  {
+    id: "code_execution",
+    label: "code_execution",
+    description: "Run sandboxed remote analysis",
+    sectionId: "runtime",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "web_search",
+    label: "web_search",
+    description: "Search the web",
+    sectionId: "web",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "web_fetch",
+    label: "web_fetch",
+    description: "Fetch web content",
+    sectionId: "web",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "x_search",
+    label: "x_search",
+    description: "Search X posts",
+    sectionId: "web",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "memory_search",
+    label: "memory_search",
+    description: "Semantic search",
+    sectionId: "memory",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "memory_get",
+    label: "memory_get",
+    description: "Read memory files",
+    sectionId: "memory",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "sessions_list",
+    label: "sessions_list",
+    description: SESSIONS_LIST_TOOL_DISPLAY_SUMMARY,
+    sectionId: "sessions",
+    profiles: ["coding", "messaging"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "sessions_history",
+    label: "sessions_history",
+    description: SESSIONS_HISTORY_TOOL_DISPLAY_SUMMARY,
+    sectionId: "sessions",
+    profiles: ["coding", "messaging"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "sessions_send",
+    label: "sessions_send",
+    description: SESSIONS_SEND_TOOL_DISPLAY_SUMMARY,
+    sectionId: "sessions",
+    profiles: ["coding", "messaging"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "sessions_spawn",
+    label: "sessions_spawn",
+    description: SESSIONS_SPAWN_TOOL_DISPLAY_SUMMARY,
+    sectionId: "sessions",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "sessions_yield",
+    label: "sessions_yield",
+    description: "End turn to receive sub-agent results",
+    sectionId: "sessions",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "subagents",
+    label: "subagents",
+    description: "Manage sub-agents",
+    sectionId: "sessions",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "session_status",
+    label: "session_status",
+    description: SESSION_STATUS_TOOL_DISPLAY_SUMMARY,
+    sectionId: "sessions",
+    profiles: [
+      "minimal",
+      "coding",
+      "messaging"
+    ],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "browser",
+    label: "browser",
+    description: "Control web browser",
+    sectionId: "ui",
+    profiles: [],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "canvas",
+    label: "canvas",
+    description: "Control canvases",
+    sectionId: "ui",
+    profiles: [],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "message",
+    label: "message",
+    description: "Send messages",
+    sectionId: "messaging",
+    profiles: ["messaging"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "cron",
+    label: "cron",
+    description: CRON_TOOL_DISPLAY_SUMMARY,
+    sectionId: "automation",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "gateway",
+    label: "gateway",
+    description: "Gateway control",
+    sectionId: "automation",
+    profiles: [],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "nodes",
+    label: "nodes",
+    description: "Nodes + devices",
+    sectionId: "nodes",
+    profiles: [],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "agents_list",
+    label: "agents_list",
+    description: "List agents",
+    sectionId: "agents",
+    profiles: [],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "update_plan",
+    label: "update_plan",
+    description: UPDATE_PLAN_TOOL_DISPLAY_SUMMARY,
+    sectionId: "agents",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "image",
+    label: "image",
+    description: "Image understanding",
+    sectionId: "media",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "image_generate",
+    label: "image_generate",
+    description: "Image generation",
+    sectionId: "media",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "music_generate",
+    label: "music_generate",
+    description: "Music generation",
+    sectionId: "media",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "video_generate",
+    label: "video_generate",
+    description: "Video generation",
+    sectionId: "media",
+    profiles: ["coding"],
+    includeInOpenClawGroup: true
+  },
+  {
+    id: "tts",
+    label: "tts",
+    description: "Text-to-speech conversion",
+    sectionId: "media",
+    profiles: [],
+    includeInOpenClawGroup: true
+  }
+];
+new Map(CORE_TOOL_DEFINITIONS.map((tool) => [tool.id, tool]));
+function listCoreToolIdsForProfile(profile) {
+  return CORE_TOOL_DEFINITIONS.filter((tool) => tool.profiles.includes(profile)).map((tool) => tool.id);
+}
+({
+  minimal: { allow: listCoreToolIdsForProfile("minimal") },
+  coding: { allow: listCoreToolIdsForProfile("coding") },
+  messaging: { allow: listCoreToolIdsForProfile("messaging") }
+});
+function buildCoreToolGroupMap() {
+  const sectionToolMap = /* @__PURE__ */ new Map();
+  for (const tool of CORE_TOOL_DEFINITIONS) {
+    const groupId = `group:${tool.sectionId}`;
+    const list = sectionToolMap.get(groupId) ?? [];
+    list.push(tool.id);
+    sectionToolMap.set(groupId, list);
+  }
+  const openclawTools = CORE_TOOL_DEFINITIONS.filter((tool) => tool.includeInOpenClawGroup).map((tool) => tool.id);
+  return {
+    "group:openclaw": openclawTools,
+    ...Object.fromEntries(sectionToolMap.entries())
+  };
+}
+buildCoreToolGroupMap();
+export {
+  UPDATE_PLAN_TOOL_DISPLAY_SUMMARY as C,
+  SESSION_STATUS_TOOL_DISPLAY_SUMMARY as S,
+  PROCESS_TOOL_DISPLAY_SUMMARY as _,
+  SESSIONS_SEND_TOOL_DISPLAY_SUMMARY as b,
+  EXEC_TOOL_DISPLAY_SUMMARY as g,
+  CRON_TOOL_DISPLAY_SUMMARY as h,
+  SESSIONS_HISTORY_TOOL_DISPLAY_SUMMARY as v,
+  SESSIONS_SPAWN_TOOL_DISPLAY_SUMMARY as x,
+  SESSIONS_LIST_TOOL_DISPLAY_SUMMARY as y
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/types-BfKfz-lz.js

@@ -0,0 +1,38 @@
+const PLUGIN_HOOK_NAMES = [
+  "before_model_resolve",
+  "before_prompt_build",
+  "before_agent_start",
+  "before_agent_reply",
+  "llm_input",
+  "llm_output",
+  "agent_end",
+  "before_compaction",
+  "after_compaction",
+  "before_reset",
+  "inbound_claim",
+  "message_received",
+  "message_sending",
+  "message_sent",
+  "before_tool_call",
+  "after_tool_call",
+  "tool_result_persist",
+  "before_message_write",
+  "session_start",
+  "session_end",
+  "subagent_spawning",
+  "subagent_delivery_target",
+  "subagent_spawned",
+  "subagent_ended",
+  "gateway_start",
+  "gateway_stop",
+  "before_dispatch",
+  "reply_dispatch",
+  "before_install"
+];
+new Set(PLUGIN_HOOK_NAMES);
+const PROMPT_INJECTION_HOOK_NAMES = ["before_prompt_build", "before_agent_start"];
+new Set(PROMPT_INJECTION_HOOK_NAMES);
+export {
+  PROMPT_INJECTION_HOOK_NAMES as n,
+  PLUGIN_HOOK_NAMES as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/types.secrets-C9RpLzA0.js

@@ -0,0 +1,53 @@
+import { l as isRecord } from "./utils-DGFSjtQF.js";
+const DEFAULT_SECRET_PROVIDER_ALIAS = "default";
+const ENV_SECRET_TEMPLATE_RE = /^\$\{([A-Z][A-Z0-9_]{0,127})\}$/;
+function isSecretRef(value) {
+  if (!isRecord(value)) return false;
+  if (Object.keys(value).length !== 3) return false;
+  return (value.source === "env" || value.source === "file" || value.source === "exec") && typeof value.provider === "string" && value.provider.trim().length > 0 && typeof value.id === "string" && value.id.trim().length > 0;
+}
+function isLegacySecretRefWithoutProvider(value) {
+  if (!isRecord(value)) return false;
+  return (value.source === "env" || value.source === "file" || value.source === "exec") && typeof value.id === "string" && value.id.trim().length > 0 && value.provider === void 0;
+}
+function parseEnvTemplateSecretRef(value, provider = DEFAULT_SECRET_PROVIDER_ALIAS) {
+  if (typeof value !== "string") return null;
+  const match = ENV_SECRET_TEMPLATE_RE.exec(value.trim());
+  if (!match) return null;
+  return {
+    source: "env",
+    provider: provider.trim() || "default",
+    id: match[1]
+  };
+}
+function coerceSecretRef(value, defaults) {
+  if (isSecretRef(value)) return value;
+  if (isLegacySecretRefWithoutProvider(value)) {
+    const provider = value.source === "env" ? "default" : value.source === "file" ? "default" : "default";
+    return {
+      source: value.source,
+      provider,
+      id: value.id
+    };
+  }
+  const envTemplate = parseEnvTemplateSecretRef(value, defaults?.env);
+  if (envTemplate) return envTemplate;
+  return null;
+}
+function hasConfiguredSecretInput(value, defaults) {
+  if (normalizeSecretInputString(value)) return true;
+  return coerceSecretRef(value, defaults) !== null;
+}
+function normalizeSecretInputString(value) {
+  if (typeof value !== "string") return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+export {
+  hasConfiguredSecretInput as a,
+  coerceSecretRef as i,
+  normalizeSecretInputString as l,
+  isSecretRef as o,
+  DEFAULT_SECRET_PROVIDER_ALIAS as t,
+  parseEnvTemplateSecretRef as u
+};

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

@@ -0,0 +1,36 @@
+import { o as resolveRequiredHomeDir, r as resolveHomeRelativePath } from "./home-dir-BEqRdfoa.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveUserPath(input, env = process.env, homedir = os.homedir) {
+  if (!input) return "";
+  return resolveHomeRelativePath(input, {
+    env,
+    homedir
+  });
+}
+function resolveConfigDir(env = process.env, homedir = os.homedir) {
+  const override = env.OPENCLAW_STATE_DIR?.trim();
+  if (override) return resolveUserPath(override, env, homedir);
+  const configPath = env.OPENCLAW_CONFIG_PATH?.trim();
+  if (configPath) return path.dirname(resolveUserPath(configPath, env, homedir));
+  const newDir = path.join(resolveRequiredHomeDir(env, homedir), ".openclaw");
+  try {
+    if (fs.existsSync(newDir)) return newDir;
+  } catch {
+  }
+  return newDir;
+}
+resolveConfigDir();
+export {
+  escapeRegExp as c,
+  resolveConfigDir as f,
+  isRecord as l,
+  resolveUserPath as m
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/version-b06Uhxnq.js

@@ -0,0 +1,82 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import { createRequire } from "node:module";
+const CORE_PACKAGE_NAME = "openclaw";
+const PACKAGE_JSON_CANDIDATES = [
+  "../package.json",
+  "../../package.json",
+  "../../../package.json",
+  "./package.json"
+];
+const BUILD_INFO_CANDIDATES = [
+  "../build-info.json",
+  "../../build-info.json",
+  "./build-info.json"
+];
+function readVersionFromJsonCandidates(moduleUrl, candidates, opts = {}) {
+  try {
+    const require2 = createRequire(moduleUrl);
+    for (const candidate of candidates) try {
+      const parsed = require2(candidate);
+      const version = normalizeOptionalString(parsed.version);
+      if (!version) continue;
+      if (opts.requirePackageName && parsed.name !== CORE_PACKAGE_NAME) continue;
+      return version;
+    } catch {
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = normalizeOptionalString(value);
+    if (trimmed) return trimmed;
+  }
+}
+function readVersionFromPackageJsonForModuleUrl(moduleUrl) {
+  return readVersionFromJsonCandidates(moduleUrl, PACKAGE_JSON_CANDIDATES, { requirePackageName: true });
+}
+function readVersionFromBuildInfoForModuleUrl(moduleUrl) {
+  return readVersionFromJsonCandidates(moduleUrl, BUILD_INFO_CANDIDATES);
+}
+function resolveVersionFromModuleUrl(moduleUrl) {
+  return readVersionFromPackageJsonForModuleUrl(moduleUrl) || readVersionFromBuildInfoForModuleUrl(moduleUrl);
+}
+function resolveBinaryVersion(params) {
+  return firstNonEmpty(params.injectedVersion) || resolveVersionFromModuleUrl(params.moduleUrl) || firstNonEmpty(params.bundledVersion) || params.fallback || "0.0.0";
+}
+const RUNTIME_SERVICE_VERSION_FALLBACK = "unknown";
+function resolveUsableRuntimeVersion(version) {
+  const trimmed = normalizeOptionalString(version);
+  if (!trimmed || trimmed === "0.0.0") return;
+  return trimmed;
+}
+function resolveVersionFromRuntimeSources(params) {
+  return firstNonEmpty(...params.preference === "env-first" ? [params.env["OPENCLAW_VERSION"], params.runtimeVersion] : [params.runtimeVersion, params.env["OPENCLAW_VERSION"]], params.env["OPENCLAW_SERVICE_VERSION"], params.env["npm_package_version"]) ?? params.fallback;
+}
+function resolveCompatibilityHostVersion(env = process.env, fallback = RUNTIME_SERVICE_VERSION_FALLBACK) {
+  const explicitCompatibilityVersion = firstNonEmpty(env.OPENCLAW_COMPATIBILITY_HOST_VERSION);
+  if (explicitCompatibilityVersion) return explicitCompatibilityVersion;
+  return resolveVersionFromRuntimeSources({
+    env,
+    runtimeVersion: resolveUsableRuntimeVersion(VERSION),
+    fallback,
+    preference: env === process.env ? "runtime-first" : "env-first"
+  });
+}
+const VERSION = resolveBinaryVersion({
+  moduleUrl: import.meta.url,
+  injectedVersion: typeof __OPENCLAW_VERSION__ === "string" ? __OPENCLAW_VERSION__ : void 0,
+  bundledVersion: process.env.OPENCLAW_BUNDLED_VERSION
+});
+export {
+  resolveBinaryVersion as a,
+  resolveUsableRuntimeVersion as c,
+  readVersionFromPackageJsonForModuleUrl as i,
+  resolveVersionFromModuleUrl as l,
+  VERSION as n,
+  resolveCompatibilityHostVersion as o,
+  readVersionFromBuildInfoForModuleUrl as r,
+  RUNTIME_SERVICE_VERSION_FALLBACK as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/workspace-oVBetctb.js

@@ -0,0 +1,20 @@
+import { o as normalizeOptionalLowercaseString } from "./string-coerce-BUSzWgUA.js";
+import { o as resolveRequiredHomeDir } from "./home-dir-BEqRdfoa.js";
+import { fileURLToPath } from "node:url";
+import "node:fs";
+import path from "node:path";
+import "node:fs/promises";
+import "./utils-DGFSjtQF.js";
+import "./exec-jRxy02_4.js";
+import os from "node:os";
+path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/reference/templates");
+function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
+  const home = resolveRequiredHomeDir(env, homedir);
+  const profile = env.OPENCLAW_PROFILE?.trim();
+  if (profile && normalizeOptionalLowercaseString(profile) !== "default") return path.join(home, ".openclaw", `workspace-${profile}`);
+  return path.join(home, ".openclaw", "workspace");
+}
+resolveDefaultAgentWorkspaceDir();
+export {
+  resolveDefaultAgentWorkspaceDir as g
+};