@openclaw/openshell-sandbox 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/index.js

@@ -1,6 +1,6 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { buildRemoteWorkdirValidationCommand, buildValidatedExecRemoteCommand, createRemoteShellSandboxFsBridge, createSshSandboxSessionFromConfigText, createWritableRenameTargetResolver, disposeSshSandboxSession, registerSandboxBackend, resolvePreferredOpenClawTmpDir, runPluginCommandWithTimeout, runSshSandboxCommand, sanitizeEnvVars, shellEscape, withTempWorkspace } from "openclaw/plugin-sdk/sandbox";
-import fs from "node:fs/promises";
+import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildPluginConfigSchema } from "openclaw/plugin-sdk/core";
@@ -283,7 +283,7 @@ var OpenShellFsBridge = class {
 	async stat(params) {
 		const target = this.resolveTarget(params);
 		const hostPath = this.requireHostPath(target);
-		const stats = await fs.lstat(hostPath).catch(() => null);
+		const stats = await fsPromises.lstat(hostPath).catch(() => null);
 		if (!stats) return null;
 		await assertLocalPathSafety({
 			target,
@@ -400,9 +400,9 @@ async function removeLocalRootPath(params) {
 	const root$1 = await root(params.target.mountHostRoot);
 	const relativePath = relativeToRoot(params.target, params.hostPath);
 	try {
-		if (params.force === false) await fs.lstat(params.hostPath);
+		if (params.force === false) await fsPromises.lstat(params.hostPath);
 		if (params.recursive) {
-			if ((await fs.lstat(params.hostPath).catch((err) => {
+			if ((await fsPromises.lstat(params.hostPath).catch((err) => {
 				if (isNotFoundError(err)) return null;
 				throw err;
 			}))?.isSymbolicLink()) {
@@ -444,12 +444,12 @@ function relativeToRoot(target, hostPath) {
 	return relativePath === "." ? "" : relativePath;
 }
 async function assertRenameSourceSupported(fromHostPath) {
-	const stats = await fs.lstat(fromHostPath);
+	const stats = await fsPromises.lstat(fromHostPath);
 	if (stats.isSymbolicLink()) throw new Error("Sandbox symlink rename sources are not supported by the local mirror bridge");
 	if (stats.isFile() && stats.nlink > 1) throw new Error("Sandbox hardlinked rename sources are not supported by the local mirror bridge");
 }
 async function assertSameDeviceRenameSupported(params) {
-	const sourceStats = await fs.lstat(params.fromHostPath);
+	const sourceStats = await fsPromises.lstat(params.fromHostPath);
 	const destinationParentStats = await nearestExistingDirectoryStats({
 		root: params.root,
 		targetPath: path.dirname(params.toHostPath)
@@ -460,7 +460,7 @@ async function nearestExistingDirectoryStats(params) {
 	const rootPath = path.resolve(params.root);
 	let cursor = path.resolve(params.targetPath);
 	while (isPathInside(rootPath, cursor)) {
-		const stats = await fs.lstat(cursor).catch((err) => {
+		const stats = await fsPromises.lstat(cursor).catch((err) => {
 			if (isNotFoundError(err)) return null;
 			throw err;
 		});
@@ -472,7 +472,7 @@ async function nearestExistingDirectoryStats(params) {
 		if (next === cursor) break;
 		cursor = next;
 	}
-	return await fs.lstat(rootPath);
+	return await fsPromises.lstat(rootPath);
 }
 function isNotFoundError(err) {
 	return err instanceof FsSafeError && err.code === "not-found" || typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
@@ -511,15 +511,15 @@ function resolveProtectedSkillShadowTarget(params) {
 }
 async function assertLocalPathSafety(params) {
 	if (!params.target.hostPath) throw new Error(`Missing local host path for ${params.target.containerPath}`);
-	const canonicalRoot = await fs.realpath(params.root).catch(() => path.resolve(params.root));
-	const targetStats = await fs.lstat(params.target.hostPath).catch(() => null);
+	const canonicalRoot = await fsPromises.realpath(params.root).catch(() => path.resolve(params.root));
+	const targetStats = await fsPromises.lstat(params.target.hostPath).catch(() => null);
 	if (!isPathInside(canonicalRoot, params.allowFinalSymlinkForUnlink && targetStats?.isSymbolicLink() ? path.resolve(canonicalRoot, path.relative(params.root, params.target.hostPath)) : await resolveCanonicalCandidate(params.target.hostPath))) throw new Error(`Sandbox path escapes allowed mounts; cannot access: ${params.target.containerPath}`);
 	const relative = path.relative(params.root, params.target.hostPath);
 	const segments = relative.split(path.sep).filter(Boolean).slice(0, Math.max(0, relative.split(path.sep).filter(Boolean).length));
 	let cursor = params.root;
 	for (let index = 0; index < segments.length; index += 1) {
 		cursor = path.join(cursor, segments[index]);
-		const stats = await fs.lstat(cursor).catch(() => null);
+		const stats = await fsPromises.lstat(cursor).catch(() => null);
 		if (!stats) {
 			if (index === segments.length - 1 && params.allowMissingLeaf) return;
 			continue;
@@ -532,8 +532,8 @@ async function resolveCanonicalCandidate(targetPath) {
 	const missing = [];
 	let cursor = path.resolve(targetPath);
 	while (true) {
-		if (await fs.lstat(cursor).then(() => true).catch(() => false)) {
-			const canonical = await fs.realpath(cursor).catch(() => cursor);
+		if (await fsPromises.lstat(cursor).then(() => true).catch(() => false)) {
+			const canonical = await fsPromises.realpath(cursor).catch(() => cursor);
 			return path.resolve(canonical, ...missing);
 		}
 		const parent = path.dirname(cursor);
@@ -575,16 +575,16 @@ function createConcurrencyLimiter(limit) {
 }
 const runLimitedFs = createConcurrencyLimiter(COPY_TREE_FS_CONCURRENCY);
 async function lstatIfExists(targetPath) {
-	return await runLimitedFs(async () => await fs.lstat(targetPath)).catch(() => null);
+	return await runLimitedFs(async () => await fsPromises.lstat(targetPath)).catch(() => null);
 }
 async function copyTreeWithoutSymlinks(params) {
-	const stats = await runLimitedFs(async () => await fs.lstat(params.sourcePath));
+	const stats = await runLimitedFs(async () => await fsPromises.lstat(params.sourcePath));
 	if (stats.isSymbolicLink()) return;
 	const targetStats = await lstatIfExists(params.targetPath);
 	if (params.preserveTargetSymlinks && targetStats?.isSymbolicLink()) return;
 	if (stats.isDirectory()) {
-		await runLimitedFs(async () => await fs.mkdir(params.targetPath, { recursive: true }));
-		const entries = await runLimitedFs(async () => await fs.readdir(params.sourcePath));
+		await runLimitedFs(async () => await fsPromises.mkdir(params.targetPath, { recursive: true }));
+		const entries = await runLimitedFs(async () => await fsPromises.readdir(params.sourcePath));
 		await Promise.all(entries.map(async (entry) => {
 			await copyTreeWithoutSymlinks({
 				sourcePath: path.join(params.sourcePath, entry),
@@ -595,23 +595,23 @@ async function copyTreeWithoutSymlinks(params) {
 		return;
 	}
 	if (stats.isFile()) {
-		await runLimitedFs(async () => await fs.mkdir(path.dirname(params.targetPath), { recursive: true }));
-		await runLimitedFs(async () => await fs.copyFile(params.sourcePath, params.targetPath));
+		await runLimitedFs(async () => await fsPromises.mkdir(path.dirname(params.targetPath), { recursive: true }));
+		await runLimitedFs(async () => await fsPromises.copyFile(params.sourcePath, params.targetPath));
 	}
 }
 async function replaceDirectoryContents(params) {
 	const isExcluded = createExcludeMatcher(params.excludeDirs);
-	await fs.mkdir(params.targetDir, { recursive: true });
-	const existing = await fs.readdir(params.targetDir);
+	await fsPromises.mkdir(params.targetDir, { recursive: true });
+	const existing = await fsPromises.readdir(params.targetDir);
 	await Promise.all(existing.filter((entry) => !isExcluded(entry)).map(async (entry) => {
 		const targetPath = path.join(params.targetDir, entry);
 		if ((await lstatIfExists(targetPath))?.isSymbolicLink()) return;
-		await runLimitedFs(async () => await fs.rm(targetPath, {
+		await runLimitedFs(async () => await fsPromises.rm(targetPath, {
 			recursive: true,
 			force: true
 		}));
 	}));
-	const sourceEntries = await fs.readdir(params.sourceDir);
+	const sourceEntries = await fsPromises.readdir(params.sourceDir);
 	for (const entry of sourceEntries) {
 		if (isExcluded(entry)) continue;
 		await copyTreeWithoutSymlinks({
@@ -623,8 +623,8 @@ async function replaceDirectoryContents(params) {
 }
 async function stageDirectoryContents(params) {
 	const isExcluded = createExcludeMatcher(params.excludeDirs);
-	await fs.mkdir(params.targetDir, { recursive: true });
-	const sourceEntries = await fs.readdir(params.sourceDir);
+	await fsPromises.mkdir(params.targetDir, { recursive: true });
+	const sourceEntries = await fsPromises.readdir(params.sourceDir);
 	for (const entry of sourceEntries) {
 		if (isExcluded(entry)) continue;
 		await copyTreeWithoutSymlinks({
@@ -1117,7 +1117,7 @@ var OpenShellSandboxBackendImpl = class {
 		await this.ensureSandboxExists();
 		await this.maybeSeedRemoteWorkspace();
 		const target = this.resolveRemoteTarget(remotePath);
-		const stats = await fs.lstat(localPath).catch(() => null);
+		const stats = await fsPromises.lstat(localPath).catch(() => null);
 		if (!stats) {
 			await this.runPinnedRemotePathMutation({ args: [
 				"remove",
@@ -1245,7 +1245,7 @@ var OpenShellSandboxBackendImpl = class {
 			script: `${ENSURE_OPEN_SHELL_REMOTE_REAL_DIRECTORY_SCRIPT}\nfind "$1" -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +`,
 			args: [remoteSkillsWorkspaceDir, this.params.remoteWorkspaceDir]
 		});
-		const stats = await fs.lstat(this.params.createParams.skillsWorkspaceDir).catch(() => null);
+		const stats = await fsPromises.lstat(this.params.createParams.skillsWorkspaceDir).catch(() => null);
 		if (!stats?.isDirectory() || stats.isSymbolicLink()) return;
 		await this.uploadPathToRemote(this.params.createParams.skillsWorkspaceDir, remoteSkillsWorkspaceDir);
 	}
@@ -1296,7 +1296,7 @@ var OpenShellSandboxBackendImpl = class {
 				sourceDir: localPath,
 				targetDir: stagedRoot
 			});
-			const stagedEntries = (await fs.readdir(stagedRoot)).toSorted();
+			const stagedEntries = (await fsPromises.readdir(stagedRoot)).toSorted();
 			for (const entry of stagedEntries) {
 				const result = await runOpenShellCli({
 					context: this.params.execContext,
@@ -1342,17 +1342,17 @@ async function removeMaterializedSkillsFromDownloadedWorkspace(tmpDir) {
 	let cursor = tmpDir;
 	for (const [index, part] of MATERIALIZED_SKILLS_REMOTE_PARTS.entries()) {
 		const next = path.join(cursor, part);
-		const stats = await fs.lstat(next).catch(() => null);
+		const stats = await fsPromises.lstat(next).catch(() => null);
 		if (!stats) return;
 		if (index === MATERIALIZED_SKILLS_REMOTE_PARTS.length - 1) {
-			await fs.rm(next, {
+			await fsPromises.rm(next, {
 				recursive: true,
 				force: true
 			});
 			return;
 		}
 		if (stats.isSymbolicLink() || !stats.isDirectory()) {
-			await fs.rm(next, {
+			await fsPromises.rm(next, {
 				recursive: true,
 				force: true
 			});
@@ -1363,11 +1363,11 @@ async function removeMaterializedSkillsFromDownloadedWorkspace(tmpDir) {
 }
 async function moveMaterializedSkillsShadowAside(params) {
 	const shadowPath = path.join(params.workspaceDir, ...MATERIALIZED_SKILLS_REMOTE_PARTS);
-	const parentStats = await fs.lstat(path.dirname(shadowPath)).catch(() => null);
+	const parentStats = await fsPromises.lstat(path.dirname(shadowPath)).catch(() => null);
 	if (!parentStats?.isDirectory() || parentStats.isSymbolicLink()) return;
-	const shadowStats = await fs.lstat(shadowPath).catch(() => null);
+	const shadowStats = await fsPromises.lstat(shadowPath).catch(() => null);
 	if (!shadowStats || shadowStats.isSymbolicLink()) return;
-	const preserveRoot = await fs.mkdtemp(path.join(path.dirname(params.tmpDir), "openclaw-openshell-preserve-"));
+	const preserveRoot = await fsPromises.mkdtemp(path.join(path.dirname(params.tmpDir), "openclaw-openshell-preserve-"));
 	const preservedPath = path.join(preserveRoot, "sandbox-skills");
 	await movePathWithCopyFallback({
 		from: shadowPath,
@@ -1384,14 +1384,14 @@ async function restoreMaterializedSkillsShadow(params) {
 	try {
 		const shadowPath = path.join(params.workspaceDir, ...MATERIALIZED_SKILLS_REMOTE_PARTS);
 		const parentPath = path.dirname(shadowPath);
-		const parentStats = await fs.lstat(parentPath).catch(() => null);
+		const parentStats = await fsPromises.lstat(parentPath).catch(() => null);
 		if (parentStats?.isSymbolicLink()) throw new Error(`Refusing to restore sandbox skills through symlink parent: ${parentPath}`);
-		if (parentStats && !parentStats.isDirectory()) await fs.rm(parentPath, {
+		if (parentStats && !parentStats.isDirectory()) await fsPromises.rm(parentPath, {
 			recursive: true,
 			force: true
 		});
-		await fs.mkdir(parentPath, { recursive: true });
-		await fs.rm(shadowPath, {
+		await fsPromises.mkdir(parentPath, { recursive: true });
+		await fsPromises.rm(shadowPath, {
 			recursive: true,
 			force: true
 		});
@@ -1401,7 +1401,7 @@ async function restoreMaterializedSkillsShadow(params) {
 		});
 		restored = true;
 	} finally {
-		if (restored) await fs.rm(params.preserved.preserveRoot, {
+		if (restored) await fsPromises.rm(params.preserved.preserveRoot, {
 			recursive: true,
 			force: true
 		});

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/openshell-sandbox",
-  "version": "2026.7.1-beta.1",
+  "version": "2026.7.1-beta.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/openshell-sandbox",
-      "version": "2026.7.1-beta.1",
+      "version": "2026.7.1-beta.4",
       "dependencies": {
         "zod": "4.4.3"
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/openshell-sandbox",
-  "version": "2026.7.1-beta.1",
+  "version": "2026.7.1-beta.4",
   "description": "OpenClaw sandbox backend for the NVIDIA OpenShell CLI with mirrored local workspaces and SSH command execution.",
   "repository": {
     "type": "git",
@@ -20,10 +20,10 @@
       "minHostVersion": ">=2026.5.12-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.7.1-beta.1"
+      "pluginApi": ">=2026.7.1-beta.4"
     },
     "build": {
-      "openclawVersion": "2026.7.1-beta.1",
+      "openclawVersion": "2026.7.1-beta.4",
       "bundledDist": false
     },
     "release": {
@@ -41,7 +41,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.1-beta.1"
+    "openclaw": ">=2026.7.1-beta.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {