@opengeni/runtime 0.13.11 → 0.13.13

package/dist/{chunk-RHB7ETON.js → chunk-3NUSY22C.js}

@@ -21427,6 +21427,8 @@ var REPOSITORY_DISCOVERY_STATUS_PREFIX = "__OPENGENI_REPOSITORY_DISCOVERY_STATUS
 var NUL = String.fromCharCode(0);
 var FS_LIST_TRUNCATED_MARKER = "__OPENGENI_FS_LIST_TRUNCATED__";
 var FS_LIST_MAX_OUTPUT_BYTES = 768 * 1024;
+var GIT_COMMAND_CHUNK_BYTES = 512 * 1024;
+var GIT_METADATA_MAX_BYTES = 2 * 1024 * 1024;
 var US = String.fromCharCode(31);
 var RS = String.fromCharCode(30);
 var SELFHOSTED_VIRTUAL_ROOT2 = "/workspace";
@@ -21467,8 +21469,9 @@ var SandboxChannelAService = class {
   // ════════════════════════════ exec primitive ══════════════════════════════
   // RAW exec — returns {stdout, stderr, exitCode}. Uses session.exec when present
   // (the local/docker sessions return raw output); falls back to execCommand +
-  // a banner strip (last resort; banner-truncation can mangle, so exec is always
-  // preferred). Throws ChannelAUnsupportedError when neither exists.
+  // a banner strip. Callers that parse output must independently bound/frame it
+  // because provider retained-output truncation drops command prefixes. Throws
+  // ChannelAUnsupportedError when neither exists.
   async run(args) {
     const withRunAs = this.runAs ? { ...args, runAs: this.runAs } : args;
     if (this.session.exec) {
@@ -21907,6 +21910,121 @@ var SandboxChannelAService = class {
     return { path, revision: this.revision };
   }
   // ════════════════════════════ Git (A2, read-only) ═════════════════════════
+  /** Measure one Git command without returning its potentially large or
+   * NUL-bearing output through the provider's text transport. */
+  async measureConfinedCommandBytes(repo, command) {
+    const measured = await this.runInConfinedDirectory(repo, {
+      cmd: [
+        "set -o pipefail",
+        `{ ${command}; } 2>/dev/null | { bytes=$(wc -c | tr -d ' \\n'); printf '%s' "$bytes"; }`,
+        "producer_status=${PIPESTATUS[0]}",
+        `printf '\\t%s\\n' "$producer_status"`
+      ].join("; "),
+      maxOutputTokens: 1024
+    });
+    const match = measured.stdout.match(/^(\d+)\t(\d+)\n?$/);
+    if (!match || measured.exitCode !== null && measured.exitCode !== 0 || Number(match[2]) !== 0) {
+      throw new ChannelAUnavailableError(
+        "Workspace Git data is temporarily unavailable. Retry the operation."
+      );
+    }
+    const size = Number(match[1]);
+    if (!Number.isSafeInteger(size) || size < 0) {
+      throw new ChannelAUnavailableError(
+        "Workspace Git data is temporarily unavailable. Retry the operation."
+      );
+    }
+    return size;
+  }
+  /** Read an exact prefix of a command's output in chunks that remain below
+   * every supported execCommand retained-output ceiling. The producer is
+   * intentionally rerun per chunk; turn-end capture calls this only after the
+   * durable mutation authority has quiesced the workspace. */
+  async readConfinedCommandPrefix(repo, command, byteLength2) {
+    if (byteLength2 === 0) return Buffer.alloc(0);
+    const chunks = [];
+    for (let offset = 0; offset < byteLength2; offset += GIT_COMMAND_CHUNK_BYTES) {
+      const expected = Math.min(GIT_COMMAND_CHUNK_BYTES, byteLength2 - offset);
+      const chunk = await this.runInConfinedDirectory(repo, {
+        cmd: [
+          `{ ${command}; } 2>/dev/null`,
+          `tail -c +${offset + 1}`,
+          `head -c ${expected}`,
+          "base64",
+          `tr -d '\\n'`
+        ].join(" | "),
+        maxOutputTokens: Math.ceil(GIT_COMMAND_CHUNK_BYTES * 4 / 3) + 1024
+      });
+      if (chunk.exitCode !== null && chunk.exitCode !== 0) {
+        throw new ChannelAUnavailableError(
+          "Workspace Git data is temporarily unavailable. Retry the operation."
+        );
+      }
+      const encoded = chunk.stdout.replace(/\s/g, "");
+      const bytes = Buffer.from(encoded, "base64");
+      if (bytes.byteLength !== expected || bytes.toString("base64") !== encoded) {
+        throw new ChannelAUnavailableError(
+          "Workspace Git data is temporarily unavailable. Retry the operation."
+        );
+      }
+      chunks.push(bytes);
+    }
+    return Buffer.concat(chunks, byteLength2);
+  }
+  async readConfinedCommandBytes(repo, command, maxBytes) {
+    const sizeBytes = await this.measureConfinedCommandBytes(repo, command);
+    if (sizeBytes > maxBytes) {
+      return { bytes: Buffer.alloc(0), sizeBytes, truncated: true };
+    }
+    return {
+      bytes: await this.readConfinedCommandPrefix(repo, command, sizeBytes),
+      sizeBytes,
+      truncated: false
+    };
+  }
+  /** Read a regular untracked file without routing its body through one large
+   * execCommand response. Native provider reads are binary-safe; providers
+   * without that surface use the same bounded chunk protocol as Git patches. */
+  async readUntrackedRegularFile(repo, target, byteLength2) {
+    if (byteLength2 === 0) return Buffer.alloc(0);
+    const path = repo ? `${repo}/${target}` : target;
+    assertSafeRelPath(path);
+    if (this.session.readFile) {
+      try {
+        const raw = await this.session.readFile({
+          path: this.joinRoot(path),
+          maxBytes: byteLength2,
+          ...this.runAs ? { runAs: this.runAs } : {}
+        });
+        const bytes = typeof raw === "string" ? Buffer.from(raw, "utf8") : Buffer.from(raw);
+        if (bytes.byteLength !== byteLength2) {
+          throw new ChannelAUnavailableError(
+            "Workspace Git data changed during capture. Retry the operation."
+          );
+        }
+        return bytes;
+      } catch (error) {
+        if (error instanceof ChannelAUnavailableError) throw error;
+        if (isWorkspaceEscapeError(error)) {
+          throw new ChannelAValidationError(`path resolves outside workspace: ${path}`);
+        }
+        if (isDefinitePathNotFoundError(error)) {
+          throw new ChannelANotFoundError(`file not found: ${path}`);
+        }
+        if (!this.session.exec && !this.session.execCommand) {
+          throw new ChannelAUnavailableError(
+            "Workspace Git data is temporarily unavailable. Retry the operation."
+          );
+        }
+      }
+    }
+    const fileArg = target.startsWith("./") ? target : `./${target}`;
+    return await this.readConfinedCommandPrefix(
+      repo,
+      `file=${shellQuote6(fileArg)}; test ! -L "$file" && test -f "$file" || exit 66; cat -- "$file"`,
+      byteLength2
+    );
+  }
   async gitStatus(req) {
     const repo = assertSafeRelPathOrRoot(req.path);
     const inside = await this.runInConfinedDirectory(repo, {
@@ -21924,23 +22042,45 @@ var SandboxChannelAService = class {
         revision: this.revision
       };
     }
-    const { stdout } = await this.runInConfinedDirectory(repo, {
-      cmd: "git status --porcelain=v2 --branch -z"
-    });
-    return { ...parsePorcelainV2(stdout), revision: this.revision };
+    const status = await this.readConfinedCommandBytes(
+      repo,
+      "git status --porcelain=v2 --branch -z",
+      GIT_METADATA_MAX_BYTES
+    );
+    if (status.truncated) {
+      throw new ChannelAUnavailableError(
+        "Workspace Git metadata exceeded the safe capture limit. Retry with a narrower path."
+      );
+    }
+    return { ...parsePorcelainV2(status.bytes.toString("utf8")), revision: this.revision };
   }
   async gitDiff(req) {
     const repo = assertSafeRelPathOrRoot(req.path);
     const ctx = req.contextLines;
     let range = "";
     if (req.fromRef && req.toRef) range = `${shellQuote6(req.fromRef)} ${shellQuote6(req.toRef)}`;
-    else if (req.fromRef) range = `${shellQuote6(req.fromRef)}`;
-    else if (req.staged) range = "--cached";
+    else if (req.fromRef) {
+      if (req.fromRef === "HEAD") {
+        const head = await this.runInConfinedDirectory(repo, {
+          cmd: "if git rev-parse --verify --quiet HEAD >/dev/null; then printf 'present'; else printf 'unborn'; fi"
+        });
+        range = head.stdout.trim() === "present" ? shellQuote6(req.fromRef) : "--cached";
+      } else {
+        range = shellQuote6(req.fromRef);
+      }
+    } else if (req.staged) range = "--cached";
     const pathspec = req.pathspec.length ? ` -- ${req.pathspec.map(shellQuote6).join(" ")}` : "";
-    const numstat = await this.runInConfinedDirectory(repo, {
-      cmd: `git -c core.quotePath=false diff --no-color -z --numstat ${range}${pathspec}`.trim()
-    });
-    const stats = parseNumstatZ(numstat.stdout);
+    const numstat = await this.readConfinedCommandBytes(
+      repo,
+      `git -c core.quotePath=false diff --no-color -z --numstat ${range}${pathspec}`.trim(),
+      GIT_METADATA_MAX_BYTES
+    );
+    if (numstat.truncated) {
+      throw new ChannelAUnavailableError(
+        "Workspace Git metadata exceeded the safe capture limit. Retry with a narrower path."
+      );
+    }
+    const stats = parseNumstatZ(numstat.bytes.toString("utf8"));
     const files = [];
     for (const stat4 of stats) {
       const target = stat4.newPath;
@@ -21959,11 +22099,12 @@ var SandboxChannelAService = class {
         });
         continue;
       }
-      const patch = await this.runInConfinedDirectory(repo, {
-        cmd: `git -c core.quotePath=false diff --no-color -U${ctx} ${range} -- ${shellQuote6(target)}`.trim()
-      });
-      const oversized = Buffer.byteLength(patch.stdout, "utf8") > req.maxBytesPerFile;
-      const parsed = oversized ? { hunks: [], status: "modified" } : parseUnifiedPatch(patch.stdout);
+      const patch = await this.readConfinedCommandBytes(
+        repo,
+        `git -c core.quotePath=false diff --no-color -U${ctx} ${range} -- ${shellQuote6(target)}`.trim(),
+        req.maxBytesPerFile
+      );
+      const parsed = patch.truncated ? { hunks: [], status: "modified" } : parseUnifiedPatch(patch.bytes.toString("utf8"));
       files.push({
         path: target,
         oldPath: stat4.oldPath,
@@ -21973,49 +22114,63 @@ var SandboxChannelAService = class {
         additions: stat4.additions,
         deletions: stat4.deletions,
         hunks: parsed.hunks,
-        truncated: oversized
+        truncated: patch.truncated
       });
     }
     if (req.includeUntracked) {
-      const untracked = await this.runInConfinedDirectory(repo, {
-        cmd: `git -c core.quotePath=false ls-files --others --exclude-standard -z${pathspec}`
-      });
-      for (const target of untracked.stdout.split(NUL).filter(Boolean)) {
+      const untracked = await this.readConfinedCommandBytes(
+        repo,
+        `git -c core.quotePath=false ls-files --others --exclude-standard -z${pathspec}`,
+        GIT_METADATA_MAX_BYTES
+      );
+      if (untracked.truncated) {
+        throw new ChannelAUnavailableError(
+          "Workspace Git metadata exceeded the safe capture limit. Retry with a narrower path."
+        );
+      }
+      for (const target of untracked.bytes.toString("utf8").split(NUL).filter(Boolean)) {
         const fileArg = target.startsWith("./") ? target : `./${target}`;
         const read = await this.runInConfinedDirectory(repo, {
           cmd: [
             `file=${shellQuote6(fileArg)}`,
-            'if [ -L "$file" ]; then printf "L\\n"; readlink -z -- "$file" | base64 | tr -d "\\n"; exit; fi',
+            'if [ -L "$file" ]; then printf "L\\t"; readlink -z -- "$file" | base64 | tr -d "\\n"; exit; fi',
             'size=$(wc -c < "$file") || exit 66',
             'line_count=$(wc -l < "$file") || exit 66',
             'if [ "$size" -gt 0 ]; then last_byte=$(tail -c 1 "$file" | od -An -tu1 | tr -d " \\n"); if [ "$last_byte" != "10" ]; then line_count=$((line_count + 1)); fi; fi',
-            'printf "F\\t%s\\t%s\\n" "$size" "$line_count"',
-            `head -c ${req.maxBytesPerFile + 1} "$file" | base64 | tr -d "\\n"`
+            'printf "F\\t%s\\t%s" "$size" "$line_count"'
           ].join("; ")
         });
-        if (read.exitCode !== null && read.exitCode !== 0) continue;
-        const lineBreak = read.stdout.indexOf("\n");
-        if (lineBreak < 0) continue;
-        const header = read.stdout.slice(0, lineBreak);
-        const encoded = read.stdout.slice(lineBreak + 1).replace(/\s/g, "");
-        let sampled = Buffer.from(encoded, "base64");
+        if (read.exitCode !== null && read.exitCode !== 0) {
+          throw new ChannelAUnavailableError(
+            "Workspace Git data is temporarily unavailable. Retry the operation."
+          );
+        }
+        const [kind, first, second] = read.stdout.split("	");
+        let sampled = Buffer.alloc(0);
         let sizeBytes;
         let lineCount;
-        if (header === "L") {
+        if (kind === "L") {
+          const encoded = (first ?? "").replace(/\s/g, "");
+          sampled = Buffer.from(encoded, "base64");
           if (sampled.at(-1) !== 0) continue;
           sampled = sampled.subarray(0, -1);
           sizeBytes = sampled.length;
           lineCount = addedLines(sampled).length;
         } else {
-          const [kind, sizeRaw, lineCountRaw] = header.split("	");
           if (kind !== "F") continue;
-          const parsedSize = safeInt(sizeRaw);
-          const parsedLineCount = safeInt(lineCountRaw);
+          const parsedSize = safeInt(first);
+          const parsedLineCount = safeInt(second);
           if (parsedSize === null || parsedSize < 0 || parsedLineCount === null || parsedLineCount < 0) {
             continue;
           }
           sizeBytes = parsedSize;
           lineCount = parsedLineCount;
+          const truncated2 = sizeBytes > req.maxBytesPerFile;
+          const sampleSize = Math.min(sizeBytes, 8192);
+          sampled = await this.readUntrackedRegularFile(repo, target, sampleSize);
+          if (!sniffBinary(sampled) && !truncated2 && sampleSize < sizeBytes) {
+            sampled = await this.readUntrackedRegularFile(repo, target, sizeBytes);
+          }
         }
         const truncated = sizeBytes > req.maxBytesPerFile || sampled.length > req.maxBytesPerFile;
         const bytes = truncated ? sampled.subarray(0, req.maxBytesPerFile) : sampled;
@@ -23222,14 +23377,14 @@ function withDockerNetwork(client, network) {
   };
 }
 async function connectDockerNetwork(network, containerId) {
-  const result = Bun.spawnSync(["docker", "network", "connect", network, containerId], {
-    stdout: "pipe",
-    stderr: "pipe"
+  const { spawnSync: spawnSync2 } = await import("child_process");
+  const result = spawnSync2("docker", ["network", "connect", network, containerId], {
+    encoding: "utf8"
   });
-  if (result.exitCode === 0) {
+  if (result.status === 0) {
     return;
   }
-  const stderr = new TextDecoder().decode(result.stderr);
+  const stderr = result.stderr ?? result.error?.message ?? "";
   if (stderr.includes("already exists")) {
     return;
   }
@@ -23893,4 +24048,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-RHB7ETON.js.map
+//# sourceMappingURL=chunk-3NUSY22C.js.map