@vibe-lark/larkpal 0.1.85 → 0.1.86

package/dist/bundled-dir-U738ay4K-DXK0q_TV.mjs

@@ -0,0 +1,258 @@
+import { i as resolveRequiredHomeDir, n as resolveEffectiveHomeDir, r as resolveHomeRelativePath, s as normalizeOptionalLowercaseString } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import "node:fs/promises";
+import os from "node:os";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/utils-CB8xp0O4.js
+/**
+* Strict plain-object guard (excludes arrays and host objects).
+*/
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+async function ensureDir(dir) {
+	await fs.promises.mkdir(dir, { recursive: true });
+}
+/**
+* Escapes special regex characters in a string so it can be used in a RegExp constructor.
+*/
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Type guard for Record<string, unknown> (less strict than isPlainObject).
+* Accepts any non-null object that isn't an array.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHighSurrogate(codeUnit) {
+	return codeUnit >= 55296 && codeUnit <= 56319;
+}
+function isLowSurrogate(codeUnit) {
+	return codeUnit >= 56320 && codeUnit <= 57343;
+}
+function sliceUtf16Safe(input, start, end) {
+	const len = input.length;
+	let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+	let to = end === void 0 ? len : end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
+	if (to < from) {
+		const tmp = from;
+		from = to;
+		to = tmp;
+	}
+	if (from > 0 && from < len) {
+		if (isLowSurrogate(input.charCodeAt(from)) && isHighSurrogate(input.charCodeAt(from - 1))) from += 1;
+	}
+	if (to > 0 && to < len) {
+		if (isHighSurrogate(input.charCodeAt(to - 1)) && isLowSurrogate(input.charCodeAt(to))) to -= 1;
+	}
+	return input.slice(from, to);
+}
+function truncateUtf16Safe(input, maxLen) {
+	const limit = Math.max(0, Math.floor(maxLen));
+	if (input.length <= limit) return input;
+	return sliceUtf16Safe(input, 0, limit);
+}
+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;
+}
+function resolveHomeDir() {
+	return resolveEffectiveHomeDir(process.env, os.homedir);
+}
+function resolveHomeDisplayPrefix() {
+	const home = resolveHomeDir();
+	if (!home) return;
+	if (process.env.OPENCLAW_HOME?.trim()) return {
+		home,
+		prefix: "$OPENCLAW_HOME"
+	};
+	return {
+		home,
+		prefix: "~"
+	};
+}
+function shortenHomeInString(input) {
+	if (!input) return input;
+	const display = resolveHomeDisplayPrefix();
+	if (!display) return input;
+	return input.split(display.home).join(display.prefix);
+}
+const CONFIG_DIR = resolveConfigDir();
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/openclaw-root-GhlHRwjz.js
+const CORE_PACKAGE_NAMES = 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;
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/bundled-dir-U738ay4K.js
+const DISABLED_BUNDLED_PLUGINS_DIR = path.join(os.tmpdir(), "openclaw-empty-bundled-plugins");
+function bundledPluginsDisabled(env) {
+	const raw = normalizeOptionalLowercaseString(env.OPENCLAW_DISABLE_BUNDLED_PLUGINS);
+	return raw === "1" || raw === "true";
+}
+function resolveDisabledBundledPluginsDir() {
+	fs.mkdirSync(DISABLED_BUNDLED_PLUGINS_DIR, { recursive: true });
+	return DISABLED_BUNDLED_PLUGINS_DIR;
+}
+function isSourceCheckoutRoot(packageRoot) {
+	return fs.existsSync(path.join(packageRoot, ".git")) && fs.existsSync(path.join(packageRoot, "src")) && fs.existsSync(path.join(packageRoot, "extensions"));
+}
+function hasUsableBundledPluginTree(pluginsDir) {
+	if (!fs.existsSync(pluginsDir)) return false;
+	try {
+		return fs.readdirSync(pluginsDir, { withFileTypes: true }).some((entry) => {
+			if (!entry.isDirectory()) return false;
+			const pluginDir = path.join(pluginsDir, entry.name);
+			return fs.existsSync(path.join(pluginDir, "package.json")) || fs.existsSync(path.join(pluginDir, "openclaw.plugin.json"));
+		});
+	} catch {
+		return false;
+	}
+}
+function runningSourceTypeScriptProcess() {
+	const argv1 = process.argv[1]?.toLowerCase();
+	if (argv1?.endsWith(".ts") || argv1?.endsWith(".tsx") || argv1?.endsWith(".mts") || argv1?.endsWith(".cts")) return true;
+	for (let index = 0; index < process.execArgv.length; index += 1) {
+		const arg = process.execArgv[index]?.toLowerCase();
+		if (!arg) continue;
+		if (arg === "tsx" || arg.includes("tsx/register")) return true;
+		if ((arg === "--import" || arg === "--loader") && process.execArgv[index + 1]) {
+			const next = process.execArgv[index + 1].toLowerCase();
+			if (next === "tsx" || next.includes("tsx/")) return true;
+		}
+	}
+	return false;
+}
+function resolveBundledDirFromPackageRoot(packageRoot, preferSourceCheckout) {
+	const sourceExtensionsDir = path.join(packageRoot, "extensions");
+	const builtExtensionsDir = path.join(packageRoot, "dist", "extensions");
+	const sourceCheckout = isSourceCheckoutRoot(packageRoot);
+	if (preferSourceCheckout && fs.existsSync(sourceExtensionsDir)) return sourceExtensionsDir;
+	const runtimeExtensionsDir = path.join(packageRoot, "dist-runtime", "extensions");
+	const hasUsableRuntimeTree = sourceCheckout ? hasUsableBundledPluginTree(runtimeExtensionsDir) : fs.existsSync(runtimeExtensionsDir);
+	const hasUsableBuiltTree = sourceCheckout ? hasUsableBundledPluginTree(builtExtensionsDir) : fs.existsSync(builtExtensionsDir);
+	if (hasUsableRuntimeTree && hasUsableBuiltTree) return runtimeExtensionsDir;
+	if (hasUsableBuiltTree) return builtExtensionsDir;
+	if (sourceCheckout && fs.existsSync(sourceExtensionsDir)) return sourceExtensionsDir;
+}
+function resolveBundledPluginsDir(env = process.env) {
+	if (bundledPluginsDisabled(env)) return resolveDisabledBundledPluginsDir();
+	const override = env.OPENCLAW_BUNDLED_PLUGINS_DIR?.trim();
+	if (override) {
+		const resolvedOverride = resolveUserPath(override, env);
+		if (fs.existsSync(resolvedOverride)) return resolvedOverride;
+		try {
+			const argvPackageRoot = resolveOpenClawPackageRootSync({ argv1: process.argv[1] });
+			if (argvPackageRoot && !isSourceCheckoutRoot(argvPackageRoot)) {
+				const argvFallback = resolveBundledDirFromPackageRoot(argvPackageRoot, false);
+				if (argvFallback) return argvFallback;
+			}
+		} catch {}
+		return resolvedOverride;
+	}
+	const preferSourceCheckout = Boolean(env.VITEST) || runningSourceTypeScriptProcess();
+	try {
+		const packageRoots = [
+			resolveOpenClawPackageRootSync({ argv1: process.argv[1] }),
+			resolveOpenClawPackageRootSync({ cwd: process.cwd() }),
+			resolveOpenClawPackageRootSync({ moduleUrl: import.meta.url })
+		].filter((entry, index, all) => Boolean(entry) && all.indexOf(entry) === index);
+		for (const packageRoot of packageRoots) {
+			const bundledDir = resolveBundledDirFromPackageRoot(packageRoot, preferSourceCheckout);
+			if (bundledDir) return bundledDir;
+		}
+	} catch {}
+	try {
+		const execDir = path.dirname(process.execPath);
+		const siblingBuilt = path.join(execDir, "dist", "extensions");
+		if (fs.existsSync(siblingBuilt)) return siblingBuilt;
+		const sibling = path.join(execDir, "extensions");
+		if (fs.existsSync(sibling)) return sibling;
+	} catch {}
+	try {
+		let cursor = path.dirname(fileURLToPath(import.meta.url));
+		for (let i = 0; i < 6; i += 1) {
+			const candidate = path.join(cursor, "extensions");
+			if (fs.existsSync(candidate)) return candidate;
+			const parent = path.dirname(cursor);
+			if (parent === cursor) break;
+			cursor = parent;
+		}
+	} catch {}
+}
+//#endregion
+export { escapeRegExp as a, resolveConfigDir as c, truncateUtf16Safe as d, ensureDir as i, resolveUserPath as l, resolveOpenClawPackageRootSync as n, isPlainObject as o, CONFIG_DIR as r, isRecord as s, resolveBundledPluginsDir as t, shortenHomeInString as u };