@jerryan/just-bash 3.6.0 → 3.6.1

package/dist/bundle/chunks/worker.js

@@ -1690,6 +1690,16 @@ var OpCode = {
   REALPATH: 13,
   RENAME: 14,
   COPY_FILE: 15,
+  // Ranged variant for write payloads larger than the data buffer.
+  // FLAGS carries the file offset (uint32); the chunk length is its
+  // DATA_LENGTH. (Reads use plain READ_FILE plus the generic
+  // READ_RESULT_RANGE assembly; only the write direction needs this.)
+  WRITE_FILE_RANGE: 17,
+  // Fetch the next slice of an oversized result (any op). The host
+  // publishes the first DATA_BUFFER bytes with the FULL length in
+  // RESULT_LENGTH and retains the complete buffer; the worker loops
+  // this op (FLAGS = offset, MODE = length) to assemble the rest.
+  READ_RESULT_RANGE: 18,
   // Special operations for I/O
   WRITE_STDOUT: 100,
   WRITE_STDERR: 101,
@@ -1718,7 +1728,8 @@ var ErrorCode = {
   IO_ERROR: 7,
   TIMEOUT: 8,
   NETWORK_ERROR: 9,
-  NETWORK_NOT_CONFIGURED: 10
+  NETWORK_NOT_CONFIGURED: 10,
+  NOT_EMPTY: 11
 };
 var Offset = {
   OP_CODE: 0,
@@ -1736,9 +1747,10 @@ var Offset = {
 var Size = {
   CONTROL_REGION: 32,
   PATH_BUFFER: 4096,
-  // 8MB limit for FS read/write, HTTP responses, and tool invocation results.
-  // Sized to handle typical OpenAPI/GraphQL responses (paginated lists, batch queries).
-  // Still well under the 64MB QuickJS memory limit per execution.
+  // 8MB transfer CHUNK size — not a semantic cap. Results larger than
+  // this are assembled transparently (READ_RESULT_RANGE), and large
+  // writes stream as WRITE_FILE_RANGE chunks. Sized to keep ordinary
+  // ops single-transfer while bounding per-transfer copies.
   DATA_BUFFER: 8388608,
   TOTAL: 8392736
   // 32 + 4096 + 8MB
@@ -1870,6 +1882,20 @@ var ProtocolBuffer = class {
     this.uint8View.set(data, Offset.DATA_BUFFER);
     this.setResultLength(data.length);
   }
+  /**
+   * Publish a result of ANY size: the first DATA_BUFFER bytes land in
+   * the data region and RESULT_LENGTH carries the FULL length. The
+   * worker detects the overflow and fetches the rest with
+   * READ_RESULT_RANGE ops (served from the host's retained buffer).
+   */
+  setResultPrefix(data) {
+    if (data.length > 2147483647) {
+      throw new Error(`Result too large: ${data.length} exceeds int32`);
+    }
+    const n = Math.min(data.length, Size.DATA_BUFFER);
+    this.uint8View.set(data.subarray(0, n), Offset.DATA_BUFFER);
+    this.setResultLength(data.length);
+  }
   getResultAsString() {
     const result = this.getResult();
     return new TextDecoder().decode(result);
@@ -1999,50 +2025,113 @@ var SyncBackend = class {
     }
     this.protocol.setStatus(Status.READY);
     this.protocol.notify();
-    const waitResult = this.protocol.waitForResult(this.operationTimeoutMs);
+    const deadline = Date.now() + this.operationTimeoutMs;
+    let waitResult = this.protocol.waitForResult(this.operationTimeoutMs);
+    while (waitResult !== "timed-out" && this.protocol.getStatus() === Status.READY) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        waitResult = "timed-out";
+        break;
+      }
+      waitResult = this.protocol.waitForResult(remaining);
+    }
     if (waitResult === "timed-out") {
       return { success: false, error: "Operation timed out" };
     }
     const status = this.protocol.getStatus();
     if (status === Status.SUCCESS) {
-      return { success: true, result: this.protocol.getResult() };
+      const totalLength = this.protocol.getResultLength();
+      if (totalLength <= Size.DATA_BUFFER) {
+        return { success: true, result: this.protocol.getResult() };
+      }
+      const content = new Uint8Array(totalLength);
+      content.set(this.protocol.getResult().subarray(0, Size.DATA_BUFFER), 0);
+      let offset = Size.DATA_BUFFER;
+      while (offset < totalLength) {
+        const length = Math.min(Size.DATA_BUFFER, totalLength - offset);
+        const slice = this.execSync(
+          OpCode.READ_RESULT_RANGE,
+          "",
+          void 0,
+          offset,
+          length
+        );
+        if (!slice.success) {
+          throw this.opError_("Failed to read result range", slice);
+        }
+        const chunk = slice.result ?? new Uint8Array(0);
+        content.set(chunk, offset);
+        offset += chunk.length;
+        if (chunk.length === 0) {
+          throw this.opError_("bridge returned an empty result slice", slice);
+        }
+      }
+      return { success: true, result: content };
     }
     return {
       success: false,
-      error: this.protocol.getResultAsString() || `Error code: ${this.protocol.getErrorCode()}`
+      error: this.protocol.getResultAsString() || // Impossible by construction: every host error path publishes a
+      // code and message. If this ever fires, the diagnostic payload
+      // must identify the exact protocol state.
+      `bridge protocol violation: op ${opCode} woke with status ${status} (wait=${waitResult}, errorCode=${this.protocol.getErrorCode()})`,
+      errorCode: this.protocol.getErrorCode()
     };
   }
+  /** Build an op failure that preserves the bridge's numeric error code,
+   * so downstream errno mapping prefers it over substring matching. */
+  opError_(fallback, result) {
+    const err = new Error(result.error || fallback);
+    err.bridgeErrorCode = result.errorCode;
+    return err;
+  }
   readFile(path) {
     const result = this.execSync(OpCode.READ_FILE, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to read file");
+      throw this.opError_("Failed to read file", result);
     }
     return result.result ?? new Uint8Array(0);
   }
   writeFile(path, data) {
-    const result = this.execSync(OpCode.WRITE_FILE, path, data);
-    if (!result.success) {
-      throw new Error(result.error || "Failed to write file");
+    if (data.length <= Size.DATA_BUFFER) {
+      const result = this.execSync(OpCode.WRITE_FILE, path, data);
+      if (!result.success) {
+        throw this.opError_("Failed to write file", result);
+      }
+      return;
+    }
+    let offset = 0;
+    while (offset < data.length) {
+      const chunk = data.subarray(offset, offset + Size.DATA_BUFFER);
+      const result = this.execSync(
+        OpCode.WRITE_FILE_RANGE,
+        path,
+        chunk,
+        offset
+      );
+      if (!result.success) {
+        throw this.opError_("Failed to write file", result);
+      }
+      offset += chunk.length;
     }
   }
   stat(path) {
     const result = this.execSync(OpCode.STAT, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to stat");
+      throw this.opError_("Failed to stat", result);
     }
     return this.protocol.decodeStat();
   }
   lstat(path) {
     const result = this.execSync(OpCode.LSTAT, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to lstat");
+      throw this.opError_("Failed to lstat", result);
     }
     return this.protocol.decodeStat();
   }
   readdir(path) {
     const result = this.execSync(OpCode.READDIR, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to readdir");
+      throw this.opError_("Failed to readdir", result);
     }
     return JSON.parse(this.protocol.getResultAsString());
   }
@@ -2050,7 +2139,7 @@ var SyncBackend = class {
     const flags = recursive ? Flags.MKDIR_RECURSIVE : 0;
     const result = this.execSync(OpCode.MKDIR, path, void 0, flags);
     if (!result.success) {
-      throw new Error(result.error || "Failed to mkdir");
+      throw this.opError_("Failed to mkdir", result);
     }
   }
   rm(path, recursive = false, force = false) {
@@ -2059,7 +2148,7 @@ var SyncBackend = class {
     if (force) flags |= Flags.FORCE;
     const result = this.execSync(OpCode.RM, path, void 0, flags);
     if (!result.success) {
-      throw new Error(result.error || "Failed to rm");
+      throw this.opError_("Failed to rm", result);
     }
   }
   exists(path) {
@@ -2072,33 +2161,33 @@ var SyncBackend = class {
   appendFile(path, data) {
     const result = this.execSync(OpCode.APPEND_FILE, path, data);
     if (!result.success) {
-      throw new Error(result.error || "Failed to append file");
+      throw this.opError_("Failed to append file", result);
     }
   }
   symlink(target, linkPath) {
     const targetData = new TextEncoder().encode(target);
     const result = this.execSync(OpCode.SYMLINK, linkPath, targetData);
     if (!result.success) {
-      throw new Error(result.error || "Failed to symlink");
+      throw this.opError_("Failed to symlink", result);
     }
   }
   readlink(path) {
     const result = this.execSync(OpCode.READLINK, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to readlink");
+      throw this.opError_("Failed to readlink", result);
     }
     return this.protocol.getResultAsString();
   }
   chmod(path, mode) {
     const result = this.execSync(OpCode.CHMOD, path, void 0, 0, mode);
     if (!result.success) {
-      throw new Error(result.error || "Failed to chmod");
+      throw this.opError_("Failed to chmod", result);
     }
   }
   realpath(path) {
     const result = this.execSync(OpCode.REALPATH, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to realpath");
+      throw this.opError_("Failed to realpath", result);
     }
     return this.protocol.getResultAsString();
   }
@@ -2106,28 +2195,28 @@ var SyncBackend = class {
     const newPathData = new TextEncoder().encode(newPath);
     const result = this.execSync(OpCode.RENAME, oldPath, newPathData);
     if (!result.success) {
-      throw new Error(result.error || "Failed to rename");
+      throw this.opError_("Failed to rename", result);
     }
   }
   copyFile(src, dest) {
     const destData = new TextEncoder().encode(dest);
     const result = this.execSync(OpCode.COPY_FILE, src, destData);
     if (!result.success) {
-      throw new Error(result.error || "Failed to copyFile");
+      throw this.opError_("Failed to copyFile", result);
     }
   }
   writeStdout(data) {
     const encoded = new TextEncoder().encode(data);
     const result = this.execSync(OpCode.WRITE_STDOUT, "", encoded);
     if (!result.success) {
-      throw new Error(result.error || "Failed to write stdout");
+      throw this.opError_("Failed to write stdout", result);
     }
   }
   writeStderr(data) {
     const encoded = new TextEncoder().encode(data);
     const result = this.execSync(OpCode.WRITE_STDERR, "", encoded);
     if (!result.success) {
-      throw new Error(result.error || "Failed to write stderr");
+      throw this.opError_("Failed to write stderr", result);
     }
   }
   exit(code) {
@@ -2141,7 +2230,7 @@ var SyncBackend = class {
     const requestData = options ? new TextEncoder().encode(JSON.stringify(options)) : void 0;
     const result = this.execSync(OpCode.HTTP_REQUEST, url, requestData);
     if (!result.success) {
-      throw new Error(result.error || "HTTP request failed");
+      throw this.opError_("HTTP request failed", result);
     }
     const responseJson = new TextDecoder().decode(result.result);
     const parsed = JSON.parse(responseJson);
@@ -2164,7 +2253,7 @@ var SyncBackend = class {
     const requestData = stdin ? new TextEncoder().encode(JSON.stringify({ stdin })) : void 0;
     const result = this.execSync(OpCode.EXEC_COMMAND, command, requestData);
     if (!result.success) {
-      throw new Error(result.error || "Command execution failed");
+      throw this.opError_("Command execution failed", result);
     }
     const responseJson = new TextDecoder().decode(result.result);
     return JSON.parse(responseJson);
@@ -2177,7 +2266,7 @@ var SyncBackend = class {
     const requestData = new TextEncoder().encode(JSON.stringify({ args }));
     const result = this.execSync(OpCode.EXEC_COMMAND, command, requestData);
     if (!result.success) {
-      throw new Error(result.error || "Command execution failed");
+      throw this.opError_("Command execution failed", result);
     }
     const responseJson = new TextDecoder().decode(result.result);
     return JSON.parse(responseJson);
@@ -2190,7 +2279,7 @@ var SyncBackend = class {
     const requestData = argsJson ? new TextEncoder().encode(argsJson) : void 0;
     const result = this.execSync(OpCode.INVOKE_TOOL, path, requestData);
     if (!result.success) {
-      throw new Error(result.error || "Tool invocation failed");
+      throw this.opError_("Tool invocation failed", result);
     }
     return new TextDecoder().decode(result.result);
   }
@@ -2321,26 +2410,50 @@ function createHOSTFS(backend, FS, PATH, configuredMaxFileSize) {
     parts.reverse();
     return PATH.join(...parts);
   }
+  function errnoFromError(e) {
+    const bridgeCode = e?.bridgeErrorCode;
+    if (typeof bridgeCode === "number" && bridgeCode !== ErrorCode.NONE) {
+      switch (bridgeCode) {
+        case ErrorCode.NOT_FOUND:
+          return ERRNO_CODES.ENOENT;
+        case ErrorCode.IS_DIRECTORY:
+          return ERRNO_CODES.EISDIR;
+        case ErrorCode.NOT_DIRECTORY:
+          return ERRNO_CODES.ENOTDIR;
+        case ErrorCode.EXISTS:
+          return ERRNO_CODES.EEXIST;
+        case ErrorCode.PERMISSION_DENIED:
+          return ERRNO_CODES.EACCES;
+        case ErrorCode.NOT_EMPTY:
+          return ERRNO_CODES.ENOTEMPTY;
+        case ErrorCode.INVALID_PATH:
+          return ERRNO_CODES.EINVAL;
+        default:
+          return ERRNO_CODES.EIO;
+      }
+    }
+    const msg = e?.message?.toLowerCase() || (typeof e === "string" ? e.toLowerCase() : "");
+    let code = ERRNO_CODES.EIO;
+    if (msg.includes("no such file") || msg.includes("not found")) {
+      code = ERRNO_CODES.ENOENT;
+    } else if (msg.includes("is a directory")) {
+      code = ERRNO_CODES.EISDIR;
+    } else if (msg.includes("not a directory")) {
+      code = ERRNO_CODES.ENOTDIR;
+    } else if (msg.includes("already exists")) {
+      code = ERRNO_CODES.EEXIST;
+    } else if (msg.includes("permission")) {
+      code = ERRNO_CODES.EACCES;
+    } else if (msg.includes("not empty")) {
+      code = ERRNO_CODES.ENOTEMPTY;
+    }
+    return code;
+  }
   function tryFSOperation(f) {
     try {
       return f();
     } catch (e) {
-      const msg = e?.message?.toLowerCase() || (typeof e === "string" ? e.toLowerCase() : "");
-      let code = ERRNO_CODES.EIO;
-      if (msg.includes("no such file") || msg.includes("not found")) {
-        code = ERRNO_CODES.ENOENT;
-      } else if (msg.includes("is a directory")) {
-        code = ERRNO_CODES.EISDIR;
-      } else if (msg.includes("not a directory")) {
-        code = ERRNO_CODES.ENOTDIR;
-      } else if (msg.includes("already exists")) {
-        code = ERRNO_CODES.EEXIST;
-      } else if (msg.includes("permission")) {
-        code = ERRNO_CODES.EACCES;
-      } else if (msg.includes("not empty")) {
-        code = ERRNO_CODES.ENOTEMPTY;
-      }
-      throw new FS.ErrnoError(code);
+      throw new FS.ErrnoError(errnoFromError(e));
     }
   }
   function getMode(path) {
@@ -2491,11 +2604,12 @@ function createHOSTFS(backend, FS, PATH, configuredMaxFileSize) {
           } else {
             content = backend.readFile(path);
           }
-        } catch (_e) {
-          if (isCreate && isWrite) {
+        } catch (e) {
+          const code = errnoFromError(e);
+          if (code === ERRNO_CODES.ENOENT && isCreate && isWrite) {
             content = new Uint8Array(0);
           } else {
-            throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+            throw new FS.ErrnoError(code);
           }
         }
         if (content.length > maxFileSize) {