@opengeni/runtime 0.14.0 → 0.14.3

package/dist/{chunk-3NUSY22C.js → chunk-GQIFSLAC.js}

@@ -10647,17 +10647,27 @@ function getHostDockerUser() {
 }
 
 // src/sandbox/providers/docker.ts
+import { isAbsolute as isAbsolute4 } from "path";
 var dockerProvider = {
   backend: "docker",
   descriptor: CAPABILITY_DESCRIPTORS.docker,
   // Local dev container — no credentials. (The dockerNetwork decoration is
   // applied by the factory, not here: it wraps the constructed client.)
-  validateCredentials() {
+  validateCredentials(settings) {
+    const workspaceBaseDir = settings.dockerWorkspaceBaseDir?.trim();
+    if (workspaceBaseDir && !isAbsolute4(workspaceBaseDir)) {
+      throw new SandboxConfigError(
+        "docker",
+        "OPENGENI_DOCKER_WORKSPACE_BASE_DIR must be an absolute path"
+      );
+    }
   },
   build({ settings, exposedPorts }) {
+    const workspaceBaseDir = settings.dockerWorkspaceBaseDir?.trim();
     return new DockerSandboxClient({
       image: settings.dockerImage,
-      exposedPorts
+      exposedPorts,
+      ...workspaceBaseDir ? { workspaceBaseDir } : {}
     });
   }
 };
@@ -19458,6 +19468,7 @@ function withRunCredentialsClient(client, sessionId, onSessionReady) {
 import { createHash as createHash5 } from "crypto";
 import { posix as posixPath } from "path";
 var MAX_TOOLSPACE_SESSION_ID_BYTES = 512;
+var HOME_RELATIVE_TOOLSPACE_PREFIX = "$HOME/";
 var ToolspaceTokenPathError = class extends Error {
   constructor(message) {
     super(message);
@@ -19473,11 +19484,29 @@ function assertToolspaceSessionId(sessionId) {
   }
   return sessionId;
 }
-function toolspaceTokenFileForSession(manifestTokenFile, sessionId) {
-  if (!manifestTokenFile || manifestTokenFile.includes("\0") || !posixPath.isAbsolute(manifestTokenFile)) {
-    throw new ToolspaceTokenPathError("Toolspace manifest token file must be absolute");
+function isHomeRelativeToolspacePath(value) {
+  if (!value.startsWith(HOME_RELATIVE_TOOLSPACE_PREFIX)) return false;
+  const relative4 = value.slice(HOME_RELATIVE_TOOLSPACE_PREFIX.length);
+  const segments = relative4.split("/");
+  return relative4.length > 0 && !relative4.includes("\0") && segments.every(
+    (segment) => segment !== "." && segment !== ".." && /^[A-Za-z0-9._-]+$/.test(segment)
+  ) && posixPath.normalize(relative4) === relative4;
+}
+function assertToolspaceFilePath(value, label) {
+  if (!value || value.includes("\0") || !posixPath.isAbsolute(value) && !isHomeRelativeToolspacePath(value)) {
+    throw new ToolspaceTokenPathError(`${label} must be absolute or use the trusted $HOME/ prefix`);
   }
-  const normalizedManifestFile = posixPath.normalize(manifestTokenFile);
+  return posixPath.isAbsolute(value) ? posixPath.normalize(value) : value;
+}
+function shellToolspacePath(value) {
+  const validated = assertToolspaceFilePath(value, "Toolspace token file");
+  return isHomeRelativeToolspacePath(validated) ? `"${validated}"` : shellQuote5(validated);
+}
+function toolspaceTokenFileForSession(manifestTokenFile, sessionId) {
+  const normalizedManifestFile = assertToolspaceFilePath(
+    manifestTokenFile,
+    "Toolspace manifest token file"
+  );
   const digest = createHash5("sha256").update(assertToolspaceSessionId(sessionId)).digest("hex");
   return posixPath.join(posixPath.dirname(normalizedManifestFile), "toolspace-tokens", digest);
 }
@@ -19486,10 +19515,7 @@ function toolspaceTokenFileFromEnvironment(environment, sessionId) {
   return toolspaceTokenFileForSession(manifestTokenFile, sessionId);
 }
 function withToolspaceTokenEnvironment(cmd, tokenFile) {
-  if (!tokenFile || tokenFile.includes("\0") || !posixPath.isAbsolute(tokenFile)) {
-    throw new ToolspaceTokenPathError("Toolspace token file must be absolute");
-  }
-  return [`export OPENGENI_TOOLSPACE_TOKEN_FILE=${shellQuote5(tokenFile)}`, cmd].join("\n");
+  return [`export OPENGENI_TOOLSPACE_TOKEN_FILE=${shellToolspacePath(tokenFile)}`, cmd].join("\n");
 }
 function withToolspaceTokenSession(session, tokenFile) {
   return new Proxy(session, {
@@ -20509,7 +20535,11 @@ var RoutingSandboxSession = class {
       if (!s.materializeEntry) {
         throw new RoutingUnsupportedError("materializeEntry", this.cached?.kind ?? "unknown");
       }
-      return s.materializeEntry(args);
+      await s.materializeEntry(args);
+      const path = args && typeof args === "object" && typeof args.path === "string" ? args.path : null;
+      if (path) {
+        await assertProviderCanSeeMaterializedPath(s, path);
+      }
     });
   }
   /** PTY support reflects the LAST-resolved backend (a synchronous probe; the SDK
@@ -20573,6 +20603,39 @@ var RoutingSandboxSession = class {
     return this.resolve();
   }
 };
+var MATERIALIZED_PATH_MARKER = "__OPENGENI_MATERIALIZED_PATH_VISIBLE__";
+async function assertProviderCanSeeMaterializedPath(session, path) {
+  const command = `test -e ${shellSingleQuote(path)} && printf %s ${shellSingleQuote(
+    MATERIALIZED_PATH_MARKER
+  )}`;
+  const args = {
+    cmd: command,
+    workdir: providerManifestRoot(session) ?? "/workspace",
+    shell: "sh",
+    login: false,
+    tty: false
+  };
+  let output;
+  if (session.execCommand) {
+    output = await session.execCommand(args);
+  } else if (session.exec) {
+    output = formatExecResult(await session.exec(args));
+  } else {
+    throw new RoutingUnsupportedError("materializeEntry.verify", "unknown");
+  }
+  if (!output.includes(MATERIALIZED_PATH_MARKER)) {
+    throw new Error(
+      `Sandbox materialization completed but the provider cannot read the destination path: ${path}`
+    );
+  }
+}
+function providerManifestRoot(session) {
+  const root = session.state?.manifest?.root;
+  return typeof root === "string" && root.length > 0 ? root : null;
+}
+function shellSingleQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
 
 // src/sandbox/turn-tool-cancellation.ts
 var TURN_EXEC_YIELD_MS = 250;
@@ -23984,6 +24047,7 @@ export {
   withRunCredentialsSession,
   withRunCredentialsClient,
   ToolspaceTokenPathError,
+  shellToolspacePath,
   toolspaceTokenFileForSession,
   toolspaceTokenFileFromEnvironment,
   withToolspaceTokenEnvironment,
@@ -24048,4 +24112,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-3NUSY22C.js.map
+//# sourceMappingURL=chunk-GQIFSLAC.js.map