@opengeni/runtime 3.0.0-canary.1 → 3.0.1-canary.1

package/dist/{chunk-46BFUGFL.js → chunk-FQM5VV5D.js}

@@ -15860,6 +15860,36 @@ function admittedProviderCommandHandle() {
   return admission.getStore();
 }
 
+// src/sandbox/materialization-verification-error.ts
+var EXPLANATIONS = {
+  path_not_visible: "the provider could not see the destination path",
+  command_failed: "the visibility-check command exited unsuccessfully",
+  command_pending: "the visibility-check command was still running; path visibility is unconfirmed",
+  invalid_response: "the visibility check returned no valid success confirmation",
+  command_error: "the provider could not complete the visibility-check command"
+};
+var SandboxMaterializationVerificationError = class extends Error {
+  constructor(diagnostic, options) {
+    super(
+      `Sandbox materialization verification failed: ${EXPLANATIONS[diagnostic.reason]}: ${diagnostic.path}`,
+      options
+    );
+    this.diagnostic = diagnostic;
+    this.name = "SandboxMaterializationVerificationError";
+  }
+  code = "sandbox_materialization_verification_failed";
+};
+var providerDiagnostics = /* @__PURE__ */ new WeakMap();
+function retainMaterializationVerificationDiagnostic(error, diagnostic) {
+  if (error !== null && (typeof error === "object" || typeof error === "function")) {
+    providerDiagnostics.set(error, diagnostic);
+  }
+}
+function materializationVerificationDiagnostic(error) {
+  if (error instanceof SandboxMaterializationVerificationError) return error.diagnostic;
+  return error !== null && (typeof error === "object" || typeof error === "function") ? providerDiagnostics.get(error) : void 0;
+}
+
 // src/sandbox/routing/routing-session.ts
 import { CAPABILITY_DESCRIPTORS as CAPABILITY_DESCRIPTORS2 } from "@opengeni/contracts";
 
@@ -17305,11 +17335,13 @@ var RoutingSandboxSession = class {
   async invokeProviderOperation(op, backend, fn, onCaptureWait) {
     const startedAt = performance.now();
     let outcome = "failed";
+    let materializationFailureReason;
     try {
       const result = await withSandboxProviderOperation(backend.session, fn, onCaptureWait);
       outcome = "ok";
       return result;
     } catch (error) {
+      materializationFailureReason = materializationVerificationDiagnostic(error)?.reason;
       if ((op === "readFile" || op === "listDir" || op === "pathExists" || op === "viewImage") && isDefinitePathNotFoundError(error)) {
         outcome = "not_found";
       }
@@ -17320,7 +17352,8 @@ var RoutingSandboxSession = class {
           backend: backend.kind,
           op,
           outcome,
-          durationMs: Math.max(0, performance.now() - startedAt)
+          durationMs: Math.max(0, performance.now() - startedAt),
+          ...materializationFailureReason ? { materializationFailureReason } : {}
         });
       } catch {
       }
@@ -17793,6 +17826,9 @@ var RoutingSandboxSession = class {
 };
 var MATERIALIZED_PATH_MARKER = "__OPENGENI_MATERIALIZED_PATH_VISIBLE__";
 async function assertProviderCanSeeMaterializedPath(session, path) {
+  if (session.verifyMaterializedPath) {
+    return session.verifyMaterializedPath(path, providerManifestRoot(session) ?? "/workspace");
+  }
   const command = `test -e ${shellSingleQuote(path)} && printf %s ${shellSingleQuote(
     MATERIALIZED_PATH_MARKER
   )}`;
@@ -17804,18 +17840,56 @@ async function assertProviderCanSeeMaterializedPath(session, path) {
     tty: false
   };
   let output;
-  if (session.execCommand) {
-    output = await session.execCommand(args);
-  } else if (session.exec) {
-    output = formatExecResult(await session.exec(args));
-  } else {
+  let result;
+  if (!session.execCommand && !session.exec) {
     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}`
-    );
+  try {
+    result = session.execCommand ? await session.execCommand(args) : await session.exec(args);
+  } catch (cause) {
+    retainMaterializationVerificationDiagnostic(cause, {
+      reason: "command_error",
+      path,
+      workdir: args.workdir,
+      command,
+      output: null,
+      exitCode: null,
+      providerSessionId: null,
+      causeMessage: cause instanceof Error ? cause.message : String(cause)
+    });
+    throw cause;
+  }
+  try {
+    output = formatExecResult(result);
+  } catch (cause) {
+    const record = result && typeof result === "object" ? result : {};
+    const returnedOutput = [record.output, record.stderr, record.stdout].filter((value) => typeof value === "string").join("\n");
+    throw new SandboxMaterializationVerificationError({
+      reason: "invalid_response",
+      path,
+      workdir: args.workdir,
+      command,
+      output: returnedOutput || null,
+      exitCode: null,
+      providerSessionId: null,
+      causeMessage: cause instanceof Error ? cause.message : String(cause)
+    });
+  }
+  const status = parseExecResponseBanner(output);
+  const markerPresent = stripExecBanner(output).includes(MATERIALIZED_PATH_MARKER);
+  if (markerPresent && (status.kind === "absent" || status.kind === "exited" && status.exitCode === 0)) {
+    return;
   }
+  const reason = status.kind === "running" ? "command_pending" : status.kind === "exited" && status.exitCode === 1 ? "path_not_visible" : status.kind === "exited" && status.exitCode !== 0 ? "command_failed" : "invalid_response";
+  throw new SandboxMaterializationVerificationError({
+    reason,
+    path,
+    workdir: args.workdir,
+    command,
+    output,
+    exitCode: status.kind === "exited" ? status.exitCode : null,
+    providerSessionId: status.kind === "running" ? status.sessionId : null
+  });
 }
 function providerManifestRoot(session) {
   const root = session.state?.manifest?.root;
@@ -21793,6 +21867,96 @@ function parseUnifiedPatch(patch) {
 
 // src/sandbox/providers/modal-command-session.ts
 import { randomUUID as randomUUID5 } from "crypto";
+
+// src/sandbox/providers/modal-materialization-verification.ts
+var MARKER = "__OPENGENI_MATERIALIZED_PATH_VISIBLE__";
+var OUTPUT_LIMIT = 16 * 1024;
+async function verifyModalMaterializedPath(control, path, workdir, pending, observationTimeoutMs = 3e4) {
+  const quote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+  const command = `test -e ${quote(path)} && printf %s ${quote(MARKER)}`;
+  const cancellation = new AbortController();
+  const deadlineReason = new Error("Materialization visibility observation deadline exceeded");
+  let providerCommand;
+  let stdout = "";
+  let stderr = "";
+  const diagnostic = (reason, exitCode = null) => ({
+    reason,
+    path,
+    workdir,
+    command,
+    output: (stdout + stderr).slice(0, OUTPUT_LIMIT),
+    exitCode,
+    providerSessionId: null,
+    ...providerCommand ? {
+      providerExecution: {
+        sandboxId: providerCommand.sandboxId,
+        taskId: providerCommand.taskId,
+        execId: providerCommand.execId
+      }
+    } : {}
+  });
+  const timer = setTimeout(() => {
+    cancellation.abort(deadlineReason);
+  }, observationTimeoutMs);
+  timer.unref();
+  pending.add(cancellation);
+  try {
+    providerCommand = await control.start(
+      { cmd: command, workdir, shell: "sh", login: false, tty: false },
+      cancellation.signal
+    );
+    for (; ; ) {
+      cancellation.signal.throwIfAborted();
+      const page = await control.readProbe(providerCommand, 1e3, cancellation);
+      cancellation.signal.throwIfAborted();
+      if (page.command.sandboxId !== providerCommand.sandboxId || page.command.taskId !== providerCommand.taskId || page.command.execId !== providerCommand.execId) {
+        throw new SandboxMaterializationVerificationError(diagnostic("invalid_response"));
+      }
+      providerCommand = page.command;
+      for (const chunk of page.chunks) {
+        if (chunk.stream === "stdout") stdout += chunk.text;
+        else stderr += chunk.text;
+      }
+      if (stdout.length + stderr.length > OUTPUT_LIMIT) {
+        throw new SandboxMaterializationVerificationError(diagnostic("invalid_response"));
+      }
+      if (page.exitCode === null) {
+        await new Promise((resolve6) => setImmediate(resolve6));
+        continue;
+      }
+      if (page.exitCode === 0 && stdout === MARKER) return;
+      throw new SandboxMaterializationVerificationError(
+        diagnostic(
+          page.exitCode === 1 ? "path_not_visible" : page.exitCode === 0 ? "invalid_response" : "command_failed",
+          page.exitCode
+        )
+      );
+    }
+  } catch (error) {
+    if (cancellation.signal.reason === deadlineReason) {
+      throw new SandboxMaterializationVerificationError(
+        {
+          ...diagnostic("command_pending"),
+          causeMessage: "Observation deadline exceeded; provider process completion is unconfirmed"
+        },
+        { cause: error }
+      );
+    }
+    if (!(error instanceof SandboxMaterializationVerificationError)) {
+      retainMaterializationVerificationDiagnostic(error, {
+        ...diagnostic("command_error"),
+        causeMessage: error instanceof Error ? error.message : String(error)
+      });
+    }
+    throw error;
+  } finally {
+    cancellation.abort(new Error("Materialization visibility observation finished"));
+    clearTimeout(timer);
+    pending.delete(cancellation);
+  }
+}
+
+// src/sandbox/providers/modal-command-session.ts
 function sameExecution(a, b) {
   return a.sandboxId === b.sandboxId && a.taskId === b.taskId && a.execId === b.execId && Boolean(a.pty) === Boolean(b.pty);
 }
@@ -21802,6 +21966,7 @@ function installModalCommandSession(session, control) {
   const originalWrite = session.writeStdin?.bind(session);
   const cancelLegacyStart = session.cancelPendingExecCommand?.bind(session);
   const pendingStarts = /* @__PURE__ */ new Set();
+  session.verifyMaterializedPath = (path, workdir) => verifyModalMaterializedPath(control, path, workdir, pendingStarts);
   const entries = /* @__PURE__ */ new Map();
   const setupHandles = /* @__PURE__ */ new Map();
   let nextSetupHandle = MAX_PROVIDER_COMMAND_HANDLE + 1;
@@ -22074,49 +22239,76 @@ var ModalCommandControl = class _ModalCommandControl {
     };
   }
   async read(command, yieldTimeMs, signal) {
+    return this.readOutput(command, yieldTimeMs, signal);
+  }
+  /** Fixed internal probes own their cancellation controller and must drain
+   * both reads before relinquishing the surrounding provider-operation gate.
+   * Retained-command readers keep their existing signal/receipt contract.
+   */
+  async readProbe(command, yieldTimeMs, cancellation) {
+    return this.readOutput(
+      command,
+      yieldTimeMs,
+      cancellation.signal,
+      (error) => cancellation.abort(error)
+    );
+  }
+  async readOutput(command, yieldTimeMs, signal, cancelSiblings) {
     signal?.throwIfAborted();
     this.assertIdentity(command);
     const next = structuredClone(command);
-    const pages = await Promise.all(
-      ["stdout", "stderr"].map(async (stream) => {
-        const cursor = command.streams[stream];
-        if (cursor.exitCode !== null) return null;
-        const descriptor = stream === "stdout" ? 1 : 2;
-        for await (const batch of this.client.containerExecGetOutput(
-          {
-            execId: command.execId,
-            timeout: Math.max(0, yieldTimeMs) / 1e3,
-            lastBatchIndex: cursor.batchIndex,
-            fileDescriptor: descriptor,
-            getRawBytes: true
-          },
-          signal ? { signal } : void 0
-        )) {
-          if (batch.batchIndex <= cursor.batchIndex) continue;
-          if (!Number.isSafeInteger(batch.batchIndex))
-            throw new Error("Invalid Modal output cursor");
-          const terminal = batch.exitCode !== void 0;
-          if (terminal && !Number.isSafeInteger(batch.exitCode))
-            throw new Error("Invalid Modal exit status");
-          const decoded = decodePage(
-            cursor.utf8Remainder,
-            batch.items.filter((item) => item.fileDescriptor === descriptor).map((item) => item.messageBytes),
-            terminal
-          );
-          next.streams[stream] = {
-            batchIndex: batch.batchIndex,
-            utf8Remainder: decoded.remainder,
-            exitCode: terminal ? batch.exitCode : null
-          };
-          return {
-            stream,
-            chunkId: `modal:${command.execId}:${stream}:${cursor.batchIndex}:${batch.batchIndex}`,
-            text: decoded.text
-          };
-        }
-        return null;
+    let failure;
+    const reads = ["stdout", "stderr"].map(async (stream) => {
+      const cursor = command.streams[stream];
+      if (cursor.exitCode !== null) return null;
+      const descriptor = stream === "stdout" ? 1 : 2;
+      for await (const batch of this.client.containerExecGetOutput(
+        {
+          execId: command.execId,
+          timeout: Math.max(0, yieldTimeMs) / 1e3,
+          lastBatchIndex: cursor.batchIndex,
+          fileDescriptor: descriptor,
+          getRawBytes: true
+        },
+        signal ? { signal } : void 0
+      )) {
+        if (batch.batchIndex <= cursor.batchIndex) continue;
+        if (!Number.isSafeInteger(batch.batchIndex))
+          throw new Error("Invalid Modal output cursor");
+        const terminal = batch.exitCode !== void 0;
+        if (terminal && !Number.isSafeInteger(batch.exitCode))
+          throw new Error("Invalid Modal exit status");
+        const decoded = decodePage(
+          cursor.utf8Remainder,
+          batch.items.filter((item) => item.fileDescriptor === descriptor).map((item) => item.messageBytes),
+          terminal
+        );
+        next.streams[stream] = {
+          batchIndex: batch.batchIndex,
+          utf8Remainder: decoded.remainder,
+          exitCode: terminal ? batch.exitCode : null
+        };
+        return {
+          stream,
+          chunkId: `modal:${command.execId}:${stream}:${cursor.batchIndex}:${batch.batchIndex}`,
+          text: decoded.text
+        };
+      }
+      return null;
+    }).map(
+      (read) => !cancelSiblings ? read : read.catch((error) => {
+        failure ??= { error };
+        cancelSiblings(error);
+        throw error;
       })
     );
+    const pages = cancelSiblings ? await Promise.allSettled(reads).then((results) => {
+      if (failure) throw failure.error;
+      return results.map((result) => {
+        if (result.status === "rejected") throw result.reason;
+        return result.value;
+      });
+    }) : await Promise.all(reads);
     const stdoutExit = next.streams.stdout.exitCode;
     const stderrExit = next.streams.stderr.exitCode;
     if (stdoutExit !== null && stderrExit !== null && stdoutExit !== stderrExit)
@@ -37040,6 +37232,8 @@ export {
   parseExecBannerSessionId,
   parseExecBannerExitCode,
   isExecSessionLostBanner,
+  SandboxMaterializationVerificationError,
+  materializationVerificationDiagnostic,
   normalizeConnectedMachineWorkspaceRoot,
   isWindowsConnectedMachinePath,
   isConnectedMachineAbsolutePath,
@@ -37293,4 +37487,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-46BFUGFL.js.map
+//# sourceMappingURL=chunk-FQM5VV5D.js.map