@poe-platform/safe-bash 0.1.423 → 0.1.424

package/dist/safe-bash/browser.js

@@ -9195,6 +9195,7 @@ var InvocationScope = class _InvocationScope {
   parent;
   #children = /* @__PURE__ */ new Set();
   #callbacks = [];
+  #finalizers = [];
   #work = /* @__PURE__ */ new Set();
   #controller = new AbortController();
   #closed = false;
@@ -9202,6 +9203,10 @@ var InvocationScope = class _InvocationScope {
   get signal() {
     return this.#controller.signal;
   }
+  registerFinalizer(finalize) {
+    this.assertOpen();
+    this.#finalizers.push(finalize);
+  }
   assertOpen() {
     this.callerSignal?.throwIfAborted();
     if (this.#closed) throw this.signal.reason;
@@ -9256,6 +9261,13 @@ var InvocationScope = class _InvocationScope {
             ...this.#work
           ]);
         } finally {
+          for (const finalize of this.#finalizers.splice(0)) {
+            try {
+              finalize();
+            } catch (error) {
+              this.failures.push(error);
+            }
+          }
           if (this.parent) this.parent.#children.delete(this);
         }
       });
@@ -11605,6 +11617,89 @@ async function matchEre(program, subject, ledger, signal) {
   return Object.freeze({ matched: false, captures: Object.freeze([]), values: Object.freeze([]) });
 }
 
+// packages/safe-bash/src/shell/path-lookup.ts
+init_platform();
+var maxCacheEntries = 256;
+var maxCacheBytes = 64 * 1024;
+var PathLookup = class {
+  #entries = /* @__PURE__ */ new Map();
+  #bytes = 0;
+  #pending = 0;
+  #generation = 0;
+  suspend() {
+    this.#entries.clear();
+    this.#bytes = 0;
+    this.#generation++;
+    this.#pending++;
+    let closed = false;
+    return () => {
+      if (closed) return;
+      closed = true;
+      this.#pending--;
+      this.#generation++;
+    };
+  }
+  suspendUntilClosed(scope) {
+    scope.assertOpen();
+    const resume = this.suspend();
+    scope.registerFinalizer(resume);
+  }
+  async isFile(fs, path, signal) {
+    signal.throwIfAborted();
+    const cached = this.#entries.get(path);
+    if (cached) return cached.file;
+    const generation = this.#generation;
+    let file;
+    try {
+      file = (await fs.stat(path, { signal })).type === "file";
+    } catch (error) {
+      signal.throwIfAborted();
+      const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+      if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
+      file = false;
+    }
+    signal.throwIfAborted();
+    const bytes2 = import_buffer.Buffer.byteLength(path) + 64;
+    if (!this.#pending && generation === this.#generation && bytes2 <= maxCacheBytes && !this.#entries.has(path)) {
+      while (this.#entries.size >= maxCacheEntries || this.#bytes + bytes2 > maxCacheBytes) {
+        const oldest = this.#entries.entries().next().value;
+        this.#bytes -= oldest[1].bytes;
+        this.#entries.delete(oldest[0]);
+      }
+      this.#entries.set(path, { file, bytes: bytes2 });
+      this.#bytes += bytes2;
+    }
+    return file;
+  }
+};
+function* pathTargets(name2, path, limits, signal, fail2) {
+  signal.throwIfAborted();
+  if (path !== void 0 && import_buffer.Buffer.byteLength(path) > limits.maxExpansionBytes) fail2("maxExpansionBytes");
+  if (name2.includes("/") || path === void 0) {
+    if (limits.maxExpansionFields < 1) fail2("maxExpansionFields");
+    yield name2;
+    return;
+  }
+  let fields = 1;
+  for (let separator = path.indexOf(":"); separator >= 0; separator = path.indexOf(":", separator + 1)) {
+    signal.throwIfAborted();
+    if (++fields > limits.maxExpansionFields) fail2("maxExpansionFields");
+  }
+  if (fields > limits.maxExpansionFields) fail2("maxExpansionFields");
+  let start = 0;
+  let consulted = 0;
+  while (start <= path.length) {
+    signal.throwIfAborted();
+    if (consulted >= limits.maxPathComponents) fail2("maxPathComponents");
+    consulted++;
+    const end = path.indexOf(":", start);
+    const component = path.slice(start, end < 0 ? path.length : end);
+    yield `${component || "."}${component.endsWith("/") ? "" : "/"}${name2}`;
+    if (end < 0) return;
+    start = end + 1;
+  }
+}
+
 // packages/safe-bash/src/shell/runtime.ts
 var defaultLimits = {
   maxParseUnits: defaultMaxParseUnits,
@@ -11612,6 +11707,7 @@ var defaultLimits = {
   maxOutputBytes: 16 * 1024 * 1024,
   maxCommands: 1e4,
   maxFileSystemOperations: 1e5,
+  maxPathComponents: 64,
   maxRedirects: 64,
   maxPipelineStages: 64,
   maxLoopIterations: 1e4,
@@ -11705,6 +11801,7 @@ var Budget = class {
   }
   limits;
   executionScope = Object.freeze({});
+  pathLookup = new PathLookup();
   parsing;
   values;
   commands = 0;
@@ -13914,9 +14011,11 @@ var Runtime = class _Runtime {
                 });
               } };
             };
+            const resumePathCache = this.budget.pathLookup.suspend();
             const release = () => {
               if (closed) return;
               closed = true;
+              resumePathCache();
               if (--file.references === 0 && this.outputFiles.get(path) === file) this.outputFiles.delete(path);
             };
             let target2;
@@ -14191,6 +14290,7 @@ var Runtime = class _Runtime {
     if (argumentValues.values.every((value2) => typeof value2 === "string")) Reflect.deleteProperty(context, "argumentValues");
     const middleware = this.middleware.map((handler) => (context2, next) => {
       scope.assertOpen();
+      this.budget.pathLookup.suspendUntilClosed(scope);
       let downstream;
       const raw = handler(context2, () => {
         downstream = next();
@@ -14384,6 +14484,7 @@ var Runtime = class _Runtime {
           await this.diagnostic({ ...io, ...context2 }, `${context2.command}: command not found`);
           return { exitCode: 127 };
         }
+        this.budget.pathLookup.suspendUntilClosed(scope);
         const raw = definition.execute(forwarded);
         const observed = this.observeRuntimeReturn(raw, runtimeFrame);
         return await interruptible(observed, this.signal);
@@ -14537,25 +14638,20 @@ ${functionDisplay(name2, state.functions.get(name2))}`;
   }
   async searchPaths(name2, state, all = false, discovery = false) {
     if (!name2) return [];
-    const path = state.variables.PATH;
-    if (path !== void 0 && import_buffer.Buffer.byteLength(path) > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
-    const components = name2.includes("/") || path === void 0 ? [void 0] : path.split(":");
-    if (components.length > this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
     let denied;
     const matches = [];
-    for (const component of components) {
-      this.signal.throwIfAborted();
-      const target = component === void 0 ? name2 : `${component || "."}${component?.endsWith("/") ? "" : "/"}${name2}`;
+    for (const target of pathTargets(name2, state.variables.PATH, this.budget.limits, this.signal, (limit) => this.budget.fail(limit))) {
       const resolved = resolvePath(state.cwd, target);
       try {
         const options3 = { signal: this.signal };
-        if ((await interruptible(this.fs.stat(resolved, options3), this.signal)).type !== "file") continue;
+        if (!await interruptible(this.budget.pathLookup.isFile(this.fs, resolved, this.signal), this.signal)) continue;
         if (this.fs.capabilities.permissions !== true) throw new CommandFailure(`${target}: execution permissions are not supported by this filesystem`, 126);
         await interruptible(this.fs.access(resolved, ACCESS_MODES.X_OK, options3), this.signal);
         matches.push(target);
         if (!all) return matches;
       } catch (error) {
         this.signal.throwIfAborted();
+        if (error instanceof ShellLimitError) throw error;
         if (error instanceof CommandFailure) {
           if (discovery) continue;
           throw error;
@@ -14805,6 +14901,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       const runtimeFrame = {};
       const middleware = this.middleware.map((handler) => (context2, next) => {
         scope.assertOpen();
+        this.budget.pathLookup.suspendUntilClosed(scope);
         let downstream;
         const raw = handler(context2, () => {
           downstream = next();
@@ -14887,7 +14984,10 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         return { exitCode: await runtime.interpreter(forwarded, state2, childIO, loadedSource) };
       }
       if (direct) return { exitCode: await runtime.scriptFile(forwarded, state2, childIO, command2, forwarded.args, true) };
-      if (definition) return definition.execute(forwarded);
+      if (definition) {
+        runtime.budget.pathLookup.suspendUntilClosed(childIO[invocationScope]);
+        return definition.execute(forwarded);
+      }
       await writeDiagnostic(forwarded.stderr, `env: ${command2}: command not found
 `);
       return { exitCode: 127 };
@@ -14907,6 +15007,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       args: argumentValues.args,
       argumentValues
     }, state, io, async (runtime, forwarded) => {
+      runtime.budget.pathLookup.suspendUntilClosed(io[invocationScope]);
       let failed = false;
       let failure;
       let failureReport;
@@ -15079,16 +15180,11 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     try {
       const options3 = { signal: this.signal };
       if (filename && !filename.includes("/") && state.variables.PATH) {
-        if (import_buffer.Buffer.byteLength(state.variables.PATH) > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
-        const components = state.variables.PATH.split(":");
-        if (components.length > this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
         let found = false;
-        for (const component of components) {
-          this.signal.throwIfAborted();
-          const candidate = `${component || "."}${component.endsWith("/") ? "" : "/"}${filename}`;
+        for (const candidate of pathTargets(filename, state.variables.PATH, this.budget.limits, this.signal, (limit) => this.budget.fail(limit))) {
           const path2 = resolvePath(state.cwd, candidate);
           try {
-            if ((await interruptible(this.fs.stat(path2, options3), this.signal)).type !== "file") continue;
+            if (!await interruptible(this.budget.pathLookup.isFile(this.fs, path2, this.signal), this.signal)) continue;
             await interruptible(this.fs.access(path2, ACCESS_MODES.R_OK, options3), this.signal);
             target = candidate;
             found = true;
@@ -17697,6 +17793,7 @@ var cloudflareWorkerLimits = Object.freeze({
   maxOutputBytes: 4 * 1024 * 1024,
   maxCommands: 1e3,
   maxFileSystemOperations: 1e4,
+  maxPathComponents: 64,
   maxRedirects: 64,
   maxPipelineStages: 64,
   maxLoopIterations: 1e3,