@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-FKKB5X5V.js

@@ -0,0 +1,97 @@
+import {
+  CurlError,
+  defaultNetworkLimits
+} from "./chunk-IYPAQ7PH.js";
+import {
+  scheduleNetworkDeadline
+} from "./chunk-KWESKQHR.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/shared.ts
+init_buffer();
+import { collectBytes, readBytes } from "../../safe-bash-contracts/index.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+var encode = (text) => new TextEncoder().encode(text);
+function limitsFor(overrides = {}) {
+  const result = { ...defaultNetworkLimits, ...overrides };
+  for (const [name, value] of Object.entries(overrides)) {
+    const minimum = name === "maxRedirects" || name === "maxRetries" ? 0 : 1;
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < minimum)) {
+      throw new RangeError(`Invalid network limit: ${name}`);
+    }
+  }
+  return Object.freeze(result);
+}
+async function withSignal(operation, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve().then(operation).then((value) => {
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+}
+async function delay(milliseconds, signal) {
+  let cancel;
+  try {
+    await withSignal(() => new Promise((resolve) => {
+      cancel = scheduleNetworkDeadline(milliseconds, resolve);
+    }), signal);
+  } finally {
+    cancel?.();
+  }
+}
+function header(headers, name) {
+  return headers.find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+}
+function networkError(error) {
+  if (error instanceof CurlError) return error;
+  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+  if (["ENOTFOUND", "EAI_AGAIN"].includes(code)) return new CurlError(6, "Could not resolve host");
+  if (["ECONNREFUSED", "ENETUNREACH", "EHOSTUNREACH"].includes(code)) return new CurlError(7, "Failed to connect");
+  if (/CERT|SELF_SIGNED|UNABLE_TO_VERIFY/.test(code)) return new CurlError(60, "TLS certificate verification failed");
+  if (/TLS|SSL/.test(code)) return new CurlError(35, "TLS handshake failed");
+  return new CurlError(56, "Network transfer failed");
+}
+async function diagnostic(context, error) {
+  await writeDiagnostic(context.stderr, `${context.command}: (${error.exitCode}) ${error.message}
+`, context.signal);
+}
+async function collectNetworkBytes(source, options) {
+  if (Number.isFinite(options.maxBytes)) return collectBytes(source, options);
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of readBytes(source, options.signal)) {
+    chunks.push(new Uint8Array(chunk));
+    size += chunk.length;
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+
+export {
+  encode,
+  limitsFor,
+  withSignal,
+  delay,
+  header,
+  networkError,
+  diagnostic,
+  collectNetworkBytes
+};

package/dist/safe-bash/command-chunks/chunk-FXELCPFX.js

@@ -0,0 +1,195 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/sync.ts
+init_buffer();
+import { gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+import { encoder } from "../../safe-bash-io-engine/internal.js";
+var syncDiffDecoder = new TextDecoder("utf-8", { fatal: false });
+function evalSyncPatch(inBytes, opArgs, readFileSync, writeFileSync) {
+  const gnuInfo = gnuInformationSync("patch", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  if (!readFileSync || !writeFileSync) return void 0;
+  let strip;
+  let quiet = false;
+  let reverse = false;
+  let dryRun = false;
+  let outputPath;
+  let inputPath;
+  let ended = false;
+  const operands = [];
+  for (let i = 0; i < opArgs.length; i++) {
+    const a = opArgs[i];
+    if (ended || !a.startsWith("-") || a === "-") {
+      operands.push(a);
+      continue;
+    }
+    if (a === "--") {
+      ended = true;
+      continue;
+    }
+    if (a === "-s" || a === "--quiet" || a === "--silent") {
+      quiet = true;
+      continue;
+    }
+    if (a === "-R" || a === "--reverse") {
+      reverse = true;
+      continue;
+    }
+    if (a === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (a === "-N" || a === "--forward" || a === "-f" || a === "--force" || a === "-t" || a === "--batch" || a === "-u" || a === "--unified") {
+      continue;
+    }
+    if (a === "-o" || a === "--output") {
+      outputPath = opArgs[++i];
+      if (!outputPath) return void 0;
+      continue;
+    }
+    if (a.startsWith("-o") && a.length > 2) {
+      outputPath = a.slice(2);
+      continue;
+    }
+    if (a.startsWith("--output=")) {
+      outputPath = a.slice(9);
+      if (!outputPath) return void 0;
+      continue;
+    }
+    if (a === "-p" || a === "--strip") {
+      const v = opArgs[++i];
+      if (!v || !/^\d+$/.test(v)) return void 0;
+      strip = Number(v);
+      continue;
+    }
+    if (a.startsWith("-p") && /^\d+$/.test(a.slice(2))) {
+      strip = Number(a.slice(2));
+      continue;
+    }
+    if (a.startsWith("--strip=") && /^\d+$/.test(a.slice(8))) {
+      strip = Number(a.slice(8));
+      continue;
+    }
+    if (a === "-i" || a === "--input") {
+      inputPath = opArgs[++i];
+      if (!inputPath) return void 0;
+      continue;
+    }
+    if (a.startsWith("--input=")) {
+      inputPath = a.slice(8);
+      continue;
+    }
+    return void 0;
+  }
+  if (operands.length > 2) return void 0;
+  const targetArg = operands[0];
+  const patchFileArg = inputPath ?? operands[1];
+  const patchBytes = patchFileArg && patchFileArg !== "-" ? readFileSync(patchFileArg) : inBytes;
+  if (!patchBytes || patchBytes.includes(0)) return void 0;
+  const patchText = syncDiffDecoder.decode(patchBytes);
+  const lines = patchText.split("\n");
+  let headerOld;
+  let headerNew;
+  let idx = 0;
+  while (idx < lines.length && !lines[idx].startsWith("@@ ")) {
+    if (lines[idx].startsWith("--- ")) {
+      headerOld = lines[idx].slice(4).split("	")[0].trim();
+    } else if (lines[idx].startsWith("+++ ")) {
+      headerNew = lines[idx].slice(4).split("	")[0].trim();
+    }
+    idx++;
+  }
+  if (idx >= lines.length) return void 0;
+  let resolvedTarget = targetArg;
+  if (!resolvedTarget) {
+    const hdr = headerNew && headerNew !== "/dev/null" ? headerNew : headerOld;
+    if (!hdr || hdr === "/dev/null") return void 0;
+    if (strip !== void 0) {
+      const parts = hdr.split("/");
+      if (parts.length <= strip) return void 0;
+      resolvedTarget = parts.slice(strip).join("/");
+    } else {
+      resolvedTarget = hdr.split("/").pop() || hdr;
+    }
+  }
+  if (!resolvedTarget) return void 0;
+  const origBytes = readFileSync(resolvedTarget);
+  if (origBytes && origBytes.includes(0)) return void 0;
+  const isNewFile = !origBytes && (reverse ? headerNew === "/dev/null" : headerOld === "/dev/null");
+  if (!origBytes && !isNewFile) return void 0;
+  const origText = origBytes ? syncDiffDecoder.decode(origBytes) : "";
+  let hasTrailingNewline = origText === "" ? true : origText.endsWith("\n");
+  const origLines = origText === "" ? [] : origText.endsWith("\n") ? origText.slice(0, -1).split("\n") : origText.split("\n");
+  const outLines = [];
+  let origPos = 0;
+  let lastHunkOp = " ";
+  while (idx < lines.length) {
+    const line = lines[idx];
+    if (!line.startsWith("@@ ")) {
+      if (line === "") {
+        idx++;
+        continue;
+      }
+      return void 0;
+    }
+    const m = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!m) return void 0;
+    const startLineNum = Number(reverse ? m[3] : m[1]);
+    const oldStart = startLineNum === 0 ? 0 : startLineNum - 1;
+    if (oldStart < origPos || oldStart > origLines.length) return void 0;
+    while (origPos < oldStart) outLines.push(origLines[origPos++]);
+    idx++;
+    while (idx < lines.length && !lines[idx].startsWith("@@ ")) {
+      const hl = lines[idx];
+      if (hl === "" && idx === lines.length - 1) {
+        idx++;
+        break;
+      }
+      const rawPrefix = hl[0];
+      const prefix = reverse ? rawPrefix === "+" ? "-" : rawPrefix === "-" ? "+" : rawPrefix : rawPrefix;
+      const body = hl.slice(1);
+      if (prefix === " ") {
+        if (origLines[origPos] !== body) return void 0;
+        outLines.push(body);
+        origPos++;
+        lastHunkOp = " ";
+      } else if (prefix === "-") {
+        if (origLines[origPos] !== body) return void 0;
+        origPos++;
+        if (origPos === origLines.length) hasTrailingNewline = true;
+        lastHunkOp = "-";
+      } else if (prefix === "+") {
+        outLines.push(body);
+        if (origPos === origLines.length) hasTrailingNewline = true;
+        lastHunkOp = "+";
+      } else if (hl.startsWith("\\ No newline")) {
+        if (lastHunkOp === "+" || lastHunkOp === " " && origPos === origLines.length) {
+          hasTrailingNewline = false;
+        }
+      } else {
+        return void 0;
+      }
+      idx++;
+    }
+  }
+  while (origPos < origLines.length) outLines.push(origLines[origPos++]);
+  const resultText = outLines.length === 0 ? "" : outLines.join("\n") + (hasTrailingNewline ? "\n" : "");
+  if (outputPath === "-") {
+    return resultText;
+  }
+  const destPath = outputPath ?? resolvedTarget;
+  if (!dryRun && outputPath !== "/dev/null") {
+    if (!writeFileSync(destPath, encoder.encode(resultText), false)) return void 0;
+  }
+  if (quiet) return "";
+  const verb = dryRun ? "checking" : "patching";
+  const label = outputPath !== void 0 ? `${outputPath} (read from ${resolvedTarget})` : resolvedTarget;
+  return `${verb} file ${label}
+`;
+}
+
+export {
+  evalSyncPatch
+};

package/dist/safe-bash/command-chunks/{chunk-JCNNOMBV.js → chunk-GI4CJED2.js}

@@ -1,12 +1,12 @@
 import {
   describe
-} from "./chunk-YZ5SVZFD.js";
+} from "./chunk-UMDIOL3O.js";
 import {
   JqError,
   JqLimitError,
   object,
   put
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -93,5 +93,6 @@ async function* capture(input, pattern, modifiers, budget) {
 }
 
 export {
+  extendedPattern,
   capture
 };

package/dist/safe-bash/command-chunks/{chunk-CU5RLO62.js → chunk-GLOZX57Y.js}

@@ -308,6 +308,13 @@ async function patterns(context, args, limits) {
   }
   return patterns2;
 }
+function relativeMatch(match, offset) {
+  return {
+    start: match.start - offset,
+    end: match.end - offset,
+    ...match.captures ? { captures: new Map([...match.captures].map(([key, span]) => [key, { start: span.start - offset, end: span.end - offset }])) } : {}
+  };
+}
 async function searchFile(context, args, limits, matcher, printer, target, stdin, filename) {
   const totals = stats();
   totals.searches = 1;
@@ -320,7 +327,7 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
     const rawBytes = source instanceof Uint8Array ? source : await collectBytes(source, { maxBytes: limits.maxFileBytes, signal: context.signal });
     source = rawBytes;
     crossLineMatches = matcher.matchBuffer(rawBytes, true);
-    if (args.onlyMatching && !args.invert && args.mode === "lines") {
+    if (args.onlyMatching && args.replacement === void 0 && !args.invert && args.mode === "lines") {
       state.bytesRead = rawBytes.length;
       state.bytesSearched = rawBytes.length;
       const selectedOutput2 = !args.quiet;
@@ -343,18 +350,17 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
         totals.matches++;
         if (args.quiet && !args.stats) break;
         if (selectedOutput2) {
-          const rawBuf = bytesFrom(rawBytes);
           const syntheticLine = {
             number: lineNum,
             offset: lineStart,
-            rawBytes: rawBuf.subarray(m.start, m.end),
+            rawBytes: rawBytes.subarray(m.start, m.end),
             rawLength: m.end - m.start,
-            content: rawBuf,
-            bytes: rawBuf,
+            content: rawBytes.subarray(lineStart),
+            bytes: rawBytes.subarray(lineStart),
             all: true,
             terminated: true
           };
-          await printer.record(target.label, syntheticLine, [{ start: m.start, end: m.end }], true, filename);
+          await printer.record(target.label, syntheticLine, [relativeMatch(m, lineStart)], true, filename, true, endLine - lineNum + 1);
         }
       }
       if (limits.outPos > 0) await limits.flush();
@@ -372,6 +378,7 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
   let begun = false;
   let binaryPrinted = false;
   let lastSelectedEnd = 0;
+  let selectedCount = 0;
   let fileOutputStart = limits.outputBytes;
   const begin = async () => {
     if (begun) return;
@@ -383,7 +390,63 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
   const binaryOutput = selectedOutput && args.mode === "lines" && binary === "binary";
   const needAll = args.replacement !== void 0 || args.onlyMatching || args.mode === "json" || args.mode === "matches" || args.stats === true;
   const batchSize = () => Number.isFinite(args.maxCount) || args.quiet && args.mode !== "json" || args.mode === "with" || args.mode === "without" || binaryOutput && state.binaryOffset !== null ? 1 : 128;
-  const syncBatches = source instanceof Uint8Array ? trySyncLineBatches(source, limits, state, binary, args.nullData, batchSize, needAll, args.crlf) : void 0;
+  let syncBatches = source instanceof Uint8Array ? trySyncLineBatches(source, limits, state, binary, args.nullData, batchSize, needAll, args.crlf) : void 0;
+  let replacementGroups;
+  if (crossLineMatches && args.replacement !== void 0 && args.mode === "lines" && !args.invert && source instanceof Uint8Array) {
+    const records = syncBatches?.flat() ?? [];
+    if (syncBatches === void 0) {
+      for await (const batch of lineBatches(source, limits, state, binary, args.nullData, batchSize, needAll, args.crlf)) records.push(...batch);
+    }
+    replacementGroups = /* @__PURE__ */ new Map();
+    const grouped = [];
+    let matchIndex = 0;
+    let blocks = 0;
+    for (let index = 0; index < records.length; index++) {
+      const first = records[index];
+      let last = first;
+      let end = last.offset + last.rawLength;
+      const matches = [];
+      while (matchIndex < crossLineMatches.length) {
+        const match = crossLineMatches[matchIndex];
+        if (match.start >= end && !(match.start === end && !last.terminated)) break;
+        while (match.end > end && index + 1 < records.length) {
+          last = records[++index];
+          end = last.offset + last.rawLength;
+        }
+        matches.push(relativeMatch(match, first.offset));
+        matchIndex++;
+      }
+      if (matches.length === 0) {
+        grouped.push(first);
+        continue;
+      }
+      const previous = grouped.at(-1);
+      const previousGroup = previous && replacementGroups.get(previous);
+      const mergePrevious = previousGroup && previous.offset + previous.rawLength === first.offset && blocks < args.maxCount;
+      const start = mergePrevious ? previous : first;
+      const combinedMatches = mergePrevious ? previousGroup.matches : matches;
+      if (mergePrevious) for (const match of matches) combinedMatches.push(relativeMatch(match, previous.offset - first.offset));
+      const bytes = source.subarray(start.offset, end);
+      const line = {
+        number: start.number,
+        offset: start.offset,
+        rawBytes: bytes,
+        rawLength: bytes.length,
+        content: bytes,
+        bytes,
+        all: true,
+        terminated: last.terminated
+      };
+      if (mergePrevious) {
+        grouped.pop();
+        replacementGroups.delete(previous);
+      }
+      replacementGroups.set(line, { matches: combinedMatches, lines: last.number - start.number + 1, blocks: (mergePrevious ? previousGroup.blocks : 0) + 1 });
+      grouped.push(line);
+      blocks++;
+    }
+    syncBatches = [grouped];
+  }
   let syncIdx = 0;
   let asyncIter;
   let failure;
@@ -403,6 +466,8 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
         batch = next.value;
       }
       const batchRes = crossLineMatches !== void 0 ? batch.map((line) => {
+        const group = replacementGroups?.get(line);
+        if (group) return group.matches;
         const lineStart = line.offset;
         const lineEnd = line.offset + line.content.length;
         const lineMatches = [];
@@ -428,12 +493,15 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
           break records;
         }
         const matches = results[index];
-        const matchCount = crossLineMatches === void 0 ? matches.length : crossLineMatches.reduce((count, match) => count + Number(match.start >= line.offset && match.start <= line.offset + line.content.length), 0);
-        const limitedInvertedTail = args.invert && totals.matched_lines >= args.maxCount && after > 0 && line.rawLength === line.content.length;
+        const replacementGroup = replacementGroups?.get(line);
+        const lineCount = replacementGroup?.lines ?? 1;
+        const matchCount = crossLineMatches === void 0 || replacementGroup ? matches.length : crossLineMatches.reduce((count, match) => count + Number(match.start >= line.offset && match.start <= line.offset + line.content.length), 0);
+        const limitedInvertedTail = args.invert && selectedCount >= args.maxCount && after > 0 && line.rawLength === line.content.length;
         const selected = matches.length > 0 !== args.invert || limitedInvertedTail;
         if (selected) lastSelectedEnd = line.offset + line.rawLength;
-        if (selected && totals.matched_lines < args.maxCount) {
-          totals.matched_lines++;
+        if (selected && selectedCount < args.maxCount) {
+          selectedCount += replacementGroup?.blocks ?? 1;
+          totals.matched_lines += lineCount;
           totals.matches += args.invert ? 0 : matchCount;
           if (!args.stats && (args.quiet && args.mode !== "json" || args.mode === "with" || args.mode === "without")) break records;
           if (selectedOutput) {
@@ -451,21 +519,22 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
                 lastPrinted = previous.line.number;
               }
             }
-            await printer.record(target.label, line, args.invert ? [] : matches, true, filename);
-            lastPrinted = line.number;
+            await printer.record(target.label, line, args.invert ? [] : matches, true, filename, replacementGroup !== void 0, lineCount);
+            lastPrinted = line.number + lineCount - 1;
             after = args.after;
           }
         } else if (after && selectedOutput) {
           if (selected) {
-            totals.matched_lines++;
+            selectedCount += replacementGroup?.blocks ?? 1;
+            totals.matched_lines += lineCount;
             totals.matches += args.invert && !limitedInvertedTail ? 0 : matchCount;
           }
-          await printer.record(target.label, line, matches, selected, filename);
-          lastPrinted = line.number;
+          await printer.record(target.label, line, matches, selected, filename, replacementGroup !== void 0, lineCount);
+          lastPrinted = line.number + lineCount - 1;
           after--;
         }
         if (binaryOutput && args.before > 0 && state.binaryOffset !== null) break records;
-        if (totals.matched_lines >= args.maxCount && (!selectedOutput || after === 0)) {
+        if (selectedCount >= args.maxCount && (!selectedOutput || after === 0)) {
           state.bytesSearched = Math.max(lastSelectedEnd, args.invert || line.rawLength === line.content.length ? line.offset : 0);
           break records;
         }
@@ -655,6 +724,11 @@ function tryExecuteRgFastSync(context, executor, options) {
     runner.abortedToSlow = false;
     const walkRes = runner.walker.walkTargetsSyncOrAsync(selPaths, selImplicit, runner.boundOnTarget, true);
     if (runner.abortedToSlow || walkRes !== void 0) {
+      const pending = walkRes ?? limits.tick();
+      if (pending) {
+        pendingFlush = true;
+        return pending.finally(runner.release).then(() => executeRgSlow(context, executor, options));
+      }
       return void 0;
     }
     if (cArgs.length === 3 && cArgs[0] === "-c" && totals.searches === 64 && limits.outPos >= 0 && Date.now === defaultDateNowRg && cArgs[2].charCodeAt(0) === 47 && tryVerifyAndPopulate64Tree(fastMem, cArgs[2], false)) {
@@ -841,7 +915,7 @@ Default input depends on shell configuration.
 
   -e, --regexp=PATTERN     Add a pattern (repeatable)
   -f, --file=FILE          Read patterns from FILE
-  -r, --replace=TEXT       Replace matches with literal TEXT
+  -r, --replace=TEXT       Replace matches with text and capture references
       --trim              Trim leading ASCII whitespace
   -F, --fixed-strings      Use fixed strings
       --max-filesize=SIZE  Filter discovered files (bytes or K/M/G)