@poe-platform/safe-bash 0.1.772 → 0.1.774

package/dist/safe-bash-command-gh/index.d.ts

@@ -21,6 +21,7 @@ export interface GhCommandOptions {
 export interface GhCommandsOptions extends GhCommandOptions {
     readonly replace?: boolean | undefined;
 }
+export declare function settings(options?: GhCommandOptions): GhLimits;
 export declare function createGhCommand(options?: GhCommandOptions): CommandDefinition;
 export declare function evalSyncGh(execFn: CommandDefinition["execute"], rawArgs: readonly string[], env: Readonly<Record<string, string>>, cwd?: string, readFileSync?: (path: string) => Uint8Array | undefined): string | undefined;
 export declare function createGhCommands(options?: GhCommandsOptions): readonly CommandDefinition[];

package/dist/safe-bash-command-gh/index.js

@@ -4,9 +4,11 @@ import {
 
 // packages/safe-bash-command-gh/dist/index.js
 init_buffer();
+import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
 
 // packages/safe-bash-command-gh/dist/input.js
 init_buffer();
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { resolvePath } from "@poe-platform/safe-fs/core";
 import { readBytes } from "../safe-bash-contracts/index.js";
 function createGhInput(context, limits) {
@@ -55,10 +57,18 @@ function createGhInput(context, limits) {
   const readStdinBytes = () => stdin ??= (async () => {
     const chunks = [];
     let size = 0;
+    let turnBytes = 0;
+    let turnChunks = 0;
     for await (const chunk of readBytes(context.stdin, context.signal)) {
       chargeBytes(chunk.length);
       chunks.push(chunk);
       size += chunk.length;
+      turnBytes += chunk.length;
+      if (++turnChunks >= 128 || turnBytes >= 16 * 1024) {
+        await yieldTurn(context.signal);
+        turnBytes = 0;
+        turnChunks = 0;
+      }
     }
     const bytes = new Uint8Array(size);
     let offset = 0;
@@ -8110,12 +8120,13 @@ State: ${cs.state}
 // packages/safe-bash-command-gh/dist/types.js
 init_buffer();
 var DEFAULT_GH_LIMITS = Object.freeze({
-  maxHttpRequests: 256,
-  maxHttpBytes: 64 * 1024 * 1024,
-  maxOutputBytes: 32 * 1024 * 1024,
-  maxInputBytes: 16 * 1024 * 1024,
-  maxFiles: 4096,
-  maxItems: 1e4
+  maxHttpRequests: Infinity,
+  maxHttpBytes: Infinity,
+  maxOutputBytes: Infinity,
+  maxInputBytes: Infinity,
+  maxFiles: Infinity,
+  maxItems: Infinity,
+  maxAliasDepth: Infinity
 });
 
 // packages/safe-bash-command-gh/dist/index.js
@@ -8225,8 +8236,17 @@ function normalizeTopLevelArgs(rawArgs) {
     help: help && !command
   };
 }
-function createGhCommand(options = {}) {
+function settings(options = {}) {
   const limits = { ...DEFAULT_GH_LIMITS, ...options.limits };
+  for (const [name, value] of Object.entries(limits)) {
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1)) {
+      throw new RangeError(`gh ${name} must be Infinity or a positive safe integer`);
+    }
+  }
+  return limits;
+}
+function createGhCommand(options = {}) {
+  const limits = settings(options);
   const backends = /* @__PURE__ */ new WeakMap();
   const openssl = createDefaultOpenSslProvider(options.openssl);
   const def = {
@@ -8266,11 +8286,9 @@ function createGhCommand(options = {}) {
       try {
         const readStdinBytes = input.readStdinBytes;
         const readStdinText = async () => decodeUtf8(await readStdinBytes());
+        const visitedAliases = /* @__PURE__ */ new Set();
         const dispatch = async (argsToRun, depth = 0) => {
-          if (depth > 8) {
-            await writeErr("gh: alias expansion loop detected\n");
-            return 1;
-          }
+          context.signal.throwIfAborted();
           const { command, subArgs, version, help } = normalizeTopLevelArgs(argsToRun);
           if (version || command === "version") {
             await writeOut(GH_VERSION_OUTPUT);
@@ -8281,10 +8299,21 @@ function createGhCommand(options = {}) {
             return 0;
           }
           if (command === "co" && !(command in backend.config.aliases)) {
-            return dispatch(["pr", "checkout", ...subArgs], depth + 1);
+            return dispatch(["pr", "checkout", ...subArgs], depth);
           }
           const aliasExpansion = backend.config.aliases[command];
           if (aliasExpansion) {
+            if (visitedAliases.has(command)) {
+              await writeErr("gh: alias expansion loop detected\n");
+              return 1;
+            }
+            if (depth >= limits.maxAliasDepth) {
+              await writeErr("gh: alias expansion depth limit exceeded\n");
+              return 1;
+            }
+            visitedAliases.add(command);
+            if (visitedAliases.size % 128 === 0)
+              await yieldTurn2(context.signal);
             const cleanExpansion = aliasExpansion.startsWith("!") ? aliasExpansion.slice(1).replace(/^gh\s+/u, "") : aliasExpansion;
             let expandedText = cleanExpansion;
             let usedPositionalPlaceholder = false;
@@ -9724,5 +9753,6 @@ export {
   createGitHubBackend,
   evalSyncGh,
   ghCommands,
-  parseRepoSpec
+  parseRepoSpec,
+  settings
 };

package/dist/safe-bash-command-gh/types.d.ts

@@ -5,6 +5,7 @@ export interface GhLimits {
     readonly maxInputBytes: number;
     readonly maxFiles: number;
     readonly maxItems: number;
+    readonly maxAliasDepth: number;
 }
 export declare const DEFAULT_GH_LIMITS: Readonly<GhLimits>;
 export interface GhHttpRequest {

package/dist/safe-bash-command-git/index.js

@@ -114,20 +114,7 @@ function createGitCommand(options = {}) {
       throw new Error(`${name} must be a positive safe integer or Infinity`);
   const def = { name: "git", runtimeIdentity: commandRuntimeIdentity, description: "Git repositories in the virtual filesystem", async execute(context) {
     try {
-      const chunks = [];
-      let stdinSize = 0;
-      for await (const chunk of readBytes(context.stdin, context.signal)) {
-        stdinSize += chunk.length;
-        if (stdinSize > limits.maxBytes)
-          throw new Error("Git stdin byte limit exceeded");
-        chunks.push(chunk);
-      }
-      const stdin = new Uint8Array(stdinSize);
-      let offset = 0;
-      for (const chunk of chunks) {
-        stdin.set(chunk, offset);
-        offset += chunk.length;
-      }
+      let stdin;
       const before = await snapshot(context.fs, limits, context.signal);
       const exports = options.wasmModule ? new globalThis.WebAssembly.Instance(options.wasmModule).exports : getDefaultGitExports();
       const responses = [];
@@ -135,7 +122,7 @@ function createGitCommand(options = {}) {
       let result;
       for (; ; ) {
         context.signal.throwIfAborted();
-        const input = encoder.encode(JSON.stringify({ cwd: context.cwd, args: context.args, entries: before, responses, stdin: encode(stdin) }));
+        const input = encoder.encode(JSON.stringify({ cwd: context.cwd, args: context.args, env: context.env, entries: before, responses, stdin }));
         const ptr = exports.git_alloc(input.length);
         try {
           new Uint8Array(exports.memory.buffer, ptr, input.length).set(input);
@@ -147,6 +134,26 @@ function createGitCommand(options = {}) {
         } finally {
           exports.git_free(ptr, input.length);
         }
+        if (result.needsStdin) {
+          if (stdin !== void 0)
+            throw new Error("Git requested stdin more than once");
+          const chunks = [];
+          let size = 0;
+          for await (const chunk of readBytes(context.stdin, context.signal)) {
+            size += chunk.length;
+            if (size > limits.maxBytes)
+              throw new Error("Git stdin byte limit exceeded");
+            chunks.push(chunk);
+          }
+          const bytes = new Uint8Array(size);
+          let offset = 0;
+          for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.length;
+          }
+          stdin = encode(bytes);
+          continue;
+        }
         if (!result.request)
           break;
         if (!options.http)