@poe-platform/safe-bash 0.1.651 → 0.1.653

package/dist/safe-bash/chunks/{chunk-IX6VL7KM.js → chunk-43HWIHXB.js}

@@ -2,9 +2,12 @@ import {
   openCommandFile
 } from "./chunk-2E4KBFO6.js";
 import {
+  PythonFailure,
   PythonInvocationError,
-  parsePythonInvocation
-} from "./chunk-JZDO5MC3.js";
+  isPythonFailureCategory,
+  parsePythonInvocation,
+  reportPythonFailure
+} from "./chunk-Y7MAMRAF.js";
 import {
   createOutputOperation
 } from "./chunk-CDBQXRWL.js";
@@ -1212,7 +1215,8 @@ function createPythonPackageEnvironment(options = {}) {
 var PythonInputChunkError = class extends RangeError {
 };
 function createPythonCommands(options) {
-  if (typeof options?.createWorker !== "function") throw new TypeError("Python requires an explicit interpreter worker factory");
+  if (typeof options?.createWorker !== "function") throw new PythonFailure("executor-unavailable");
+  if (options.onDiagnostic !== void 0 && typeof options.onDiagnostic !== "function") throw new TypeError("Python onDiagnostic must be a function");
   const maxTransferBytes = options.maxTransferBytes ?? 65536;
   const maxOpenFiles = options.maxOpenFiles ?? 256;
   const maxConcurrentWorkers = options.maxConcurrentWorkers ?? 4;
@@ -1245,7 +1249,8 @@ function createPythonCommands(options) {
     }
     context.signal.throwIfAborted();
     if (activeWorkers >= maxConcurrentWorkers) {
-      await writeBytes(context.stderr, new TextEncoder().encode("python: worker capacity exhausted\n"), context.signal);
+      const failure2 = reportPythonFailure("capacity", void 0, options.onDiagnostic);
+      await writeBytes(context.stderr, new TextEncoder().encode("python: " + failure2.message + "\n"), context.signal);
       return { exitCode: 1 };
     }
     const controller = new AbortController();
@@ -1300,7 +1305,7 @@ function createPythonCommands(options) {
         }
         finish();
       }, (reason) => {
-        fail(reason);
+        fail(reportPythonFailure("cleanup", reason, options.onDiagnostic));
       });
       return closing;
     };
@@ -1309,6 +1314,8 @@ function createPythonCommands(options) {
     };
     context.registerCleanup?.(close);
     let primary;
+    let ready = false;
+    const filesystemDiagnostics = /* @__PURE__ */ new Set();
     let result = 1;
     try {
       signal.throwIfAborted();
@@ -1317,8 +1324,12 @@ function createPythonCommands(options) {
       const outputContext = { signal, ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {} };
       stdoutOperation = createOutputOperation(outputContext, context.stdout);
       stderrOperation = createOutputOperation(outputContext, context.stderr);
-      if (typeof SharedArrayBuffer !== "function") throw new Error("Python worker filesystem requires SharedArrayBuffer");
-      const shared = new SharedArrayBuffer(8 + maxTransferBytes * 6 + 65536);
+      let shared;
+      try {
+        shared = new SharedArrayBuffer(8 + maxTransferBytes * 6 + 65536);
+      } catch (reason) {
+        throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
+      }
       const control = new Int32Array(shared, 0, 2);
       const payload = new Uint8Array(shared, 8);
       const reply = (value, status) => {
@@ -1332,9 +1343,13 @@ function createPythonCommands(options) {
           status = 2;
         }
         payload.set(bytes);
-        Atomics.store(control, 1, bytes.length);
-        Atomics.store(control, 0, status);
-        Atomics.notify(control, 0);
+        try {
+          Atomics.store(control, 1, bytes.length);
+          Atomics.store(control, 0, status);
+          Atomics.notify(control, 0);
+        } catch (reason) {
+          throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
+        }
       };
       const dispatch = async (request) => {
         signal.throwIfAborted();
@@ -1384,7 +1399,11 @@ function createPythonCommands(options) {
         pending.delete(preparation);
       }
       signal.throwIfAborted();
-      endpoint = options.createWorker();
+      try {
+        endpoint = options.createWorker();
+      } catch (reason) {
+        throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : "startup", reason, options.onDiagnostic);
+      }
       signal.throwIfAborted();
       result = await new Promise((resolve, reject) => {
         let settled = false;
@@ -1394,92 +1413,109 @@ function createPythonCommands(options) {
         };
         rejectRun = fail;
         signal.addEventListener("abort", aborted, { once: true });
-        unsubscribe = endpoint.subscribe((value) => {
-          if (closed || settled) return;
-          if (typeof value !== "object" || value === null) {
-            fail(new TypeError("Invalid Python worker message"));
-            return;
-          }
-          const message = value;
-          if (message.type === "ready") {
-            try {
-              options.onProgress?.({ phase: "ready", command: context.command });
-            } catch (error) {
-              fail(error);
+        const transportFailure = (reason) => {
+          fail(reportPythonFailure("transport-unavailable", reason, options.onDiagnostic));
+        };
+        try {
+          unsubscribe = endpoint.subscribe((value) => {
+            if (closed || settled) return;
+            if (typeof value !== "object" || value === null) {
+              transportFailure(new TypeError("Invalid Python worker message"));
+              return;
             }
-            return;
-          }
-          if (message.type === "exit") {
-            if (pending.size) {
-              fail(new TypeError("Python worker exited with an outstanding request"));
+            const message = value;
+            if (message.type === "ready") {
+              ready = true;
+              try {
+                options.onProgress?.({ phase: "ready", command: context.command });
+              } catch (error) {
+                fail(error);
+              }
               return;
             }
-            try {
-              const status = validateExitCode(message.exitCode);
-              settled = true;
-              resolve(status);
-            } catch (error) {
-              fail(error);
+            if (message.type === "exit") {
+              if (pending.size) {
+                transportFailure(new TypeError("Python worker exited with an outstanding request"));
+                return;
+              }
+              try {
+                const status = validateExitCode(message.exitCode);
+                settled = true;
+                resolve(status);
+              } catch (error) {
+                transportFailure(error);
+              }
+              return;
             }
-            return;
-          }
-          if (message.type === "error") {
-            settled = true;
-            const diagnostic = "python: " + (typeof message.message === "string" ? message.message : "Python worker failed") + "\n";
-            const work2 = writeBytes(stderrOperation.output, new TextEncoder().encode(diagnostic), signal).then(
-              () => {
-                pending.delete(work2);
-                resolve(1);
+            if (message.type === "error") {
+              fail(reportPythonFailure(isPythonFailureCategory(message.category) ? message.category : ready ? "runtime" : "startup", message.message, options.onDiagnostic));
+              return;
+            }
+            if (typeof message.op !== "string" || !Array.isArray(message.args) || pending.size) {
+              transportFailure(new TypeError("Invalid concurrent Python worker request"));
+              return;
+            }
+            const work = dispatch({ op: message.op, args: message.args }).then(
+              (value2) => {
+                pending.delete(work);
+                reply(value2, 1);
               },
-              (error) => {
-                pending.delete(work2);
-                reject(error);
+              async (error) => {
+                if (signal.aborted) {
+                  pending.delete(work);
+                  fail(signal.reason);
+                  return;
+                }
+                if (typeof message.op === "string" && message.op.startsWith("package-")) {
+                  const failure2 = reportPythonFailure("runtime-assets", error, options.onDiagnostic);
+                  pending.delete(work);
+                  reply({ code: "EPACKAGE", message: failure2.message }, 2);
+                  return;
+                }
+                if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string") {
+                  pending.delete(work);
+                  fail(error);
+                  return;
+                }
+                if (error.code === "ENOTSUP") {
+                  const category = message.op === "open" ? "filesystem-open" : message.op === "read" ? "filesystem-read" : message.op === "write" || message.op === "ftruncate" ? "filesystem-write" : message.op === "readdir" ? "filesystem-directory" : "filesystem-operation";
+                  if (!filesystemDiagnostics.has(category)) {
+                    filesystemDiagnostics.add(category);
+                    const failure2 = reportPythonFailure(category, error, options.onDiagnostic);
+                    await writeBytes(stderrOperation.output, new TextEncoder().encode("python: " + failure2.message + "\n"), signal);
+                  }
+                }
+                pending.delete(work);
+                reply({ code: error.code }, 2);
               }
             );
-            pending.add(work2);
-            return;
-          }
-          if (typeof message.op !== "string" || !Array.isArray(message.args) || pending.size) {
-            fail(new TypeError("Invalid concurrent Python worker request"));
-            return;
-          }
-          const work = dispatch({ op: message.op, args: message.args }).then(
-            (value2) => {
-              pending.delete(work);
-              reply(value2, 1);
-            },
-            (error) => {
+            pending.add(work);
+            void work.catch((reason) => {
               pending.delete(work);
-              if (signal.aborted) {
-                fail(signal.reason);
-                return;
-              }
-              if (typeof message.op === "string" && message.op.startsWith("package-")) {
-                reply({ code: "EPACKAGE", message: error instanceof Error ? error.message : String(error) }, 2);
-                return;
-              }
-              if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string") {
-                fail(error);
-                return;
-              }
-              reply({ code: error.code }, 2);
-            }
-          );
-          pending.add(work);
-          void work.catch(fail);
-        }, fail);
+              fail(reason);
+            });
+          }, transportFailure);
+        } catch (reason) {
+          transportFailure(reason);
+        }
         if (settled) return;
         const start = { type: "start", shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes, ...packages ? { packages } : {}, installOnly: !!installation };
         signal.throwIfAborted();
-        endpoint.postMessage(start);
+        try {
+          endpoint.postMessage(start);
+        } catch (reason) {
+          transportFailure(reason);
+        }
       });
     } catch (reason) {
-      if (!signal.aborted && (reason instanceof PythonInputChunkError || reason instanceof Error && "code" in reason && reason.code === "EPACKAGE")) {
+      if (!signal.aborted && reason instanceof PythonInputChunkError) {
         try {
           await writeBytes(stderrOperation.output, new TextEncoder().encode("python: " + reason.message + "\n"), signal);
         } catch (error) {
           primary = { reason: error };
         }
+      } else if (!signal.aborted && typeof reason === "object" && reason !== null && "code" in reason && reason.code === "EPACKAGE") {
+        primary = { reason: reportPythonFailure("runtime-assets", reason, options.onDiagnostic) };
       } else primary = { reason };
     }
     try {
@@ -1493,7 +1529,12 @@ function createPythonCommands(options) {
       primary ??= { reason };
     }
     context.signal.throwIfAborted();
-    if (primary) throw primary.reason;
+    if (primary) {
+      if (!(primary.reason instanceof PythonFailure)) throw primary.reason;
+      const failure2 = primary.reason;
+      await writeBytes(context.stderr, new TextEncoder().encode("python: " + failure2.message + "\n"), context.signal);
+      return { exitCode: 1 };
+    }
     return { exitCode: result };
   };
   return ["python", "python3"].map((name) => ({ name, description: "Python with an explicit synchronous interpreter worker and canonical filesystem", execute }));
@@ -1525,4 +1566,4 @@ export {
   createPythonCommands,
   pythonCommands
 };
-//# sourceMappingURL=chunk-IX6VL7KM.js.map
+//# sourceMappingURL=chunk-43HWIHXB.js.map