@poe-platform/safe-bash 0.1.58 → 0.1.60

package/dist/safe-bash/browser.js

@@ -2796,17 +2796,6 @@ function concatenate(chunks, size = chunks.reduce((sum, chunk) => sum + chunk.le
   }
   return result;
 }
-async function collect(source, signal, limit = bufferLimit) {
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of source) {
-    signal.throwIfAborted();
-    size += chunk.length;
-    if (size > limit) throw new FsError("EFBIG", { message: `buffer limit exceeded (${limit} bytes)` });
-    chunks.push(new Uint8Array(chunk));
-  }
-  return concatenate(chunks, size);
-}
 async function* lines(source, separator = 10) {
   let pending = [];
   let size = 0;
@@ -10197,6 +10186,13 @@ function activeIO(io) {
     ...error?.closed && error.output === io.stderr ? { stderr: closedSink } : {}
   };
 }
+function appendOutputBytes(current, chunk) {
+  const length = current.length + chunk.length;
+  const bytes2 = current.buffer.byteLength - current.byteOffset >= length ? new Uint8Array(current.buffer, current.byteOffset, length) : new Uint8Array(Math.max(length, current.length * 2, 64));
+  if (bytes2.buffer !== current.buffer) bytes2.set(current);
+  bytes2.set(chunk, current.length);
+  return bytes2.subarray(0, length);
+}
 var Flow = class extends Error {
   constructor(kind, status, levels = 1) {
     super(kind);
@@ -12167,22 +12163,27 @@ var Runtime = class _Runtime {
                 return this.fileOperation(path, async () => {
                   if (closed) throw new Error("Output descriptor is closed");
                   const current = file.data;
-                  if (append) {
-                    await this.fs.appendFile(path, copy2, options2);
-                    if (current) {
-                      const bytes2 = new Uint8Array(current.length + copy2.length);
-                      bytes2.set(current);
-                      bytes2.set(copy2, current.length);
-                      file.data = bytes2;
+                  let atEOF = false;
+                  if (!append && current && offset === current.length && capabilities.append === true && capabilities.stat !== false) {
+                    try {
+                      atEOF = (await interruptible(this.fs.stat(path, options2), this.signal)).size === offset;
+                    } catch {
+                      this.signal.throwIfAborted();
                     }
+                    this.signal.throwIfAborted();
+                  }
+                  if (append || atEOF) {
+                    const bytes2 = current ? appendOutputBytes(current, copy2) : void 0;
+                    await this.fs.appendFile(path, copy2, options2);
+                    file.data = bytes2;
                   } else {
                     const bytes2 = new Uint8Array(Math.max(current?.length ?? 0, offset + copy2.length));
                     if (current) bytes2.set(current);
                     bytes2.set(copy2, offset);
                     await this.fs.writeFile(path, bytes2, options2);
                     file.data = bytes2;
-                    offset += copy2.length;
                   }
+                  if (!append) offset += copy2.length;
                 });
               } };
             };
@@ -17370,6 +17371,7 @@ function sedCommand(options2 = {}) {
 
 // packages/safe-bash/src/commands/search/grep.ts
 init_platform();
+var maxPatternCount = 1024;
 function createGrepCommands(executor) {
   return [{ name: "grep", filesystemRequirements: grepRequirements, execute: (context) => withRegexSession(context, executor, async (session) => {
     try {
@@ -17382,18 +17384,44 @@ function createGrepCommands(executor) {
       const names = parsed.operands.length ? parsed.operands : ["-"];
       const patternFiles = parsed.values.get("f") ?? [];
       const patterns2 = [];
-      const addPatterns = (text, file) => {
-        if (file && text === "") return;
-        const parts = text.split("\n");
-        if (parts.length > 1 && parts.at(-1) === "") parts.pop();
-        patterns2.push(...parts);
+      let patternCount = 0;
+      let patternBytes = 0;
+      const admit = (chunk, atStart) => {
+        context.signal.throwIfAborted();
+        const size = typeof chunk === "string" ? import_buffer.Buffer.byteLength(chunk) : chunk.length;
+        if (size > bufferLimit - patternBytes) throw new UsageError(`pattern byte limit exceeded (${bufferLimit} bytes)`);
+        patternBytes += size;
+        for (let offset = 0; offset < chunk.length; ) {
+          if (atStart && ++patternCount > maxPatternCount) throw new UsageError(`pattern count limit exceeded (${maxPatternCount})`);
+          const newline = typeof chunk === "string" ? chunk.indexOf("\n", offset) : chunk.indexOf(10, offset);
+          if (newline < 0) return false;
+          offset = newline + 1;
+          atStart = true;
+        }
+        return atStart;
+      };
+      const addArgument = async (pattern) => {
+        admit(pattern, true);
+        if (pattern === "") {
+          if (++patternCount > maxPatternCount) throw new UsageError(`pattern count limit exceeded (${maxPatternCount})`);
+          patterns2.push("");
+        } else {
+          for await (const line of lines(toByteSource(pattern))) patterns2.push(import_buffer.Buffer.from(line.bytes).toString("latin1"));
+        }
       };
-      for (const pattern of parsed.values.get("e") ?? []) addPatterns(import_buffer.Buffer.from(pattern).toString("latin1"), false);
+      async function* admitted(source) {
+        let atStart = true;
+        for await (const chunk of source) {
+          atStart = admit(chunk, atStart);
+          yield chunk;
+        }
+      }
+      for (const pattern of parsed.values.get("e") ?? []) await addArgument(pattern);
       for (const name2 of patternFiles) {
-        const source = name2 === "-" ? input(context) : requiredFileInput(context, grepRequirements, "pattern-file", name2, bufferLimit);
-        addPatterns(import_buffer.Buffer.from(await collect(source, context.signal)).toString("latin1"), true);
+        const source = name2 === "-" ? input(context) : requiredFileInput(context, grepRequirements, "pattern-file", name2, bufferLimit - patternBytes);
+        for await (const line of lines(admitted(source))) patterns2.push(import_buffer.Buffer.from(line.bytes).toString("latin1"));
       }
-      if (positionalPattern !== void 0) addPatterns(import_buffer.Buffer.from(positionalPattern).toString("latin1"), false);
+      if (positionalPattern !== void 0) await addArgument(positionalPattern);
       if (parsed.flags.has("E") && parsed.flags.has("F")) throw new UsageError("conflicting matchers specified");
       const descriptor = {
         kind: "grep",