@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash-zip-engine/zip/log.js

@@ -0,0 +1,153 @@
+import {
+  ZipFailure
+} from "../../safe-bash/command-chunks/chunk-Q3EWDEUQ.js";
+import {
+  init_buffer
+} from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/log.ts
+init_buffer();
+import { dirname, writeBytes } from "../../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { concatBytes, decodeBytes, encodeBytes, indexOfBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { checkPath, hasIdentity, sameIdentity, vfsPath } from "../../safe-bash-io-engine/commands/archive/internal.js";
+var ZipLog = class {
+  constructor(scope, info) {
+    this.scope = scope;
+    this.info = info;
+  }
+  scope;
+  info;
+  failed = false;
+  password;
+  path = "";
+  parent;
+  expected;
+  bytes = 0;
+  append = false;
+  started = false;
+  pending = [];
+  async open(name, append, protectedNames) {
+    const { context, limits } = this.scope;
+    try {
+      const path = vfsPath(context.cwd, name);
+      checkPath(path, limits);
+      const parent = await this.scope.operation(() => context.fs.realpath(dirname(path), { signal: context.signal }));
+      this.path = `${parent === "/" ? "" : parent}/${path.slice(path.lastIndexOf("/") + 1)}`;
+      this.parent = await this.scope.stat(parent);
+      this.expected = await this.scope.stat(this.path);
+      if (!this.parent || !hasIdentity(this.parent) || this.parent.type !== "directory" || this.expected && (this.expected.type !== "file" || this.expected.nlink !== 1 || !hasIdentity(this.expected))) throw new Error("unsafe log identity");
+      await this.protect(protectedNames);
+      const capabilities = await this.scope.operation(() => context.fs.capabilitiesFor?.(this.path, { signal: context.signal, create: true }) ?? context.fs.capabilities);
+      if (capabilities.atomicFileMutation !== true && capabilities.trustedOwnedStaging !== true || !context.fs.writeFileConditional) throw new Error("conditional log writes unavailable");
+      this.bytes = append ? this.expected?.size ?? 0 : 0;
+      if (!Number.isSafeInteger(this.bytes) || this.bytes < 0 || this.bytes > limits.maxTextBytes) throw new Error("log byte limit");
+      this.append = append;
+      if (!this.expected) this.expected = await this.scope.operation(() => context.fs.writeFileConditional(this.path, new Uint8Array(), {
+        signal: context.signal,
+        parent: this.parent,
+        expected: null
+      }));
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(16, "Invalid command arguments", "ZIP log path is unavailable or unsafe");
+    }
+  }
+  async protect(names) {
+    const { context } = this.scope;
+    try {
+      for (const name of names) {
+        if (name === "-") continue;
+        const path = vfsPath(context.cwd, name);
+        const stat = await this.scope.stat(path);
+        if (this.path === path || this.expected && stat && sameIdentity(this.expected, stat)) throw new Error("log alias");
+        if (stat?.type === "directory") {
+          const canonical = await this.scope.operation(() => context.fs.realpath(path, { signal: context.signal }));
+          if (this.path.startsWith(`${canonical === "/" ? "" : canonical}/`)) throw new Error("log within selected directory");
+        }
+      }
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(16, "Invalid command arguments", "ZIP log path is unavailable or unsafe");
+    }
+  }
+  async start() {
+    if (this.started || this.failed) return;
+    const { context } = this.scope;
+    try {
+      this.expected = await this.scope.operation(() => context.fs.writeFileConditional(this.path, new Uint8Array(), {
+        signal: context.signal,
+        parent: this.parent,
+        expected: this.expected,
+        append: this.append
+      }));
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(16, "Invalid command arguments", "ZIP log path is unavailable or unsafe");
+    }
+    try {
+      for (const bytes of this.pending) await this.write(bytes);
+      this.pending.length = 0;
+      this.started = true;
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(11, "Error writing to a file", "ZIP log write failed or exceeded its byte limit");
+    }
+  }
+  async write(bytes) {
+    const { context } = this.scope;
+    await writeFileOutput(context, bytes, (data) => this.scope.operation(async () => {
+      this.expected = await context.fs.writeFileConditional(this.path, data, {
+        signal: context.signal,
+        parent: this.parent,
+        expected: this.expected,
+        append: true
+      });
+    }));
+  }
+  sink(destination, quiet = false) {
+    const { context, limits } = this.scope;
+    return { write: async (chunk) => {
+      if (!this.failed && (this.info || decodeBytes(encodeBytes(chunk)).includes("warning:") || decodeBytes(encodeBytes(chunk)).includes("error:") || destination === context.stderr)) {
+        try {
+          const input = encodeBytes(chunk);
+          const secret = this.password;
+          const fragments = [];
+          let start = 0;
+          let size = 0;
+          if (secret?.length) {
+            for (; ; ) {
+              const offset = indexOfBytes(input, secret, start);
+              if (offset < 0) break;
+              size += offset - start + 10;
+              if (size > limits.maxTextBytes - this.bytes) throw new Error("log byte limit");
+              fragments.push(input.subarray(start, offset), encodeBytes("[redacted]"));
+              start = offset + secret.length;
+            }
+          }
+          size += input.length - start;
+          if (size > limits.maxTextBytes - this.bytes) throw new Error("log byte limit");
+          fragments.push(input.subarray(start));
+          const redacted = fragments.length === 1 ? input : concatBytes(fragments, size);
+          if (redacted.length > limits.maxTextBytes - this.bytes) throw new Error("log byte limit");
+          if (this.started) await this.write(redacted);
+          else this.pending.push(Uint8Array.from(redacted));
+          this.bytes += redacted.length;
+        } catch {
+          context.signal.throwIfAborted();
+          this.failed = true;
+          throw new ZipFailure(11, "Error writing to a file", "ZIP log write failed or exceeded its byte limit");
+        }
+      }
+      const message = decodeBytes(encodeBytes(chunk));
+      if (!quiet || message.includes("zip error:") || message.startsWith("zip:")) await writeBytes(destination, chunk, context.signal);
+    } };
+  }
+};
+export {
+  ZipLog
+};

package/dist/safe-bash-zip-engine/zip/lzma.d.ts

@@ -0,0 +1,9 @@
+import type { CodecInput } from "../../safe-bash-compression-engine/codec.js";
+import type { ByteSource } from "../../safe-bash-contracts/index.js";
+/** ZIP 6.3.4: version, property length, LZMA1 properties, then raw stream. */
+export declare function zipLzma(input: CodecInput, signal: AbortSignal, options: Readonly<{
+    decode: boolean;
+    level: number;
+    eos: boolean;
+    size: number;
+}>): ByteSource;

package/dist/safe-bash-zip-engine/zip/lzma.js

@@ -0,0 +1,7 @@
+import {
+  zipLzma
+} from "../../safe-bash/command-chunks/chunk-2FGJYFWZ.js";
+import "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  zipLzma
+};

package/dist/safe-bash-zip-engine/zip/move.d.ts

@@ -0,0 +1,11 @@
+import { type FileStat } from "../../safe-bash-contracts/index.js";
+import { type Budget } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import type { ZipScope } from "./safety.js";
+export interface ZipMoveSource {
+    readonly path: string;
+    readonly source: string;
+    readonly parent: FileStat;
+    expected: FileStat;
+}
+export declare function inspectZipMoveSource(scope: ZipScope, path: string, source: string): Promise<ZipMoveSource>;
+export declare function removeZipSources(scope: ZipScope, sources: readonly ZipMoveSource[], budget: Budget, quiet: boolean): Promise<void>;

package/dist/safe-bash-zip-engine/zip/move.js

@@ -0,0 +1,57 @@
+import {
+  init_buffer
+} from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/move.ts
+init_buffer();
+import { dirname } from "../../safe-bash-contracts/index.js";
+import { fail, hasIdentity, sameIdentity } from "../../safe-bash-io-engine/commands/archive/internal.js";
+async function inspectZipMoveSource(scope, path, source) {
+  const { fs, signal } = scope.context;
+  const capabilities = await scope.operation(() => fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+  if (capabilities.atomicEntryRemoval !== true || !fs.removeEntryConditional) fail("ZIP move requires atomic conditional source removal");
+  const parentPath = await scope.operation(() => fs.realpath(dirname(path), { signal }));
+  const parent = await scope.operation(() => fs.lstat(parentPath, { signal }));
+  const expected = await scope.operation(() => fs.lstat(path, { signal }));
+  if (parent.type !== "directory" || !hasIdentity(parent) || !hasIdentity(expected) || !Number.isSafeInteger(expected.revision)) fail("ZIP move requires known source identity and revision");
+  return { path: `${parentPath === "/" ? "" : parentPath}/${path.slice(path.lastIndexOf("/") + 1)}`, source, parent, expected };
+}
+async function removeZipSources(scope, sources, budget, quiet) {
+  const { fs, signal } = scope.context;
+  const pending = [...sources].sort((a, b) => Number(a.expected.type === "directory") - Number(b.expected.type === "directory") || b.path.split("/").length - a.path.split("/").length);
+  const remaining = new Set(pending);
+  const identities = /* @__PURE__ */ new Map();
+  for (const entry of pending) {
+    let scoped = identities.get(entry.expected.identityScope);
+    if (!scoped) identities.set(entry.expected.identityScope, scoped = /* @__PURE__ */ new Map());
+    const key = `${entry.expected.dev}:${entry.expected.ino}`;
+    const grouped = scoped.get(key);
+    if (grouped) grouped.push(entry);
+    else scoped.set(key, [entry]);
+  }
+  for (let index = 0; index < pending.length; index++) {
+    const entry = pending[index];
+    try {
+      if (!fs.removeEntryConditional) fail("ZIP conditional source removal unavailable");
+      await scope.operation(() => fs.removeEntryConditional(entry.path, { parent: entry.parent, expected: entry.expected, signal }));
+      remaining.delete(entry);
+      for (const changed of [entry.parent, entry.expected]) {
+        const candidates = identities.get(changed.identityScope)?.get(`${changed.dev}:${changed.ino}`) ?? [];
+        for (const candidate of candidates) {
+          if (!remaining.has(candidate)) continue;
+          const revision = Math.min(Number.MAX_SAFE_INTEGER + 1, candidate.expected.revision + 1);
+          const current = await scope.stat(candidate.path);
+          if (current && sameIdentity(current, candidate.expected) && current.type === candidate.expected.type && current.revision === revision) candidate.expected = current;
+        }
+      }
+    } catch {
+      signal.throwIfAborted();
+      if (entry.expected.type !== "directory" && !quiet) await budget.output(`	zip warning: error deleting ${entry.source}
+`);
+    }
+  }
+}
+export {
+  inspectZipMoveSource,
+  removeZipSources
+};

package/dist/safe-bash-zip-engine/zip/names.d.ts

@@ -0,0 +1,2 @@
+/** Unix Info-ZIP msname ordering, restricted to its portable ASCII domain. */
+export declare function zipDosName(name: string): string;

package/dist/safe-bash-zip-engine/zip/names.js

@@ -0,0 +1,37 @@
+import {
+  ZipFailure
+} from "../../safe-bash/command-chunks/chunk-Q3EWDEUQ.js";
+import {
+  init_buffer
+} from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/names.ts
+init_buffer();
+function zipDosName(name) {
+  let result = "";
+  let length = 0;
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    if (code >= 127 || code < 32 || character === "\\") {
+      throw new ZipFailure(16, "Invalid command arguments", "DOS names require printable ASCII components without backslashes");
+    }
+    if (' :"*+,;<=>?[]|'.includes(character)) continue;
+    if (character === "/") {
+      result += character;
+      length = 0;
+    } else if (character === ".") {
+      if (length === 0) continue;
+      if (length < 9) {
+        result += character;
+        length = 9;
+      } else length = 12;
+    } else if (length < 12 && length !== 8) {
+      result += character.toUpperCase();
+      length++;
+    }
+  }
+  return result;
+}
+export {
+  zipDosName
+};

package/dist/safe-bash-zip-engine/zip/options.d.ts

@@ -0,0 +1,13 @@
+export declare class ZipFailure extends Error {
+    readonly status: number;
+    readonly label: string;
+    constructor(status: number, label: string, detail: string);
+}
+export declare const reservedZipShortOptions: Set<string>;
+export declare const zipLongOptions: Readonly<Record<string, string>>;
+export declare function normalizeZipOption(argument: string): string;
+export declare const zipNegatableOptions: Set<string>;
+export declare function parseZipDotSize(value: string): number;
+export declare function zipDisplaySize(size: number): string;
+export declare function zipPasswordArgument(value: string): "attached" | "separate" | undefined;
+export declare function zipPublicText(value: string): string;

package/dist/safe-bash-zip-engine/zip/options.js

@@ -0,0 +1,23 @@
+import {
+  ZipFailure,
+  normalizeZipOption,
+  parseZipDotSize,
+  reservedZipShortOptions,
+  zipDisplaySize,
+  zipLongOptions,
+  zipNegatableOptions,
+  zipPasswordArgument,
+  zipPublicText
+} from "../../safe-bash/command-chunks/chunk-Q3EWDEUQ.js";
+import "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  ZipFailure,
+  normalizeZipOption,
+  parseZipDotSize,
+  reservedZipShortOptions,
+  zipDisplaySize,
+  zipLongOptions,
+  zipNegatableOptions,
+  zipPasswordArgument,
+  zipPublicText
+};

package/dist/safe-bash-zip-engine/zip/repair.d.ts

@@ -0,0 +1,10 @@
+import { type ArchiveLimits } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import { type ZipArchive } from "../zip-format.js";
+/** Recovery is opt-in. Signatures nominate records; the normal reader and
+ * codecs validate metadata, descriptors, names, sizes and CRC before retention. */
+export declare function repairZip(bytes: Uint8Array, mode: "F" | "FF", limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): Promise<{
+    archive: ZipArchive;
+    partial: boolean;
+}>;
+/** Adjust a validated SFX using owned bytes; prefix bytes are inert. */
+export declare function adjustZipSfx(bytes: Uint8Array, archive: ZipArchive, limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): Promise<Uint8Array>;