@poe-platform/safe-bash 0.1.71 → 0.1.73

package/dist/safe-bash/browser.js

@@ -3432,6 +3432,7 @@ function createDirectoryReader(maxEntries = 1e4) {
 }
 
 // packages/safe-bash/src/commands/filesystem.ts
+var MAX_RECURSIVE_DIRECTORY_DEPTH = 1024;
 async function preflightOperands(context, operands, check) {
   for (const operand of operands) {
     try {
@@ -3514,11 +3515,19 @@ async function copy(context, source, target, flags, readDirectory, top = true, a
     if (isPathWithin(physicalSource, physicalTarget)) throw new FsError("EINVAL", { path: target, message: "cannot copy a directory into itself" });
     if (ancestors.has(physicalSource)) throw new FsError("ELOOP", { path: source });
     if (targetStat && targetStat.type !== "directory") throw new FsError("ENOTDIR", { path: target });
+    context.signal.throwIfAborted();
+    if (ancestors.size > MAX_RECURSIVE_DIRECTORY_DEPTH) {
+      throw new FsError("ELOOP", { path: source, message: `cp directory depth limit exceeded (${MAX_RECURSIVE_DIRECTORY_DEPTH})` });
+    }
     await admitFilesystemModes(context, "cp", ["recursive"], [target]);
-    if (!targetStat && !preflight) await context.fs.mkdir(target, { mode: sourceStat.mode & 511, signal: context.signal });
-    const next = new Set(ancestors).add(physicalSource);
-    for (const entry of await readDirectory(context, source, true)) {
-      await copy(context, joinPath(source, entry.name), joinPath(target, entry.name), flags, readDirectory, false, next, preflight);
+    ancestors.add(physicalSource);
+    try {
+      if (!targetStat && !preflight) await context.fs.mkdir(target, { mode: sourceStat.mode & 511, signal: context.signal });
+      for (const entry of await readDirectory(context, source, true)) {
+        await copy(context, joinPath(source, entry.name), joinPath(target, entry.name), flags, readDirectory, false, ancestors, preflight);
+      }
+    } finally {
+      ancestors.delete(physicalSource);
     }
   } else if (preserveLink) {
     await admitFilesystemModes(context, "cp", ["symlink"], [target]);
@@ -3856,25 +3865,33 @@ function filesystemCommands(maxDirectoryEntries) {
         await admitFilesystemModes(context, "ls", ["directory"], [path]);
         const physical = await context.fs.realpath(path, { signal: context.signal });
         if (ancestors.has(physical)) throw new FsError("ELOOP", { path });
-        const next = new Set(ancestors).add(physical);
-        if (header) {
-          await output(context, `${headerWritten ? "\n" : ""}${display}:
-`);
-          headerWritten = true;
-        }
-        const entries = await readDirectory(context, path, true);
-        const names = entries.map((entry) => entry.name).filter((name2) => parsed.flags.has("a") || parsed.flags.has("A") || !name2.startsWith("."));
-        if (parsed.flags.has("a")) for (const name2 of [".", ".."]) {
-          const index = names.findIndex((entry) => entry > name2);
-          names.splice(index < 0 ? names.length : index, 0, name2);
+        context.signal.throwIfAborted();
+        if (ancestors.size > MAX_RECURSIVE_DIRECTORY_DEPTH) {
+          throw new FsError("ELOOP", { path, message: `ls directory depth limit exceeded (${MAX_RECURSIVE_DIRECTORY_DEPTH})` });
         }
-        if (parsed.flags.has("r")) names.reverse();
-        for (const name2 of names) await render(joinPath(path, name2), name2);
-        if (parsed.flags.has("R")) for (const name2 of names) {
-          if (name2 === "." || name2 === "..") continue;
-          const child = joinPath(path, name2);
-          const childStat = await context.fs[parsed.flags.has("L") ? "stat" : "lstat"](child, { signal: context.signal });
-          if (childStat.type === "directory") await list(child, `${display.replace(/\/$/u, "")}/${name2}`, true, next);
+        ancestors.add(physical);
+        try {
+          if (header) {
+            await output(context, `${headerWritten ? "\n" : ""}${display}:
+`);
+            headerWritten = true;
+          }
+          const entries = await readDirectory(context, path, true);
+          const names = entries.map((entry) => entry.name).filter((name2) => parsed.flags.has("a") || parsed.flags.has("A") || !name2.startsWith("."));
+          if (parsed.flags.has("a")) for (const name2 of [".", ".."]) {
+            const index = names.findIndex((entry) => entry > name2);
+            names.splice(index < 0 ? names.length : index, 0, name2);
+          }
+          if (parsed.flags.has("r")) names.reverse();
+          for (const name2 of names) await render(joinPath(path, name2), name2);
+          if (parsed.flags.has("R")) for (const name2 of names) {
+            if (name2 === "." || name2 === "..") continue;
+            const child = joinPath(path, name2);
+            const childStat = await context.fs[parsed.flags.has("L") ? "stat" : "lstat"](child, { signal: context.signal });
+            if (childStat.type === "directory") await list(child, `${display.replace(/\/$/u, "")}/${name2}`, true, ancestors);
+          }
+        } finally {
+          ancestors.delete(physical);
         }
       };
       return eachOperand(context, operands, (operand) => list(pathOf(context, operand), operand, operands.length > 1 || parsed.flags.has("R")));
@@ -18696,7 +18713,7 @@ function descriptor(value2, limits) {
   for (const flag of flags) if (typeof value2[flag] !== "boolean") fail("protocol", `invalid ${flag} flag`);
   if (kind.value === "rg" && !["sensitive", "insensitive", "smart"].includes(value2.case)) fail("protocol", "invalid case flag");
   if (value2.word || kind.value === "grep" && value2.insensitive || kind.value === "rg" && value2.case !== "sensitive") fail("unsupported", "only case-sensitive, non-word selection is supported");
-  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex and Unicode modes are unsupported; use fixed ASCII patterns");
+  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex modes are unsupported; use fixed UTF-8 patterns");
   array(value2.patterns, limits.maxPatterns, "pattern");
   let bytes2 = 0;
   for (let index = 0; index < value2.patterns.length; index++) {
@@ -18724,7 +18741,7 @@ function admit(input3, limits, signal) {
     bytes2 += length;
   }
   const ledger = new EreLedger({ maxExpansionBytes: 1048576, maxExpansionFields: 8192 }, {
-    patternBytes: limits.maxPatternBytes + 4,
+    patternBytes: limits.maxPatternBytes + (selected.fixed ? 0 : 4),
     subjectBytes: limits.maxInputBytes,
     work: limits.maxWork,
     allocationUnits: limits.maxAllocationUnits,
@@ -18770,8 +18787,116 @@ async function admitBre(pattern, ledger, signal) {
     }
   }
 }
+async function validateUtf8(input3, ledger, signal) {
+  for (let index = 0; index < input3.length; ) {
+    const first = typeof input3 === "string" ? input3.charCodeAt(index) : input3[index];
+    const width = first < 128 ? 1 : first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
+    ledger.charge("work", Math.max(width, 1), signal);
+    if (first === 0 || width === 0 || width > input3.length - index) fail("unsupported", "literal patterns and subjects require valid non-NUL UTF-8 bytes");
+    for (let continuation = 1; continuation < width; continuation++) {
+      const byte = typeof input3 === "string" ? input3.charCodeAt(index + continuation) : input3[index + continuation];
+      if (byte < 128 || byte > 191 || continuation === 1 && (first === 224 && byte < 160 || first === 237 && byte > 159 || first === 240 && byte < 144 || first === 244 && byte > 143)) fail("unsupported", "literal patterns and subjects require valid non-NUL UTF-8 bytes");
+    }
+    index += width;
+    await ledger.checkpoint(signal);
+  }
+}
+async function literalBytes(pattern, selected, ledger, signal) {
+  const { kind } = selected;
+  let length = 0;
+  if (kind === "grep") {
+    await validateUtf8(pattern, ledger, signal);
+    length = pattern.length;
+  } else {
+    for (let index = 0; index < pattern.length; ) {
+      const scalar = pattern.codePointAt(index);
+      const units = scalar > 65535 ? 2 : 1;
+      ledger.charge("work", units, signal);
+      if (scalar === 0 || scalar >= 55296 && scalar <= 57343) fail("unsupported", "rg literal patterns require non-NUL Unicode scalars for UTF-8");
+      if (scalar === 10 && selected.kind === "rg" && !selected.nullData) fail("unsupported", "rg multiline matching is unsupported");
+      length += scalar < 128 ? 1 : scalar < 2048 ? 2 : scalar < 65536 ? 3 : 4;
+      index += units;
+      await ledger.checkpoint(signal);
+    }
+  }
+  ledger.charge("patternBytes", length, signal);
+  ledger.charge("allocationUnits", length + 1, signal);
+  const bytes2 = new Uint8Array(length);
+  let offset = 0;
+  for (let index = 0; index < pattern.length; ) {
+    const scalar = kind === "grep" ? pattern.charCodeAt(index) : pattern.codePointAt(index);
+    const width = kind === "grep" || scalar < 128 ? 1 : scalar < 2048 ? 2 : scalar < 65536 ? 3 : 4;
+    ledger.charge("work", width, signal);
+    if (width === 1) bytes2[offset++] = scalar;
+    else {
+      bytes2[offset++] = width === 2 ? 192 | scalar >> 6 : width === 3 ? 224 | scalar >> 12 : 240 | scalar >> 18;
+      if (width === 4) bytes2[offset++] = 128 | scalar >> 12 & 63;
+      if (width >= 3) bytes2[offset++] = 128 | scalar >> 6 & 63;
+      bytes2[offset++] = 128 | scalar & 63;
+    }
+    index += kind === "rg" && scalar > 65535 ? 2 : 1;
+    await ledger.checkpoint(signal);
+  }
+  return bytes2;
+}
+async function compileLiteral(bytes2, ledger, signal) {
+  ledger.charge("states", bytes2.length, signal);
+  ledger.charge("allocationUnits", bytes2.length * 4 + 3, signal);
+  const fallback = new Uint32Array(bytes2.length);
+  for (let index = 1, prefix2 = 0; index < bytes2.length; ) {
+    ledger.charge("work", 1, signal);
+    if (bytes2[index] === bytes2[prefix2]) fallback[index++] = ++prefix2;
+    else if (prefix2 > 0) prefix2 = fallback[prefix2 - 1];
+    else index++;
+    await ledger.checkpoint(signal);
+  }
+  return { bytes: bytes2, fallback };
+}
+async function literalStart(program, subject, whole, ledger, signal) {
+  const { bytes: bytes2, fallback } = program;
+  ledger.charge("work", 1, signal);
+  await ledger.checkpoint(signal);
+  if (whole && bytes2.length !== subject.length || bytes2.length > subject.length) return -1;
+  if (bytes2.length === 0) return 0;
+  for (let index = 0, prefix2 = 0; index < subject.length; ) {
+    ledger.charge("work", 1, signal);
+    if (subject[index] === bytes2[prefix2]) {
+      index++;
+      if (++prefix2 === bytes2.length) return index - prefix2;
+    } else if (prefix2 > 0) prefix2 = fallback[prefix2 - 1];
+    else index++;
+    await ledger.checkpoint(signal);
+  }
+  return -1;
+}
+async function executeLiteral(input3, signal) {
+  const { descriptor: selected, rows, ledger } = input3;
+  const programs2 = [];
+  for (const pattern of selected.patterns) {
+    programs2.push(await compileLiteral(await literalBytes(pattern, selected, ledger, signal), ledger, signal));
+  }
+  const results = [];
+  for (const row of rows) {
+    await validateUtf8(row.bytes, ledger, signal);
+    let start = -1;
+    let end = -1;
+    for (const program of programs2) {
+      const candidate = await literalStart(program, row.bytes, selected.whole, ledger, signal);
+      if (candidate < 0) continue;
+      if (start < 0 || candidate < start) {
+        start = candidate;
+        end = start + program.bytes.length;
+      }
+      if (selected.kind === "grep") break;
+    }
+    signal.throwIfAborted();
+    results.push(start < 0 ? new Float64Array() : new Float64Array([start, end]));
+  }
+  return { id: input3.id, results };
+}
 async function execute2(input3, signal) {
   const { descriptor: selected, rows, ledger } = input3;
+  if (selected.fixed) return executeLiteral(input3, signal);
   const programs2 = [];
   for (const pattern of selected.patterns) {
     if (selected.kind === "grep" && !selected.fixed && !selected.extended) await admitBre(pattern, ledger, signal);