@ai-sdk/harness-pi 1.0.101 → 1.0.102

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @ai-sdk/harness-pi
 
+## 1.0.102
+
+### Patch Changes
+
+- 7c3211d: fix (harness-pi): transfer the workspace mirror as batched archives instead of one request per file
+- Updated dependencies [0c37bf0]
+  - @ai-sdk/harness@1.0.100
+
 ## 1.0.101
 
 ### Patch Changes

package/dist/index.js

@@ -134,7 +134,7 @@ import {
 import { access } from "fs/promises";
 
 // src/version.ts
-var VERSION = true ? "1.0.101" : "0.0.0-test";
+var VERSION = true ? "1.0.102" : "0.0.0-test";
 
 // src/pi-auth.ts
 var DEFAULT_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
@@ -1662,9 +1662,12 @@ import {
   writeFile as writeFile2
 } from "fs/promises";
 import path6 from "path";
+import { gunzipSync } from "zlib";
 import { shellQuote as shellQuote2 } from "@ai-sdk/harness/utils";
 var PI_CONFIG_DIRS = [".pi", ".agents"];
 var PI_CONTEXT_FILENAMES = ["AGENTS.md", "AGENTS.MD"];
+var ARCHIVE_BATCH_SIZE = 300;
+var TAR_BLOCK_SIZE = 512;
 function normalizeRelativePath(inputPath) {
   const normalized = inputPath.split(path6.posix.sep).join(path6.sep);
   const relative = path6.normalize(normalized);
@@ -1802,6 +1805,74 @@ async function listRemoteWorkspaceEntries(sandbox, sandboxWorkDir) {
   }
   return { directories, files };
 }
+function readTarString(header, offset, length) {
+  const field = header.subarray(offset, offset + length);
+  const end = field.indexOf(0);
+  return field.subarray(0, end === -1 ? field.length : end).toString("utf8");
+}
+function parseTarFiles(archive) {
+  const files = /* @__PURE__ */ new Map();
+  let overrideName;
+  let offset = 0;
+  while (offset + TAR_BLOCK_SIZE <= archive.length) {
+    const header = archive.subarray(offset, offset + TAR_BLOCK_SIZE);
+    if (header.every((byte) => byte === 0)) break;
+    const size = Number.parseInt(
+      readTarString(header, 124, 12).trim() || "0",
+      8
+    );
+    const typeFlag = String.fromCharCode(header[156]);
+    const dataStart = offset + TAR_BLOCK_SIZE;
+    const data = archive.subarray(dataStart, dataStart + size);
+    offset = dataStart + Math.ceil(size / TAR_BLOCK_SIZE) * TAR_BLOCK_SIZE;
+    if (typeFlag === "L") {
+      overrideName = readTarString(data, 0, data.length);
+      continue;
+    }
+    if (typeFlag === "x" || typeFlag === "X") {
+      const pathRecord = data.toString("utf8").split("\n").map((record) => /^\d+ path=(.*)$/.exec(record)?.[1]).find((value) => value != null);
+      if (pathRecord != null) overrideName = pathRecord;
+      continue;
+    }
+    if (typeFlag === "0" || typeFlag === "\0") {
+      const name = readTarString(header, 0, 100);
+      const prefix = readTarString(header, 345, 155);
+      files.set(
+        overrideName ?? (prefix === "" ? name : `${prefix}/${name}`),
+        Buffer.from(data)
+      );
+    }
+    overrideName = void 0;
+  }
+  return files;
+}
+async function readSandboxFilesAsArchive(sandbox, sandboxPaths) {
+  const members = sandboxPaths.map(
+    (sandboxPath) => sandboxPath.replace(/^\/+/, "")
+  );
+  const command = `tar -C / -czf - -- ${members.map(shellQuote2).join(" ")} 2>/dev/null | base64`;
+  let encoded;
+  try {
+    encoded = (await readCommandOutput(sandbox, command)).replace(/\s+/g, "");
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  if (encoded === "") return /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = parseTarFiles(gunzipSync(Buffer.from(encoded, "base64")));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  const contents = /* @__PURE__ */ new Map();
+  for (const [index, member] of members.entries()) {
+    const content = entries.get(member);
+    if (content != null) {
+      contents.set(sandboxPaths[index], content);
+    }
+  }
+  return contents;
+}
 async function pathKind(target) {
   try {
     const stats = await stat(target);
@@ -1888,25 +1959,38 @@ async function syncHostWorkspaceFromSandbox(args) {
   )) {
     await mkdir2(path6.join(hostWorkDir, relativePath), { recursive: true });
   }
-  for (const { relativePath, sandboxPath } of remoteEntries.files) {
-    const bytes = await sandbox.readBinaryFile({ path: sandboxPath });
-    if (!bytes) {
-      throw new Error(
-        `Sandbox workspace file disappeared during mirror sync: ${sandboxPath}`
-      );
-    }
-    const content = Buffer.from(bytes);
-    const hostPath = path6.join(hostWorkDir, relativePath);
-    let shouldWrite = true;
-    try {
-      const existing = await readFile2(hostPath);
-      shouldWrite = !existing.equals(content);
-    } catch {
-      shouldWrite = true;
-    }
-    if (shouldWrite) {
-      await mkdir2(path6.dirname(hostPath), { recursive: true });
-      await writeFile2(hostPath, content);
+  for (let offset = 0; offset < remoteEntries.files.length; offset += ARCHIVE_BATCH_SIZE) {
+    const batch = remoteEntries.files.slice(
+      offset,
+      offset + ARCHIVE_BATCH_SIZE
+    );
+    const archived = await readSandboxFilesAsArchive(
+      sandbox,
+      batch.map((file) => file.sandboxPath)
+    );
+    for (const { relativePath, sandboxPath } of batch) {
+      let content = archived.get(sandboxPath);
+      if (content == null) {
+        const bytes = await sandbox.readBinaryFile({ path: sandboxPath });
+        if (!bytes) {
+          throw new Error(
+            `Sandbox workspace file disappeared during mirror sync: ${sandboxPath}`
+          );
+        }
+        content = Buffer.from(bytes);
+      }
+      const hostPath = path6.join(hostWorkDir, relativePath);
+      let shouldWrite = true;
+      try {
+        const existing = await readFile2(hostPath);
+        shouldWrite = !existing.equals(content);
+      } catch {
+        shouldWrite = true;
+      }
+      if (shouldWrite) {
+        await mkdir2(path6.dirname(hostPath), { recursive: true });
+        await writeFile2(hostPath, content);
+      }
     }
   }
 }