@workclaw/openclaw-workclaw 1.0.201 → 1.0.331

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/file-identity-sp9axE-E.js

@@ -0,0 +1,411 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import "node:fs/promises";
+const NOT_FOUND_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR"]);
+const PARENT_SEGMENT_PREFIX = /^\.\.(?:[\\/]|$)/u;
+function normalizeWindowsPathForComparison(input) {
+  let normalized = path.win32.normalize(input);
+  if (normalized.startsWith("\\\\?\\")) {
+    normalized = normalized.slice(4);
+    if (normalized.toUpperCase().startsWith("UNC\\")) normalized = `\\\\${normalized.slice(4)}`;
+  }
+  return normalizeLowercaseStringOrEmpty(normalized.replaceAll("/", "\\"));
+}
+function isNodeError(value) {
+  return Boolean(value && typeof value === "object" && "code" in value);
+}
+function isNotFoundPathError(value) {
+  return isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
+}
+function isPathInside(root, target) {
+  if (process.platform === "win32") {
+    const rootForCompare = normalizeWindowsPathForComparison(path.win32.resolve(root));
+    const targetForCompare = normalizeWindowsPathForComparison(path.win32.resolve(target));
+    const relative2 = path.win32.relative(rootForCompare, targetForCompare);
+    return relative2 === "" || !PARENT_SEGMENT_PREFIX.test(relative2) && !path.win32.isAbsolute(relative2);
+  }
+  const resolvedRoot = path.resolve(root);
+  const resolvedTarget = path.resolve(target);
+  const relative = path.relative(resolvedRoot, resolvedTarget);
+  return relative === "" || !PARENT_SEGMENT_PREFIX.test(relative) && !path.isAbsolute(relative);
+}
+function resolveBoundaryPathSync(params) {
+  const rootPath = path.resolve(params.rootPath);
+  const absolutePath = path.resolve(params.absolutePath);
+  const context = createBoundaryResolutionContext({
+    resolveParams: params,
+    rootPath,
+    absolutePath,
+    rootCanonicalPath: params.rootCanonicalPath ? path.resolve(params.rootCanonicalPath) : resolvePathViaExistingAncestorSync(rootPath),
+    outsideLexicalCanonicalPath: resolveOutsideLexicalCanonicalPathSync({
+      rootPath,
+      absolutePath
+    })
+  });
+  const outsideResult = resolveOutsideBoundaryPathSync({
+    boundaryLabel: params.boundaryLabel,
+    context
+  });
+  if (outsideResult) return outsideResult;
+  return resolveBoundaryPathLexicalSync({
+    params,
+    absolutePath: context.absolutePath,
+    rootPath: context.rootPath,
+    rootCanonicalPath: context.rootCanonicalPath
+  });
+}
+function isPromiseLike(value) {
+  return Boolean(value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function");
+}
+function createLexicalTraversalState(params) {
+  return {
+    segments: path.relative(params.rootPath, params.absolutePath).split(path.sep).filter(Boolean),
+    allowFinalSymlink: params.params.policy?.allowFinalSymlinkForUnlink === true,
+    canonicalCursor: params.rootCanonicalPath,
+    lexicalCursor: params.rootPath,
+    preserveFinalSymlink: false
+  };
+}
+function assertLexicalCursorInsideBoundary(params) {
+  assertInsideBoundary({
+    boundaryLabel: params.params.boundaryLabel,
+    rootCanonicalPath: params.rootCanonicalPath,
+    candidatePath: params.candidatePath,
+    absolutePath: params.absolutePath
+  });
+}
+function applyMissingSuffixToCanonicalCursor(params) {
+  const missingSuffix = params.state.segments.slice(params.missingFromIndex);
+  params.state.canonicalCursor = path.resolve(params.state.canonicalCursor, ...missingSuffix);
+  assertLexicalCursorInsideBoundary({
+    params: params.params,
+    rootCanonicalPath: params.rootCanonicalPath,
+    candidatePath: params.state.canonicalCursor,
+    absolutePath: params.absolutePath
+  });
+}
+function advanceCanonicalCursorForSegment(params) {
+  params.state.canonicalCursor = path.resolve(params.state.canonicalCursor, params.segment);
+  assertLexicalCursorInsideBoundary({
+    params: params.params,
+    rootCanonicalPath: params.rootCanonicalPath,
+    candidatePath: params.state.canonicalCursor,
+    absolutePath: params.absolutePath
+  });
+}
+function finalizeLexicalResolution(params) {
+  assertLexicalCursorInsideBoundary({
+    params: params.params,
+    rootCanonicalPath: params.rootCanonicalPath,
+    candidatePath: params.state.canonicalCursor,
+    absolutePath: params.absolutePath
+  });
+  return buildResolvedBoundaryPath({
+    absolutePath: params.absolutePath,
+    canonicalPath: params.state.canonicalCursor,
+    rootPath: params.rootPath,
+    rootCanonicalPath: params.rootCanonicalPath,
+    kind: params.kind
+  });
+}
+function handleLexicalLstatFailure(params) {
+  if (!isNotFoundPathError(params.error)) return false;
+  applyMissingSuffixToCanonicalCursor({
+    state: params.state,
+    missingFromIndex: params.missingFromIndex,
+    rootCanonicalPath: params.rootCanonicalPath,
+    params: params.resolveParams,
+    absolutePath: params.absolutePath
+  });
+  return true;
+}
+function handleLexicalStatReadFailure(params) {
+  if (handleLexicalLstatFailure({
+    error: params.error,
+    state: params.state,
+    missingFromIndex: params.missingFromIndex,
+    rootCanonicalPath: params.rootCanonicalPath,
+    resolveParams: params.resolveParams,
+    absolutePath: params.absolutePath
+  })) return null;
+  throw params.error;
+}
+function handleLexicalStatDisposition(params) {
+  if (!params.isSymbolicLink) {
+    advanceCanonicalCursorForSegment({
+      state: params.state,
+      segment: params.segment,
+      rootCanonicalPath: params.rootCanonicalPath,
+      params: params.resolveParams,
+      absolutePath: params.absolutePath
+    });
+    return "continue";
+  }
+  if (params.state.allowFinalSymlink && params.isLast) {
+    params.state.preserveFinalSymlink = true;
+    advanceCanonicalCursorForSegment({
+      state: params.state,
+      segment: params.segment,
+      rootCanonicalPath: params.rootCanonicalPath,
+      params: params.resolveParams,
+      absolutePath: params.absolutePath
+    });
+    return "break";
+  }
+  return "resolve-link";
+}
+function applyResolvedSymlinkHop(params) {
+  if (!isPathInside(params.rootCanonicalPath, params.linkCanonical)) throw symlinkEscapeError({
+    boundaryLabel: params.boundaryLabel,
+    rootCanonicalPath: params.rootCanonicalPath,
+    symlinkPath: params.state.lexicalCursor
+  });
+  params.state.canonicalCursor = params.linkCanonical;
+  params.state.lexicalCursor = params.linkCanonical;
+}
+function readLexicalStat(params) {
+  try {
+    const stat = params.read(params.state.lexicalCursor);
+    if (isPromiseLike(stat)) return Promise.resolve(stat).catch((error) => handleLexicalStatReadFailure({
+      ...params,
+      error
+    }));
+    return stat;
+  } catch (error) {
+    return handleLexicalStatReadFailure({
+      ...params,
+      error
+    });
+  }
+}
+function resolveAndApplySymlinkHop(params) {
+  const linkCanonical = params.resolveLinkCanonical(params.state.lexicalCursor);
+  if (isPromiseLike(linkCanonical)) return Promise.resolve(linkCanonical).then((value) => applyResolvedSymlinkHop({
+    state: params.state,
+    linkCanonical: value,
+    rootCanonicalPath: params.rootCanonicalPath,
+    boundaryLabel: params.boundaryLabel
+  }));
+  applyResolvedSymlinkHop({
+    state: params.state,
+    linkCanonical,
+    rootCanonicalPath: params.rootCanonicalPath,
+    boundaryLabel: params.boundaryLabel
+  });
+}
+function resolveBoundaryPathLexicalSync(params) {
+  const state = createLexicalTraversalState(params);
+  for (let idx = 0; idx < state.segments.length; idx += 1) {
+    const segment = state.segments[idx] ?? "";
+    const isLast = idx === state.segments.length - 1;
+    state.lexicalCursor = path.join(state.lexicalCursor, segment);
+    const maybeStat = readLexicalStat({
+      state,
+      missingFromIndex: idx,
+      rootCanonicalPath: params.rootCanonicalPath,
+      resolveParams: params.params,
+      absolutePath: params.absolutePath,
+      read: (cursor) => fs.lstatSync(cursor)
+    });
+    if (isPromiseLike(maybeStat)) throw new Error("Unexpected async lexical stat");
+    const stat = maybeStat;
+    if (!stat) break;
+    const disposition = handleLexicalStatDisposition({
+      state,
+      isSymbolicLink: stat.isSymbolicLink(),
+      segment,
+      isLast,
+      rootCanonicalPath: params.rootCanonicalPath,
+      resolveParams: params.params,
+      absolutePath: params.absolutePath
+    });
+    if (disposition === "continue") continue;
+    if (disposition === "break") break;
+    if (isPromiseLike(resolveAndApplySymlinkHop({
+      state,
+      rootCanonicalPath: params.rootCanonicalPath,
+      boundaryLabel: params.params.boundaryLabel,
+      resolveLinkCanonical: (cursor) => resolveSymlinkHopPathSync(cursor)
+    }))) throw new Error("Unexpected async symlink resolution");
+  }
+  const kind = getPathKindSync(params.absolutePath, state.preserveFinalSymlink);
+  return finalizeLexicalResolution({
+    ...params,
+    state,
+    kind
+  });
+}
+function resolveCanonicalOutsideLexicalPath(params) {
+  return params.outsideLexicalCanonicalPath ?? params.absolutePath;
+}
+function createBoundaryResolutionContext(params) {
+  const lexicalInside = isPathInside(params.rootPath, params.absolutePath);
+  const canonicalOutsideLexicalPath = resolveCanonicalOutsideLexicalPath({
+    absolutePath: params.absolutePath,
+    outsideLexicalCanonicalPath: params.outsideLexicalCanonicalPath
+  });
+  assertLexicalBoundaryOrCanonicalAlias({
+    skipLexicalRootCheck: params.resolveParams.skipLexicalRootCheck,
+    lexicalInside,
+    canonicalOutsideLexicalPath,
+    rootCanonicalPath: params.rootCanonicalPath,
+    boundaryLabel: params.resolveParams.boundaryLabel,
+    rootPath: params.rootPath,
+    absolutePath: params.absolutePath
+  });
+  return {
+    rootPath: params.rootPath,
+    absolutePath: params.absolutePath,
+    rootCanonicalPath: params.rootCanonicalPath,
+    lexicalInside,
+    canonicalOutsideLexicalPath
+  };
+}
+function resolveOutsideBoundaryPathSync(params) {
+  if (params.context.lexicalInside) return null;
+  const kind = getPathKindSync(params.context.absolutePath, false);
+  return buildOutsideBoundaryPathFromContext({
+    boundaryLabel: params.boundaryLabel,
+    context: params.context,
+    kind
+  });
+}
+function buildOutsideBoundaryPathFromContext(params) {
+  return buildOutsideLexicalBoundaryPath({
+    boundaryLabel: params.boundaryLabel,
+    rootCanonicalPath: params.context.rootCanonicalPath,
+    absolutePath: params.context.absolutePath,
+    canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
+    rootPath: params.context.rootPath,
+    kind: params.kind
+  });
+}
+function resolveOutsideLexicalCanonicalPathSync(params) {
+  if (isPathInside(params.rootPath, params.absolutePath)) return;
+  return resolvePathViaExistingAncestorSync(params.absolutePath);
+}
+function buildOutsideLexicalBoundaryPath(params) {
+  assertInsideBoundary({
+    boundaryLabel: params.boundaryLabel,
+    rootCanonicalPath: params.rootCanonicalPath,
+    candidatePath: params.canonicalOutsideLexicalPath,
+    absolutePath: params.absolutePath
+  });
+  return buildResolvedBoundaryPath({
+    absolutePath: params.absolutePath,
+    canonicalPath: params.canonicalOutsideLexicalPath,
+    rootPath: params.rootPath,
+    rootCanonicalPath: params.rootCanonicalPath,
+    kind: params.kind
+  });
+}
+function assertLexicalBoundaryOrCanonicalAlias(params) {
+  if (params.skipLexicalRootCheck || params.lexicalInside) return;
+  if (isPathInside(params.rootCanonicalPath, params.canonicalOutsideLexicalPath)) return;
+  throw pathEscapeError({
+    boundaryLabel: params.boundaryLabel,
+    rootPath: params.rootPath,
+    absolutePath: params.absolutePath
+  });
+}
+function buildResolvedBoundaryPath(params) {
+  return {
+    absolutePath: params.absolutePath,
+    canonicalPath: params.canonicalPath,
+    rootPath: params.rootPath,
+    rootCanonicalPath: params.rootCanonicalPath,
+    relativePath: relativeInsideRoot(params.rootCanonicalPath, params.canonicalPath),
+    exists: params.kind.exists,
+    kind: params.kind.kind
+  };
+}
+function resolvePathViaExistingAncestorSync(targetPath) {
+  const normalized = path.resolve(targetPath);
+  let cursor = normalized;
+  const missingSuffix = [];
+  while (!isFilesystemRoot(cursor) && !fs.existsSync(cursor)) {
+    missingSuffix.unshift(path.basename(cursor));
+    const parent = path.dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+  if (!fs.existsSync(cursor)) return normalized;
+  try {
+    const resolvedAncestor = path.resolve(fs.realpathSync(cursor));
+    if (missingSuffix.length === 0) return resolvedAncestor;
+    return path.resolve(resolvedAncestor, ...missingSuffix);
+  } catch {
+    return normalized;
+  }
+}
+function getPathKindSync(absolutePath, preserveFinalSymlink) {
+  try {
+    return {
+      exists: true,
+      kind: toResolvedKind(preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath))
+    };
+  } catch (error) {
+    if (isNotFoundPathError(error)) return {
+      exists: false,
+      kind: "missing"
+    };
+    throw error;
+  }
+}
+function toResolvedKind(stat) {
+  if (stat.isFile()) return "file";
+  if (stat.isDirectory()) return "directory";
+  if (stat.isSymbolicLink()) return "symlink";
+  return "other";
+}
+function relativeInsideRoot(rootPath, targetPath) {
+  const relative = path.relative(path.resolve(rootPath), path.resolve(targetPath));
+  if (!relative || relative === ".") return "";
+  if (relative.startsWith("..") || path.isAbsolute(relative)) return "";
+  return relative;
+}
+function assertInsideBoundary(params) {
+  if (isPathInside(params.rootCanonicalPath, params.candidatePath)) return;
+  throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
+}
+function pathEscapeError(params) {
+  return /* @__PURE__ */ new Error(`Path escapes ${params.boundaryLabel} (${shortPath(params.rootPath)}): ${shortPath(params.absolutePath)}`);
+}
+function symlinkEscapeError(params) {
+  return /* @__PURE__ */ new Error(`Symlink escapes ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.symlinkPath)}`);
+}
+function shortPath(value) {
+  const home = os.homedir();
+  if (value.startsWith(home)) return `~${value.slice(home.length)}`;
+  return value;
+}
+function isFilesystemRoot(candidate) {
+  return path.parse(candidate).root === candidate;
+}
+function resolveSymlinkHopPathSync(symlinkPath) {
+  try {
+    return path.resolve(fs.realpathSync(symlinkPath));
+  } catch (error) {
+    if (!isNotFoundPathError(error)) throw error;
+    const linkTarget = fs.readlinkSync(symlinkPath);
+    return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
+  }
+}
+function isZero(value) {
+  return value === 0 || value === 0n;
+}
+function sameFileIdentity(left, right, platform = process.platform) {
+  if (left.ino !== right.ino) return false;
+  if (left.dev === right.dev) return true;
+  return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
+}
+export {
+  resolvePathViaExistingAncestorSync as a,
+  isPathInside as c,
+  resolveBoundaryPathSync as i,
+  isNotFoundPathError as s,
+  sameFileIdentity as t,
+  normalizeWindowsPathForComparison as u
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/file-lock-D016H3tC.js

@@ -0,0 +1,5 @@
+import "node:fs";
+import { t as resolveProcessScopedMap } from "./process-scoped-map-Cv-PkzaO.js";
+import "node:path";
+import "node:fs/promises";
+resolveProcessScopedMap(Symbol.for("openclaw.fileLockHeldLocks"));

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/gateway-control-ui-origins-B-lkqr3D.js

@@ -0,0 +1,23 @@
+import { n as DEFAULT_GATEWAY_PORT } from "./paths-LCYGfrV7.js";
+function isGatewayNonLoopbackBindMode(bind) {
+  return bind === "lan" || bind === "tailnet" || bind === "custom" || bind === "auto";
+}
+function hasConfiguredControlUiAllowedOrigins(params) {
+  if (params.dangerouslyAllowHostHeaderOriginFallback === true) return true;
+  return Array.isArray(params.allowedOrigins) && params.allowedOrigins.some((origin) => typeof origin === "string" && origin.trim().length > 0);
+}
+function resolveGatewayPortWithDefault(port, fallback = DEFAULT_GATEWAY_PORT) {
+  return typeof port === "number" && port > 0 ? port : fallback;
+}
+function buildDefaultControlUiAllowedOrigins(params) {
+  const origins = /* @__PURE__ */ new Set([`http://localhost:${params.port}`, `http://127.0.0.1:${params.port}`]);
+  const customBindHost = params.customBindHost?.trim();
+  if (params.bind === "custom" && customBindHost) origins.add(`http://${customBindHost}:${params.port}`);
+  return [...origins];
+}
+export {
+  resolveGatewayPortWithDefault as a,
+  isGatewayNonLoopbackBindMode as i,
+  hasConfiguredControlUiAllowedOrigins as r,
+  buildDefaultControlUiAllowedOrigins as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/gateway-request-scope-BEWoJTx4.js

@@ -0,0 +1,3 @@
+import { n as resolveGlobalSingleton } from "./global-singleton-DhGoboiG.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+resolveGlobalSingleton(Symbol.for("openclaw.pluginRuntimeGatewayRequestScope"), () => new AsyncLocalStorage());

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/global-singleton-DhGoboiG.js

@@ -0,0 +1,14 @@
+function resolveGlobalSingleton(key, create) {
+  const globalStore = globalThis;
+  if (Object.prototype.hasOwnProperty.call(globalStore, key)) return globalStore[key];
+  const created = create();
+  globalStore[key] = created;
+  return created;
+}
+function resolveGlobalMap(key) {
+  return resolveGlobalSingleton(key, () => /* @__PURE__ */ new Map());
+}
+export {
+  resolveGlobalSingleton as n,
+  resolveGlobalMap as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/helpers-CI2CkXhU.js

@@ -0,0 +1,7 @@
+import { t as formatCliCommand } from "./command-format-LqDv8ows.js";
+function formatPairingApproveHint(channelId) {
+  return `Approve via: ${formatCliCommand(`openclaw pairing list ${channelId}`)} / ${formatCliCommand(`openclaw pairing approve ${channelId} <code>`)}`;
+}
+export {
+  formatPairingApproveHint as n
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/home-dir-BEqRdfoa.js

@@ -0,0 +1,67 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import path from "node:path";
+import os from "node:os";
+function normalize(value) {
+  const trimmed = normalizeOptionalString(value);
+  if (!trimmed) return;
+  if (trimmed === "undefined" || trimmed === "null") return;
+  return trimmed;
+}
+function resolveEffectiveHomeDir(env = process.env, homedir = os.homedir) {
+  const raw = resolveRawHomeDir(env, homedir);
+  return raw ? path.resolve(raw) : void 0;
+}
+function resolveRawHomeDir(env, homedir) {
+  const explicitHome = normalize(env.OPENCLAW_HOME);
+  if (explicitHome) {
+    if (explicitHome === "~" || explicitHome.startsWith("~/") || explicitHome.startsWith("~\\")) {
+      const fallbackHome = resolveRawOsHomeDir(env, homedir);
+      if (fallbackHome) return explicitHome.replace(/^~(?=$|[\\/])/, fallbackHome);
+      return;
+    }
+    return explicitHome;
+  }
+  return resolveRawOsHomeDir(env, homedir);
+}
+function resolveRawOsHomeDir(env, homedir) {
+  const envHome = normalize(env.HOME);
+  if (envHome) return envHome;
+  const userProfile = normalize(env.USERPROFILE);
+  if (userProfile) return userProfile;
+  return normalizeSafe(homedir);
+}
+function normalizeSafe(homedir) {
+  try {
+    return normalize(homedir());
+  } catch {
+    return;
+  }
+}
+function resolveRequiredHomeDir(env = process.env, homedir = os.homedir) {
+  return resolveEffectiveHomeDir(env, homedir) ?? path.resolve(process.cwd());
+}
+function expandHomePrefix(input, opts) {
+  if (!input.startsWith("~")) return input;
+  const home = normalize(opts?.home) ?? resolveEffectiveHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir);
+  if (!home) return input;
+  return input.replace(/^~(?=$|[\\/])/, home);
+}
+function resolveHomeRelativePath(input, opts) {
+  const trimmed = input.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.startsWith("~")) {
+    const expanded = expandHomePrefix(trimmed, {
+      home: resolveRequiredHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
+      env: opts?.env,
+      homedir: opts?.homedir
+    });
+    return path.resolve(expanded);
+  }
+  return path.resolve(trimmed);
+}
+export {
+  resolveEffectiveHomeDir as n,
+  resolveRequiredHomeDir as o,
+  resolveHomeRelativePath as r,
+  expandHomePrefix as t
+};