@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -0,0 +1,136 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/aes.ts
+init_buffer();
+import { ecb } from "@noble/ciphers/aes.js";
+import { equalBytes } from "@noble/ciphers/utils.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha1 } from "@noble/hashes/legacy.js";
+import { pbkdf2 } from "@noble/hashes/pbkdf2.js";
+import { collectBytes } from "../../safe-bash-contracts/index.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+function zipEncryptionProfile(profile) {
+  if (profile === "zipcrypto") return void 0;
+  const [prefix, strength, version, extra] = profile.split("-");
+  if (prefix !== "aes" || extra !== void 0 || !["128", "192", "256"].includes(strength) || !["ae1", "ae2"].includes(version)) fail("ZIP unsupported encryption profile");
+  return { strength: Number(strength), version: version === "ae1" ? 1 : 2 };
+}
+function aesParameters(aes) {
+  if (aes.version !== 1 && aes.version !== 2) fail("ZIP unsupported AES version");
+  if (aes.strength !== 128 && aes.strength !== 192 && aes.strength !== 256) fail("ZIP unsupported AES strength");
+  return { keyBytes: aes.strength / 8, saltBytes: aes.strength / 16 };
+}
+function keys(password, salt, aes, signal) {
+  signal.throwIfAborted();
+  const { keyBytes } = aesParameters(aes);
+  const derived = pbkdf2(sha1, password, salt, { c: 1e3, dkLen: keyBytes * 2 + 2 });
+  if (signal.aborted) {
+    derived.fill(0);
+    signal.throwIfAborted();
+  }
+  return derived;
+}
+async function transform(input, key, signal) {
+  const output = new Uint8Array(input.length);
+  try {
+    for (let offset = 0; offset < input.length; offset += 65536) {
+      signal.throwIfAborted();
+      const length = Math.min(65536, input.length - offset);
+      const counters = new Uint8Array(Math.ceil(length / 16) * 16);
+      const view = new DataView(counters.buffer);
+      for (let block = 0; block < counters.length; block += 16) view.setBigUint64(block, BigInt((offset + block) / 16 + 1), true);
+      const stream = ecb(key, { disablePadding: true }).encrypt(counters);
+      for (let i = 0; i < length; i++) output[offset + i] = input[offset + i] ^ stream[i];
+      stream.fill(0);
+      await yieldTurn(signal);
+    }
+    return output;
+  } catch (error) {
+    output.fill(0);
+    throw error;
+  }
+}
+async function encryptAesPayload(source, encryption, maxBytes, signal) {
+  signal.throwIfAborted();
+  const { keyBytes, saltBytes } = aesParameters(encryption.aes);
+  const aes = { ...encryption.aes };
+  const password = new Uint8Array(encryption.password);
+  let plaintext;
+  let derived;
+  try {
+    plaintext = await collectBytes(source, { ...Number.isFinite(maxBytes) ? { maxBytes } : {}, signal });
+    let supplied;
+    try {
+      supplied = await encryption.entropy(saltBytes, signal);
+    } catch {
+      signal.throwIfAborted();
+      fail("ZIP AES entropy capability failed");
+    }
+    signal.throwIfAborted();
+    if (!(supplied instanceof Uint8Array) || supplied.length !== saltBytes) fail("ZIP invalid AES entropy bytes");
+    const salt = new Uint8Array(supplied);
+    derived = keys(password, salt, aes, signal);
+    const encrypted = await transform(plaintext, derived.subarray(0, keyBytes), signal);
+    const tag = hmac(sha1, derived.subarray(keyBytes, keyBytes * 2), encrypted);
+    const wire = new Uint8Array(saltBytes + 2 + encrypted.length + 10);
+    wire.set(salt);
+    wire.set(derived.subarray(keyBytes * 2), saltBytes);
+    wire.set(encrypted, saltBytes + 2);
+    wire.set(tag.subarray(0, 10), wire.length - 10);
+    encrypted.fill(0);
+    tag.fill(0);
+    return wire;
+  } finally {
+    plaintext?.fill(0);
+    derived?.fill(0);
+    password.fill(0);
+  }
+}
+async function decryptAesPayload(wire, password, aes, maxBytes, signal) {
+  signal.throwIfAborted();
+  const { keyBytes, saltBytes } = aesParameters(aes);
+  aes = { ...aes };
+  if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError("maxBytes must be a nonnegative safe integer");
+  if (wire.length < saltBytes + 12) fail("ZIP truncated AES payload");
+  const size = wire.length - saltBytes - 12;
+  if (size > maxBytes) fail("ZIP AES authenticated staging limit exceeded");
+  const owned = new Uint8Array(wire);
+  const secret = new Uint8Array(password);
+  let derived;
+  try {
+    derived = keys(secret, owned.subarray(0, saltBytes), aes, signal);
+    if (!equalBytes(derived.subarray(keyBytes * 2), owned.subarray(saltBytes, saltBytes + 2))) fail("ZIP incorrect password");
+    const encrypted = owned.subarray(saltBytes + 2, owned.length - 10);
+    const tag = hmac(sha1, derived.subarray(keyBytes, keyBytes * 2), encrypted);
+    const authentic = equalBytes(tag.subarray(0, 10), owned.subarray(owned.length - 10));
+    tag.fill(0);
+    if (!authentic) fail("ZIP AES authentication failed");
+    return await transform(encrypted, derived.subarray(0, keyBytes), signal);
+  } finally {
+    derived?.fill(0);
+    secret.fill(0);
+    owned.fill(0);
+  }
+}
+function aesExtra(aes, method) {
+  aesParameters(aes);
+  const bytes = new Uint8Array(11);
+  const view = new DataView(bytes.buffer);
+  view.setUint16(0, 39169, true);
+  view.setUint16(2, 7, true);
+  view.setUint16(4, aes.version, true);
+  bytes.set([65, 69, aes.strength / 64 - 1], 6);
+  view.setUint16(9, method, true);
+  return bytes;
+}
+
+export {
+  zipEncryptionProfile,
+  aesParameters,
+  encryptAesPayload,
+  decryptAesPayload,
+  aesExtra
+};

package/dist/safe-bash/command-chunks/{chunk-SX2X3IH4.js → chunk-V2V5OCL3.js}

@@ -1,6 +1,6 @@
 import {
   convert
-} from "./chunk-IEXHHNOF.js";
+} from "./chunk-4J5CZ2DP.js";
 import {
   Lifecycle
 } from "./chunk-7D7JRRML.js";

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

@@ -0,0 +1,112 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-publication.ts
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { dirname, FsError, isFsError } from "../../safe-bash-contracts/index.js";
+import { host, ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+var PatchPublication = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  directories = /* @__PURE__ */ new Map();
+  removals = /* @__PURE__ */ new Map();
+  pruning = /* @__PURE__ */ new Map();
+  async capture(path, prune = []) {
+    const paths = [];
+    for (let parent = dirname(path); ; parent = dirname(parent)) {
+      paths.unshift(parent);
+      if (parent === "/") break;
+    }
+    for (const parent of paths) {
+      if (this.directories.has(parent)) continue;
+      let stat;
+      try {
+        stat = await host(this.context, () => this.context.fs.lstat(parent, { signal: this.context.signal }));
+      } catch (error) {
+        if (isFsError(error, "ENOENT")) break;
+        throw error;
+      }
+      if (stat.type !== "directory") throw new ToolError(`unsafe patch parent: ${parent}`);
+      this.directories.set(parent, stat);
+    }
+    if (this.directories.has(dirname(path)) && !this.removals.has(path)) {
+      this.removals.set(path, await host(this.context, () => this.context.fs.confineExtraction([dirname(path)], { signal: this.context.signal })));
+    }
+    const parents = prune.filter((parent) => this.directories.has(parent) && !this.pruning.has(parent));
+    if (this.directories.has(dirname(path)) && parents.length) {
+      const view = await host(this.context, () => this.context.fs.confineExtraction([dirname(path), parents.at(-1)], { signal: this.context.signal }));
+      for (const parent of parents) this.pruning.set(parent, view);
+    }
+  }
+  async write(path, text, destination, mode, mtimeMs) {
+    await this.capture(path);
+    const ancestors = [];
+    for (let parent2 = dirname(path); ; parent2 = dirname(parent2)) {
+      const stat = this.directories.get(parent2);
+      if (!stat) throw new ToolError(`patch parent does not exist: ${parent2}`);
+      ancestors.unshift({ path: parent2, stat });
+      if (parent2 === "/") break;
+    }
+    const context = this.context;
+    const parent = ancestors[ancestors.length - 1].stat;
+    let staging;
+    let operation;
+    let closed = false;
+    const release = retainFileSystemCleanup(context.fs, async (view) => {
+      await operation?.catch(() => {
+      });
+      if (staging) await view.removeStagedFile(staging);
+    }, { maxOperations: 1 });
+    const cleanup = () => {
+      closed = true;
+      return release();
+    };
+    context.registerCleanup?.(cleanup);
+    try {
+      operation = Promise.resolve().then(async () => {
+        context.signal.throwIfAborted();
+        if (closed) throw new ToolError("patch publication is closed");
+        staging = await context.fs.createStagedFile(`${dirname(path) === "/" ? "" : dirname(path)}/.patch-${globalThis.crypto.randomUUID()}`, "file", {
+          type: "file",
+          data: encodeBytes(text)
+        }, {
+          parent,
+          signal: context.signal,
+          ...mode === void 0 ? {} : { mode },
+          ...mtimeMs === void 0 ? {} : { atimeMs: mtimeMs, mtimeMs }
+        });
+        context.signal.throwIfAborted();
+        if (closed) throw new ToolError("patch publication is closed");
+        await context.fs.publishStagedFile(staging, path, {
+          parent,
+          destination: destination ?? null,
+          ancestors,
+          signal: context.signal
+        });
+      });
+      await host(context, () => operation);
+    } finally {
+      await cleanup();
+    }
+  }
+  async remove(path) {
+    const fs = this.removals.get(path);
+    if (!fs) throw new ToolError(`patch removal was not admitted: ${path}`);
+    await host(this.context, () => fs.rm(path, { signal: this.context.signal }));
+  }
+  async prune(path) {
+    const fs = this.pruning.get(path);
+    if (!fs) throw new ToolError(`patch directory pruning was not admitted: ${path}`);
+    if (!fs.rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path });
+    await host(this.context, () => fs.rmdir(path, { signal: this.context.signal }));
+  }
+};
+
+export {
+  PatchPublication
+};

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

@@ -0,0 +1,293 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-wget/src/wget.ts
+init_buffer();
+import { createTransferCommand } from "../../safe-bash-command-curl/curl.js";
+import { getCommandArguments } from "../../safe-bash-contracts/index.js";
+import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+import { validateRequestHeader } from "../../safe-bash-network-engine/args.js";
+import { validateHeaderName } from "../../safe-bash-network-engine/platform-portable.js";
+import { collectNetworkBytes as collectBytes } from "../../safe-bash-network-engine/shared.js";
+import { CurlError } from "../../safe-bash-network-engine/types.js";
+async function parseWget(context, limits) {
+  const carrier = getCommandArguments(context);
+  let argumentBytes = 0;
+  for (const value of carrier.values) {
+    if (typeof value === "string" && value.length > limits.maxBufferBytes) throw new CurlError(2, "Arguments exceed host buffer limit");
+    argumentBytes += shellValueByteLength(value);
+    if (argumentBytes > limits.maxBufferBytes) throw new CurlError(2, "Arguments exceed host buffer limit");
+    if (typeof value === "string") {
+      for (let index = 0; index < value.length; index++) {
+        if (index % 1024 === 0) await yieldTurn(context.signal);
+        const code = value.charCodeAt(index);
+        if (code >= 55296 && code <= 56319) {
+          const next = value.charCodeAt(++index);
+          if (!(next >= 56320 && next <= 57343)) throw new CurlError(2, "Arguments must be valid UTF-8");
+        } else if (code >= 56320 && code <= 57343) throw new CurlError(2, "Arguments must be valid UTF-8");
+      }
+      continue;
+    }
+    const bytes = shellValueBytes(value);
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    for (let offset = 0; offset < bytes.length; offset += 1024) {
+      await yieldTurn(context.signal);
+      try {
+        decoder.decode(bytes.subarray(offset, offset + 1024), { stream: offset + 1024 < bytes.length });
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (!(error instanceof TypeError) || "code" in error && error.code !== "ERR_ENCODING_INVALID_ENCODED_DATA") throw error;
+        throw new CurlError(2, "Arguments must be valid UTF-8");
+      }
+    }
+  }
+  const result = {
+    urls: [],
+    data: [],
+    headers: [],
+    include: false,
+    head: false,
+    get: false,
+    location: true,
+    remoteName: true,
+    fail: true,
+    failWithBody: false,
+    silent: false,
+    showError: false,
+    verbose: false,
+    globoff: true,
+    help: false,
+    version: false,
+    retries: limits.maxRetries,
+    retryDelayMs: 0,
+    maxTimeMs: limits.maxTimeMs,
+    maxRedirects: limits.maxRedirects,
+    maxFileSize: limits.maxDownloadBytes,
+    agent: "virtual-bash-wget/0.0",
+    retryTransport: true,
+    directoryIndex: "index.html",
+    download: { spider: false, resume: false, noClobber: false, contentDisposition: false }
+  };
+  const number = (value, integral) => {
+    let start = 0;
+    let end = value.length;
+    if (!integral) {
+      while (start < end && " 	\n\r\v\f".includes(value[start])) start++;
+      while (end > start && " 	\n\r\v\f".includes(value[end - 1])) end--;
+    }
+    let multiplier = 1;
+    if (!integral) {
+      const units = { s: 1, m: 60, h: 3600, d: 86400 };
+      const unit = units[value[end - 1]];
+      if (unit !== void 0) {
+        multiplier = unit;
+        end--;
+      }
+    }
+    let position = start;
+    if (!integral && (value[position] === "+" || value[position] === "-")) position++;
+    let digits = 0;
+    let dot = false;
+    for (; position < end; position++) {
+      const character = value[position];
+      if (character >= "0" && character <= "9") digits++;
+      else if (!integral && character === "." && !dot) dot = true;
+      else throw new CurlError(2, "Invalid numeric option");
+    }
+    if (!digits) throw new CurlError(2, "Invalid numeric option");
+    const parsed = Number(value.slice(start, end)) * multiplier;
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > Number.MAX_SAFE_INTEGER) throw new CurlError(2, "Invalid numeric option");
+    return parsed;
+  };
+  const bodies = {};
+  const headers = /* @__PURE__ */ new Map();
+  let agent;
+  let referer;
+  let ended = false;
+  let inputFile;
+  for (let index = 0; index < context.args.length; index++) {
+    if (index % 128 === 0) await yieldTurn(context.signal);
+    const argument = context.args[index];
+    if (ended || !argument.startsWith("-") || argument === "-") {
+      result.urls.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (!argument.startsWith("--")) {
+      for (let position = 1; position < argument.length; position++) {
+        if (position % 1024 === 0) await yieldTurn(context.signal);
+        const flag2 = argument[position];
+        if (flag2 === "q") result.silent = true;
+        else if (flag2 === "c") result.download.resume = true;
+        else if (flag2 === "n" && argument[position + 1] === "c") {
+          result.download.noClobber = true;
+          position++;
+        } else if (flag2 === "n" && argument[position + 1] === "v") position++;
+        else if (flag2 === "h") result.help = true;
+        else if (flag2 === "r") throw new CurlError(2, "Recursive mirroring is unsupported");
+        else if (["O", "P", "i", "T", "t"].includes(flag2)) {
+          const output = position + 1 < argument.length ? argument.slice(position + 1) : context.args[++index];
+          if (!output) throw new CurlError(2, `-${flag2} requires a nonempty argument`);
+          if (flag2 === "O") {
+            result.output = output;
+            result.remoteName = false;
+          } else if (flag2 === "P") result.outputDirectory = output;
+          else if (flag2 === "i") inputFile = output;
+          else if (flag2 === "T") {
+            const seconds = number(output, false);
+            result.maxTimeMs = Math.min(seconds === 0 ? Infinity : seconds * 1e3, limits.maxTimeMs);
+          } else {
+            const tries = number(output, true);
+            result.retries = tries === 0 ? limits.maxRetries : Math.min(tries - 1, limits.maxRetries);
+          }
+          break;
+        } else throw new CurlError(2, `Unsupported option: -${flag2}`);
+      }
+      continue;
+    }
+    if (argument === "--quiet") {
+      result.silent = true;
+      continue;
+    }
+    if (argument === "--no-verbose") continue;
+    if (argument === "--help") {
+      result.help = true;
+      continue;
+    }
+    if (argument === "--version") {
+      result.version = true;
+      continue;
+    }
+    if (argument === "--spider") {
+      result.download.spider = true;
+      continue;
+    }
+    if (argument === "--continue") {
+      result.download.resume = true;
+      continue;
+    }
+    if (argument === "--no-clobber") {
+      result.download.noClobber = true;
+      continue;
+    }
+    if (argument === "--content-disposition") {
+      result.download.contentDisposition = true;
+      continue;
+    }
+    if (argument === "--recursive") throw new CurlError(2, "Recursive mirroring is unsupported");
+    const equal = argument.indexOf("=");
+    const flag = equal < 0 ? argument : argument.slice(0, equal);
+    let operand;
+    if (["--directory-prefix", "--input-file", "--output-document", "--timeout", "--tries", "--method", "--post-data", "--post-file", "--body-data", "--body-file", "--header", "--user-agent", "--referer"].includes(flag)) {
+      operand = equal < 0 ? context.args[++index] : argument.slice(equal + 1);
+    } else throw new CurlError(2, `Unsupported option: ${argument}`);
+    if (operand === void 0) throw new CurlError(2, `${flag} requires an argument`);
+    if (flag === "--output-document") {
+      if (!operand) throw new CurlError(2, "Output filename must not be empty");
+      result.output = operand;
+      result.remoteName = false;
+    } else if (flag === "--directory-prefix") result.outputDirectory = operand;
+    else if (flag === "--input-file") inputFile = operand;
+    else if (flag === "--timeout") {
+      const seconds = number(operand, false);
+      result.maxTimeMs = Math.min(seconds === 0 ? Infinity : seconds * 1e3, limits.maxTimeMs);
+    } else if (flag === "--tries") {
+      const tries = number(operand, true);
+      result.retries = tries === 0 ? limits.maxRetries : Math.min(tries - 1, limits.maxRetries);
+    } else if (flag === "--header") {
+      if (operand === "") {
+        headers.clear();
+        continue;
+      }
+      const colon = operand.indexOf(":");
+      if (colon < 1) throw new CurlError(2, "Invalid HTTP header");
+      const name = operand.slice(0, colon);
+      const value = operand.slice(colon + 1).trim();
+      validateRequestHeader(name, value);
+      headers.set(name.toLowerCase(), [name, value]);
+    } else if (flag === "--user-agent") {
+      validateRequestHeader("User-Agent", operand);
+      agent = operand;
+    } else if (flag === "--referer") {
+      validateRequestHeader("Referer", operand);
+      referer = operand;
+    } else if (flag === "--method") {
+      try {
+        validateHeaderName(operand);
+      } catch {
+        throw new CurlError(2, "Invalid or unsupported HTTP method");
+      }
+      result.method = operand.toUpperCase();
+      if (["CONNECT", "TRACE"].includes(result.method)) throw new CurlError(2, "Invalid or unsupported HTTP method");
+    } else {
+      const bodyFlag = flag;
+      if (bodyFlag.endsWith("-file") && !operand) throw new CurlError(2, "Upload filename must not be empty");
+      bodies[bodyFlag] = operand;
+    }
+  }
+  if (agent !== void 0 && !headers.has("user-agent")) result.headers.push(["User-Agent", agent === "" ? null : agent]);
+  if (referer !== void 0 && !headers.has("referer")) result.headers.push(["Referer", referer]);
+  result.headers.push(...headers.values());
+  const post = bodies["--post-data"] !== void 0 || bodies["--post-file"] !== void 0;
+  const customBody = bodies["--body-data"] !== void 0 || bodies["--body-file"] !== void 0;
+  if (post && result.method !== void 0 || customBody && result.method === void 0 || bodies["--post-data"] !== void 0 && bodies["--post-file"] !== void 0 || bodies["--body-data"] !== void 0 && bodies["--body-file"] !== void 0) {
+    throw new CurlError(2, "Incompatible request body options: use --post-data or --post-file, or --method with --body-data or --body-file");
+  }
+  const data = bodies["--post-data"] ?? bodies["--body-data"];
+  const file = bodies["--post-file"] ?? bodies["--body-file"];
+  if (data !== void 0) result.data.push({ kind: "raw", value: data });
+  else if (file !== void 0) result.data.push({ kind: "binary", value: `@${file === "-" ? "./-" : file}` });
+  if (!result.help && !result.version) {
+    if (inputFile !== void 0) {
+      let bytes;
+      try {
+        bytes = inputFile === "-" ? await collectBytes(context.stdin, { signal: context.signal, maxBytes: limits.maxBufferBytes }) : await context.fs.readFile(pathOf(context, inputFile), { signal: context.signal, ...Number.isFinite(limits.maxBufferBytes) ? { maxBytes: limits.maxBufferBytes } : {} });
+      } catch {
+        context.signal.throwIfAborted();
+        throw new CurlError(26, "Failed reading virtual URL input file");
+      }
+      let text;
+      try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      } catch {
+        throw new CurlError(2, "URL input must be valid UTF-8");
+      }
+      let start = 0;
+      let lines = 0;
+      for (let index = 0; index <= text.length; index++) {
+        if (index % 1024 === 0) await yieldTurn(context.signal);
+        if (index !== text.length && text[index] !== "\n") continue;
+        if (index === text.length && start === index) break;
+        if (++lines > limits.maxInputLines) throw new CurlError(2, "URL input exceeds host line limit");
+        const url = text.slice(start, index).trim();
+        start = index + 1;
+        if (url) result.urls.push(url);
+        if (result.urls.length > limits.maxUrls) throw new CurlError(2, "URL count exceeds host limit");
+      }
+    }
+    if (!result.urls.length) throw new CurlError(2, "An HTTP(S) URL is required");
+    if (result.urls.length > limits.maxUrls) throw new CurlError(2, "URL count exceeds host limit");
+    if (result.download.resume && result.download.noClobber) throw new CurlError(2, "Continue and no-clobber are incompatible");
+    if (result.output === "-" && (result.download.resume || result.download.noClobber)) throw new CurlError(2, "Download controls require a file output");
+  }
+  return result;
+}
+function createWgetCommand(options = {}) {
+  return createTransferCommand(options, {
+    name: "wget",
+    parse: parseWget,
+    help: "Usage: wget [-O FILE|-] [-q|-nv] [-T SECONDS] [-t COUNT] [URL ...]\nDownloads: --spider | -c/--continue | -nc/--no-clobber | -P/--directory-prefix DIR | --content-disposition\nInput: -i/--input-file FILE (VFS URL list; '-' reads stdin)\nRequest headers: --header 'NAME: VALUE' | --user-agent AGENT | --referer URL\nRequest bodies: --post-data DATA | --post-file FILE | --method METHOD [--body-data DATA | --body-file FILE]\nBody files are read from the VFS. Downloads require explicit host authorization. Recursive mirroring is unsupported.\nTimeout (--timeout) is aggregate and host-capped; --tries=0 remains host-capped.\n",
+    version: "virtual-bash wget 0.0 (bounded HTTP HTTPS)\n",
+    status: (code) => code === 0 ? 0 : [1, 2, 3].includes(code) ? 2 : [23, 26].includes(code) ? 3 : code === 60 ? 5 : code === 22 ? 8 : 4
+  });
+}
+
+export {
+  createWgetCommand
+};