@vibe-lark/larkpal 0.1.85 → 0.1.86

package/dist/boundary-file-read-BSd9MXPy--KThL5e6.mjs

@@ -0,0 +1,594 @@
+import { o as normalizeLowercaseStringOrEmpty } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
+import fs from "node:fs";
+import path from "node:path";
+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/boundary-path-BSBSMt0u.js
+const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
+const SYMLINK_OPEN_CODES = new Set([
+	"ELOOP",
+	"EINVAL",
+	"ENOTSUP"
+]);
+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 hasNodeErrorCode(value, code) {
+	return isNodeError(value) && value.code === code;
+}
+function isNotFoundPathError(value) {
+	return isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
+}
+function isSymlinkOpenError(value) {
+	return isNodeError(value) && typeof value.code === "string" && SYMLINK_OPEN_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 relative = path.win32.relative(rootForCompare, targetForCompare);
+		return relative === "" || !PARENT_SEGMENT_PREFIX.test(relative) && !path.win32.isAbsolute(relative);
+	}
+	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);
+}
+Object.freeze({
+	allowFinalSymlinkForUnlink: false,
+	allowFinalHardlinkForUnlink: false
+}), Object.freeze({
+	allowFinalSymlinkForUnlink: true,
+	allowFinalHardlinkForUnlink: true
+});
+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));
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/file-identity-DBd-elc3.js
+function isZero(value) {
+	return value === 0 || value === 0n;
+}
+function sameFileIdentity$1(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));
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/safe-open-sync-X8Q1U9Y1.js
+function isExpectedPathError(error) {
+	const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+	return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
+}
+function sameFileIdentity(left, right) {
+	return sameFileIdentity$1(left, right);
+}
+function openVerifiedFileSync(params) {
+	const ioFs = params.ioFs ?? fs;
+	const allowedType = params.allowedType ?? "file";
+	const openReadFlags = ioFs.constants.O_RDONLY | (typeof ioFs.constants.O_NOFOLLOW === "number" ? ioFs.constants.O_NOFOLLOW : 0);
+	let fd = null;
+	try {
+		if (params.rejectPathSymlink) {
+			if (ioFs.lstatSync(params.filePath).isSymbolicLink()) return {
+				ok: false,
+				reason: "validation"
+			};
+		}
+		const realPath = params.resolvedPath ?? ioFs.realpathSync(params.filePath);
+		const preOpenStat = ioFs.lstatSync(realPath);
+		if (!isAllowedType(preOpenStat, allowedType)) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.rejectHardlinks && preOpenStat.isFile() && preOpenStat.nlink > 1) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.maxBytes !== void 0 && preOpenStat.isFile() && preOpenStat.size > params.maxBytes) return {
+			ok: false,
+			reason: "validation"
+		};
+		fd = ioFs.openSync(realPath, openReadFlags);
+		const openedStat = ioFs.fstatSync(fd);
+		if (!isAllowedType(openedStat, allowedType)) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.rejectHardlinks && openedStat.isFile() && openedStat.nlink > 1) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.maxBytes !== void 0 && openedStat.isFile() && openedStat.size > params.maxBytes) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (!sameFileIdentity(preOpenStat, openedStat)) return {
+			ok: false,
+			reason: "validation"
+		};
+		const opened = {
+			ok: true,
+			path: realPath,
+			fd,
+			stat: openedStat
+		};
+		fd = null;
+		return opened;
+	} catch (error) {
+		if (isExpectedPathError(error)) return {
+			ok: false,
+			reason: "path",
+			error
+		};
+		return {
+			ok: false,
+			reason: "io",
+			error
+		};
+	} finally {
+		if (fd !== null) ioFs.closeSync(fd);
+	}
+}
+function isAllowedType(stat, allowedType) {
+	if (allowedType === "directory") return stat.isDirectory();
+	return stat.isFile();
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/boundary-file-read-BSd9MXPy.js
+function canUseBoundaryFileOpen(ioFs) {
+	return typeof ioFs.openSync === "function" && typeof ioFs.closeSync === "function" && typeof ioFs.fstatSync === "function" && typeof ioFs.lstatSync === "function" && typeof ioFs.realpathSync === "function" && typeof ioFs.readFileSync === "function" && typeof ioFs.constants === "object" && ioFs.constants !== null;
+}
+function openBoundaryFileSync(params) {
+	const ioFs = params.ioFs ?? fs;
+	const resolved = resolveBoundaryFilePathGeneric({
+		absolutePath: params.absolutePath,
+		resolve: (absolutePath) => resolveBoundaryPathSync({
+			absolutePath,
+			rootPath: params.rootPath,
+			rootCanonicalPath: params.rootRealPath,
+			boundaryLabel: params.boundaryLabel,
+			skipLexicalRootCheck: params.skipLexicalRootCheck
+		})
+	});
+	if (resolved instanceof Promise) return toBoundaryValidationError(/* @__PURE__ */ new Error("Unexpected async boundary resolution"));
+	return finalizeBoundaryFileOpen({
+		resolved,
+		maxBytes: params.maxBytes,
+		rejectHardlinks: params.rejectHardlinks,
+		allowedType: params.allowedType,
+		ioFs
+	});
+}
+function matchBoundaryFileOpenFailure(failure, handlers) {
+	switch (failure.reason) {
+		case "path": return handlers.path ? handlers.path(failure) : handlers.fallback(failure);
+		case "validation": return handlers.validation ? handlers.validation(failure) : handlers.fallback(failure);
+		case "io": return handlers.io ? handlers.io(failure) : handlers.fallback(failure);
+	}
+	return handlers.fallback(failure);
+}
+function openBoundaryFileResolved(params) {
+	const opened = openVerifiedFileSync({
+		filePath: params.absolutePath,
+		resolvedPath: params.resolvedPath,
+		rejectHardlinks: params.rejectHardlinks ?? true,
+		maxBytes: params.maxBytes,
+		allowedType: params.allowedType,
+		ioFs: params.ioFs
+	});
+	if (!opened.ok) return opened;
+	return {
+		ok: true,
+		path: opened.path,
+		fd: opened.fd,
+		stat: opened.stat,
+		rootRealPath: params.rootRealPath
+	};
+}
+function finalizeBoundaryFileOpen(params) {
+	if ("ok" in params.resolved) return params.resolved;
+	return openBoundaryFileResolved({
+		absolutePath: params.resolved.absolutePath,
+		resolvedPath: params.resolved.resolvedPath,
+		rootRealPath: params.resolved.rootRealPath,
+		maxBytes: params.maxBytes,
+		rejectHardlinks: params.rejectHardlinks,
+		allowedType: params.allowedType,
+		ioFs: params.ioFs
+	});
+}
+function toBoundaryValidationError(error) {
+	return {
+		ok: false,
+		reason: "validation",
+		error
+	};
+}
+function mapResolvedBoundaryPath(absolutePath, resolved) {
+	return {
+		absolutePath,
+		resolvedPath: resolved.canonicalPath,
+		rootRealPath: resolved.rootCanonicalPath
+	};
+}
+function resolveBoundaryFilePathGeneric(params) {
+	const absolutePath = path.resolve(params.absolutePath);
+	try {
+		const resolved = params.resolve(absolutePath);
+		if (resolved instanceof Promise) return resolved.then((value) => mapResolvedBoundaryPath(absolutePath, value)).catch((error) => toBoundaryValidationError(error));
+		return mapResolvedBoundaryPath(absolutePath, resolved);
+	} catch (error) {
+		return toBoundaryValidationError(error);
+	}
+}
+//#endregion
+export { hasNodeErrorCode as a, isSymlinkOpenError as c, sameFileIdentity$1 as i, resolveBoundaryPathSync as l, matchBoundaryFileOpenFailure as n, isNotFoundPathError as o, openBoundaryFileSync as r, isPathInside as s, canUseBoundaryFileOpen as t };

package/dist/browser-lifecycle-cleanup-BdNsMhMD-O3tnAM4i.mjs

@@ -0,0 +1,60 @@
+import { n as loadBundledPluginPublicSurfaceModuleSync } from "./facade-loader-DFzIYYt_-CIr4HKtE.mjs";
+import "node:fs";
+import "node:path";
+import "node:os";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/browser-maintenance-CgzwL4B_.js
+let cachedBrowserMaintenanceSurface;
+function hasRequestedSessionKeys(sessionKeys) {
+	return sessionKeys.some((key) => Boolean(key?.trim()));
+}
+function loadBrowserMaintenanceSurface() {
+	cachedBrowserMaintenanceSurface ??= loadBundledPluginPublicSurfaceModuleSync({
+		dirName: "browser",
+		artifactBasename: "browser-maintenance.js"
+	});
+	return cachedBrowserMaintenanceSurface;
+}
+async function closeTrackedBrowserTabsForSessions(params) {
+	if (!hasRequestedSessionKeys(params.sessionKeys)) return 0;
+	let surface;
+	try {
+		surface = loadBrowserMaintenanceSurface();
+	} catch (error) {
+		params.onWarn?.(`browser cleanup unavailable: ${String(error)}`);
+		return 0;
+	}
+	return await surface.closeTrackedBrowserTabsForSessions(params);
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/browser-lifecycle-cleanup-D8s47iQX.js
+async function runBestEffortCleanup(params) {
+	try {
+		return await params.cleanup();
+	} catch (error) {
+		params.onError?.(error);
+		return;
+	}
+}
+function normalizeSessionKeys(sessionKeys) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const sessionKey of sessionKeys) {
+		const normalized = sessionKey.trim();
+		if (normalized) keys.add(normalized);
+	}
+	return [...keys];
+}
+async function cleanupBrowserSessionsForLifecycleEnd(params) {
+	const sessionKeys = normalizeSessionKeys(params.sessionKeys);
+	if (sessionKeys.length === 0) return;
+	await runBestEffortCleanup({
+		cleanup: async () => {
+			await closeTrackedBrowserTabsForSessions({
+				sessionKeys,
+				onWarn: params.onWarn
+			});
+		},
+		onError: params.onError
+	});
+}
+//#endregion
+export { cleanupBrowserSessionsForLifecycleEnd };