toolcraft 0.0.749 → 0.0.750

package/node_modules/@poe-code/process-runner/dist/workspace-transfer.js

@@ -1,10 +1,12 @@
-import { createHash, randomUUID } from "node:crypto";
-import { promises as nodeFs } from "node:fs";
-import path from "node:path";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { posixPath } from "@poe-code/safe-fs/contracts";
+import { createDefaultFileSystem } from "#transfer-filesystem";
+const path = { ...posixPath, resolve: (...parts) => posixPath.resolve(globalThis.process?.cwd?.() ?? "/", ...parts) };
 const uploadState = new WeakMap();
 export async function uploadWorkspace(env, opts) {
-    const localFs = env.fs ?? nodeFs;
-    const remoteFs = env.remoteFs ?? localFs;
+    const localFs = transferFileSystem(env.fs);
+    const remoteFs = env.remoteFs ? transferFileSystem(env.remoteFs) : localFs;
     const workspaceDir = env.workspaceDir ?? "/workspace";
     const maxBytes = resolveUploadMaxBytes(opts);
     const warn = opts.warn ?? console.warn;
@@ -24,7 +26,7 @@ export async function uploadWorkspace(env, opts) {
         const content = await localFs.readFile(file.absolutePath);
         const bytes = content.byteLength;
         state.set(file.path, {
-            hash: hashBuffer(content),
+            hash: hashUint8Array(content),
             uploaded: false
         });
         if (bytes > maxBytes) {
@@ -34,7 +36,7 @@ export async function uploadWorkspace(env, opts) {
         }
         entries.push({ ...file, bytes, content });
         state.set(file.path, {
-            hash: hashBuffer(content),
+            hash: hashUint8Array(content),
             uploaded: true
         });
     }
@@ -78,8 +80,8 @@ export async function uploadWorkspace(env, opts) {
     };
 }
 export async function downloadWorkspace(env, opts) {
-    const localFs = env.fs ?? nodeFs;
-    const remoteFs = env.remoteFs ?? localFs;
+    const localFs = transferFileSystem(env.fs);
+    const remoteFs = env.remoteFs ? transferFileSystem(env.remoteFs) : localFs;
     const workspaceDir = env.workspaceDir ?? "/workspace";
     const state = uploadState.get(env) ?? new Map();
     const remoteFiles = await listFilesIfExists(remoteFs, workspaceDir, { rejectSymlinks: true });
@@ -98,7 +100,7 @@ export async function downloadWorkspace(env, opts) {
         }
         await writeFileAtomically(localFs, env.cwd, localPath, remoteContent, ".download-tmp");
         state.set(remoteFile.path, {
-            hash: hashBuffer(remoteContent),
+            hash: hashUint8Array(remoteContent),
             uploaded: true
         });
         files += 1;
@@ -114,7 +116,7 @@ export async function downloadWorkspace(env, opts) {
         if (localContent === null) {
             continue;
         }
-        if (opts.conflictPolicy === "refuse" && hashBuffer(localContent) !== fileState.hash) {
+        if (opts.conflictPolicy === "refuse" && hashUint8Array(localContent) !== fileState.hash) {
             conflicts.push({ path: relativePath, reason: "local_modified" });
             continue;
         }
@@ -172,7 +174,7 @@ async function readIgnoreFile(fs, cwd, fileName, allowNegation) {
     if (content === null) {
         return [];
     }
-    return parseIgnoreLines(content.toString("utf8").split("\n"), allowNegation, "");
+    return parseIgnoreLines(new TextDecoder("utf-8", { ignoreBOM: true }).decode(content).split("\n"), allowNegation, "");
 }
 async function readGitignoreRules(fs, cwd, files) {
     const rules = [];
@@ -343,8 +345,8 @@ async function isDownloadConflict(fs, localPath, relativePath, remoteContent, st
     if (localContent === null) {
         return false;
     }
-    const localHash = hashBuffer(localContent);
-    const remoteHash = hashBuffer(remoteContent);
+    const localHash = hashUint8Array(localContent);
+    const remoteHash = hashUint8Array(remoteContent);
     const uploadedHash = state.get(relativePath)?.hash;
     const localChanged = uploadedHash === undefined || localHash !== uploadedHash;
     return localChanged && localHash !== remoteHash;
@@ -397,7 +399,7 @@ async function renamePath(fs, sourcePath, destinationPath) {
     await fs.rename(sourcePath, destinationPath);
 }
 async function writeFileAtomically(fs, workspacePath, destinationPath, data, temporarySuffix) {
-    const temporaryPath = `${destinationPath}.${randomUUID()}${temporarySuffix}`;
+    const temporaryPath = `${destinationPath}.${crypto.randomUUID()}${temporarySuffix}`;
     let temporaryCreated = false;
     await fs.mkdir(path.dirname(destinationPath), { recursive: true });
     try {
@@ -468,13 +470,19 @@ function createTar(entries) {
     for (const entry of entries) {
         chunks.push(createTarHeader(entry.path, entry.bytes));
         chunks.push(entry.content);
-        chunks.push(Buffer.alloc(paddingFor(entry.bytes)));
+        chunks.push(new Uint8Array(paddingFor(entry.bytes)));
     }
-    chunks.push(Buffer.alloc(1024));
-    return Buffer.concat(chunks);
+    chunks.push(new Uint8Array(1024));
+    const result = new Uint8Array(chunks.reduce((sum, chunk) => sum + chunk.length, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
 }
 function createTarHeader(name, size) {
-    const header = Buffer.alloc(512);
+    const header = new Uint8Array(512);
     const { entryName, prefix } = splitTarPath(name);
     writeString(header, entryName, 0, 100);
     writeOctal(header, 0o644, 100, 8);
@@ -483,22 +491,22 @@ function createTarHeader(name, size) {
     writeOctal(header, size, 124, 12);
     writeOctal(header, 0, 136, 12);
     header.fill(32, 148, 156);
-    header.write("0", 156, 1, "ascii");
-    header.write("ustar", 257, 5, "ascii");
-    header.write("00", 263, 2, "ascii");
+    writeString(header, "0", 156, 1);
+    writeString(header, "ustar", 257, 5);
+    writeString(header, "00", 263, 2);
     writeString(header, prefix, 345, 155);
     writeOctal(header, checksum(header), 148, 8);
     return header;
 }
 function splitTarPath(name) {
-    if (Buffer.byteLength(name) <= 100) {
+    if (new TextEncoder().encode(name).length <= 100) {
         return { entryName: name, prefix: "" };
     }
     let separatorIndex = name.lastIndexOf("/");
     while (separatorIndex !== -1) {
         const prefix = name.slice(0, separatorIndex);
         const entryName = name.slice(separatorIndex + 1);
-        if (Buffer.byteLength(entryName) <= 100 && Buffer.byteLength(prefix) <= 155) {
+        if (new TextEncoder().encode(entryName).length <= 100 && new TextEncoder().encode(prefix).length <= 155) {
             return { entryName, prefix };
         }
         separatorIndex = name.lastIndexOf("/", separatorIndex - 1);
@@ -506,12 +514,12 @@ function splitTarPath(name) {
     throw new Error(`Workspace tar path is too long to represent: ${name}`);
 }
 function writeString(buffer, value, offset, length) {
-    const text = Buffer.from(value);
-    text.copy(buffer, offset, 0, Math.min(text.length, length));
+    const text = new TextEncoder().encode(value);
+    buffer.set(text.subarray(0, length), offset);
 }
 function writeOctal(buffer, value, offset, length) {
     const text = value.toString(8).padStart(length - 1, "0");
-    buffer.write(text.slice(0, length - 1), offset, length - 1, "ascii");
+    writeString(buffer, text, offset, length - 1);
     buffer[offset + length - 1] = 0;
 }
 function checksum(buffer) {
@@ -521,8 +529,8 @@ function paddingFor(size) {
     const remainder = size % 512;
     return remainder === 0 ? 0 : 512 - remainder;
 }
-function hashBuffer(buffer) {
-    return createHash("sha256").update(buffer).digest("hex");
+function hashUint8Array(buffer) {
+    return bytesToHex(sha256(buffer));
 }
 function toRelativePath(root, absolutePath) {
     return normalizeRelativePath(path.relative(root, absolutePath));
@@ -553,3 +561,33 @@ function hasOwnErrorCode(error, code) {
         Object.prototype.hasOwnProperty.call(error, "code") &&
         error.code === code);
 }
+function transferFileSystem(fs = createDefaultFileSystem()) {
+    if (!("capabilities" in fs))
+        return fs;
+    const predicates = (entry) => ({
+        isFile: () => entry.type === "file", isDirectory: () => entry.type === "directory",
+        isSymbolicLink: () => entry.type === "symlink"
+    });
+    async function readFile(path, encoding) {
+        const bytes = await fs.readFile(path);
+        return encoding ? new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes) : bytes;
+    }
+    return {
+        mkdir: async (path, options) => { await fs.mkdir(path, options); },
+        readdir: async (path) => (await fs.readdir(path)).map(entry => ({ name: entry.name, ...predicates(entry) })),
+        readFile,
+        async writeFile(path, data, options) {
+            const flag = options?.flag;
+            if (flag !== undefined && flag !== "w" && flag !== "wx" && flag !== "a" && flag !== "ax")
+                throw new Error("Unsupported workspace write flag.");
+            await fs.writeFile(path, typeof data === "string" ? new TextEncoder().encode(data) : data, { ...options, flag });
+        },
+        stat: async (path) => { const stat = await fs.stat(path); return { size: stat.size, ...predicates(stat) }; },
+        lstat: async (path) => { const stat = await fs.lstat(path); return { size: stat.size, ...predicates(stat) }; },
+        rename: (from, to) => fs.rename(from, to),
+        async unlink(path) { if (!fs.unlink)
+            throw new Error("Workspace transfer requires unlink support."); await fs.unlink(path); },
+        async rmdir(path) { if (!fs.rmdir)
+            throw new Error("Workspace transfer requires rmdir support."); await fs.rmdir(path); }
+    };
+}

package/node_modules/@poe-code/process-runner/package.json

@@ -16,6 +16,10 @@
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"
+    },
+    "./workspace-transfer": {
+      "types": "./dist/workspace-transfer.d.ts",
+      "import": "./dist/workspace-transfer.js"
     }
   },
   "scripts": {
@@ -32,5 +36,14 @@
     "type": "git",
     "url": "git+https://github.com/poe-platform/poe-code.git",
     "directory": "packages/process-runner"
+  },
+  "imports": {
+    "#transfer-filesystem": {
+      "types": "./src/transfer-filesystem.ts",
+      "workerd": "./dist/transfer-filesystem.workerd.js",
+      "browser": "./dist/transfer-filesystem.workerd.js",
+      "worker": "./dist/transfer-filesystem.workerd.js",
+      "default": "./dist/transfer-filesystem.js"
+    }
   }
 }

package/node_modules/@poe-code/safe-fs/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.