doer-agent 0.4.4 → 0.4.6

package/dist/agent-fs-rpc.js

@@ -1,7 +1,8 @@
 import path from "node:path";
-import { gunzipSync, gzipSync } from "node:zlib";
-import { mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import crypto from "node:crypto";
 import { StringCodec } from "nats";
+import { create as createTar, extract as extractTar } from "tar";
 const fsRpcCodec = StringCodec();
 function normalizeFsRpcPath(workspaceRoot, rawPath) {
     const raw = typeof rawPath === "string" && rawPath.trim() ? rawPath.trim() : ".";
@@ -23,10 +24,9 @@ function normalizeFsRpcPath(workspaceRoot, rawPath) {
 function parseFsRpcAction(value) {
     if (value === "list" ||
         value === "stat" ||
-        value === "fetch_file" ||
+        value === "upload_file" ||
         value === "read_text" ||
-        value === "read_file" ||
-        value === "write_file" ||
+        value === "write_text" ||
         value === "download_file" ||
         value === "delete_path" ||
         value === "archive_dir" ||
@@ -88,33 +88,20 @@ function inferMimeType(filePath) {
     }
     return "application/octet-stream";
 }
-function normalizeArchiveRelativePath(value) {
-    const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-    if (!normalized || normalized.includes("..")) {
-        throw new Error("invalid archive entry path");
-    }
-    return normalized;
+function sha256Hex(bytes) {
+    return crypto.createHash("sha256").update(bytes).digest("hex");
 }
-async function collectDirectoryFiles(absDir, rootDir = absDir) {
-    const rows = await readdir(absDir, { withFileTypes: true });
-    const files = [];
-    for (const row of rows.sort((a, b) => a.name.localeCompare(b.name))) {
-        const child = path.join(absDir, row.name);
-        if (row.isDirectory()) {
-            files.push(...await collectDirectoryFiles(child, rootDir));
-            continue;
-        }
-        if (!row.isFile()) {
-            continue;
-        }
-        const bytes = await readFile(child);
-        files.push({
-            relPath: normalizeArchiveRelativePath(path.relative(rootDir, child)),
-            contentBase64: Buffer.from(bytes).toString("base64"),
-            sizeBytes: bytes.byteLength,
-        });
-    }
-    return files;
+async function createTarGzipBuffer(cwd, entries) {
+    const stream = createTar({
+        cwd,
+        gzip: true,
+        portable: true,
+    }, entries);
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
 }
 async function executeFsRpc(args) {
     const action = parseFsRpcAction(args.request.action);
@@ -168,13 +155,18 @@ async function executeFsRpc(args) {
             throw new Error("archivePath is required");
         }
         const archiveTarget = normalizeFsRpcPath(args.workspaceRoot, rawArchivePath);
-        const files = await collectDirectoryFiles(abs);
-        if (!files.some((file) => file.relPath === "SKILL.md")) {
+        try {
+            const manifestEntry = await stat(path.join(abs, "SKILL.md"));
+            if (!manifestEntry.isFile()) {
+                throw new Error("Selected skill directory must contain SKILL.md");
+            }
+        }
+        catch {
             throw new Error("Selected skill directory must contain SKILL.md");
         }
-        const payload = gzipSync(Buffer.from(JSON.stringify({ files }), "utf8"));
         await mkdir(path.dirname(archiveTarget.abs), { recursive: true });
-        await writeFile(archiveTarget.abs, payload);
+        const archiveBytes = await createTarGzipBuffer(abs, ["."]);
+        await writeFile(archiveTarget.abs, archiveBytes);
         const archiveStat = await stat(archiveTarget.abs);
         return {
             ok: true,
@@ -184,27 +176,58 @@ async function executeFsRpc(args) {
             size: archiveStat.size,
         };
     }
-    if (action === "fetch_file") {
+    if (action === "upload_file") {
         const entry = await stat(abs);
         if (!entry.isFile()) {
             throw new Error("path is not a file");
         }
         const uploadUrl = typeof args.request.uploadUrl === "string" ? args.request.uploadUrl : "";
-        const agentId = typeof args.request.agentId === "string" ? args.request.agentId : "";
-        if (!uploadUrl || !agentId) {
-            throw new Error("missing upload parameters");
+        const uploadMode = args.request.uploadMode === "multipart" ? "multipart" : "raw";
+        const uploadMethod = args.request.uploadMethod === "POST" ? "POST" : "PUT";
+        const uploadContentType = typeof args.request.uploadContentType === "string" && args.request.uploadContentType.trim()
+            ? args.request.uploadContentType.trim()
+            : inferMimeType(abs);
+        const uploadFieldName = typeof args.request.uploadFieldName === "string" && args.request.uploadFieldName.trim()
+            ? args.request.uploadFieldName.trim()
+            : "file";
+        if (!uploadUrl) {
+            throw new Error("uploadUrl is required");
         }
         const resolvedUploadUrl = new URL(uploadUrl, `${args.serverBaseUrl}/`).toString();
         const data = await readFile(abs);
         const fileName = path.basename(abs) || "file";
-        const form = new FormData();
-        form.append("file", new File([data], fileName));
-        form.append("agentId", agentId);
-        const response = await fetch(resolvedUploadUrl, {
-            method: "POST",
-            headers: { Authorization: `Bearer ${args.agentToken}` },
-            body: form,
-        });
+        const serverOrigin = new URL(args.serverBaseUrl).origin;
+        const targetOrigin = new URL(resolvedUploadUrl).origin;
+        const headers = {};
+        if (targetOrigin === serverOrigin) {
+            headers.Authorization = `Bearer ${args.agentToken}`;
+        }
+        let response;
+        if (uploadMode === "multipart") {
+            const form = new FormData();
+            const formFields = args.request.formFields && typeof args.request.formFields === "object" && !Array.isArray(args.request.formFields)
+                ? args.request.formFields
+                : {};
+            for (const [key, value] of Object.entries(formFields)) {
+                if (typeof value === "string") {
+                    form.append(key, value);
+                }
+            }
+            form.append(uploadFieldName, new File([data], fileName, { type: uploadContentType }));
+            response = await fetch(resolvedUploadUrl, {
+                method: uploadMethod,
+                headers,
+                body: form,
+            });
+        }
+        else {
+            headers["Content-Type"] = uploadContentType;
+            response = await fetch(resolvedUploadUrl, {
+                method: uploadMethod,
+                headers,
+                body: data,
+            });
+        }
         const text = await response.text();
         let upload = {};
         try {
@@ -225,15 +248,12 @@ async function executeFsRpc(args) {
             upload,
         };
     }
-    if (action === "write_file") {
-        const contentBase64 = typeof args.request.contentBase64 === "string" ? args.request.contentBase64 : "";
-        if (!contentBase64) {
-            throw new Error("contentBase64 is required");
-        }
+    if (action === "write_text") {
+        const text = typeof args.request.text === "string" ? args.request.text : "";
+        const encoding = typeof args.request.encoding === "string" && args.request.encoding ? args.request.encoding : "utf8";
         const parentDir = path.dirname(abs);
         await mkdir(parentDir, { recursive: true });
-        const bytes = Buffer.from(contentBase64, "base64");
-        await writeFile(abs, bytes);
+        await writeFile(abs, text, { encoding: encoding });
         const entry = await stat(abs);
         return {
             ok: true,
@@ -243,6 +263,7 @@ async function executeFsRpc(args) {
             size: entry.size,
             mimeType: inferMimeType(abs),
             mtimeMs: entry.mtimeMs,
+            encoding,
         };
     }
     if (action === "delete_path") {
@@ -277,6 +298,9 @@ async function executeFsRpc(args) {
         const parentDir = path.dirname(abs);
         await mkdir(parentDir, { recursive: true });
         await writeFile(abs, bytes);
+        if (abs.endsWith(".skillpkg")) {
+            console.log(`[doer-agent] skillpkg downloaded path=${formatPath(abs)} size=${bytes.byteLength} sha256=${sha256Hex(bytes)}`);
+        }
         const entry = await stat(abs);
         return {
             ok: true,
@@ -299,18 +323,42 @@ async function executeFsRpc(args) {
         }
         const destinationTarget = normalizeFsRpcPath(args.workspaceRoot, rawDestinationPath);
         const archiveBytes = await readFile(abs);
-        const decoded = JSON.parse(gunzipSync(archiveBytes).toString("utf8"));
-        const files = Array.isArray(decoded.files) ? decoded.files : [];
-        await mkdir(destinationTarget.abs, { recursive: true });
-        for (const file of files) {
-            const relPath = typeof file.relPath === "string" ? normalizeArchiveRelativePath(file.relPath) : "";
-            const contentBase64 = typeof file.contentBase64 === "string" ? file.contentBase64 : "";
-            if (!relPath || !contentBase64) {
-                throw new Error("archive contains an invalid file entry");
+        const magic = archiveBytes.subarray(0, 8).toString("hex");
+        const digest = sha256Hex(archiveBytes);
+        const destinationParent = path.dirname(destinationTarget.abs);
+        const tempDestinationAbs = path.join(destinationParent, `.tmp-extract-${path.basename(destinationTarget.abs)}-${crypto.randomBytes(6).toString("hex")}`);
+        await mkdir(destinationParent, { recursive: true });
+        try {
+            const existing = await stat(destinationTarget.abs);
+            if (existing.isDirectory()) {
+                const entries = await readdir(destinationTarget.abs);
+                if (entries.length > 0) {
+                    throw new Error("destinationPath already exists");
+                }
+            }
+            else {
+                throw new Error("destinationPath already exists");
+            }
+            await rm(destinationTarget.abs, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !error.message.includes("ENOENT")) {
+                throw error;
             }
-            const targetPath = path.join(destinationTarget.abs, relPath);
-            await mkdir(path.dirname(targetPath), { recursive: true });
-            await writeFile(targetPath, Buffer.from(contentBase64, "base64"));
+        }
+        await mkdir(tempDestinationAbs, { recursive: true });
+        try {
+            await extractTar({
+                cwd: tempDestinationAbs,
+                file: abs,
+                gzip: true,
+            });
+            await rename(tempDestinationAbs, destinationTarget.abs);
+        }
+        catch (error) {
+            await rm(tempDestinationAbs, { recursive: true, force: true }).catch(() => undefined);
+            const message = error instanceof Error ? error.message : "extract failed";
+            throw new Error(`${message} (magic=${magic} size=${archiveBytes.byteLength} sha256=${digest})`);
         }
         return {
             ok: true,
@@ -323,21 +371,6 @@ async function executeFsRpc(args) {
     if (!entry.isFile()) {
         throw new Error("path is not a file");
     }
-    if (action === "read_file") {
-        const maxBytes = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.maxBytes, 2_000_000), 5_000_000));
-        const data = await readFile(abs);
-        const truncated = data.byteLength > maxBytes;
-        const bytes = truncated ? data.subarray(0, maxBytes) : data;
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            mimeType: inferMimeType(abs),
-            size: entry.size,
-            truncated,
-            contentBase64: bytes.toString("base64"),
-        };
-    }
     const offset = Math.max(0, normalizeFsRpcNumber(args.request.offset, 0));
     const length = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.length, 65536), 262144));
     const encoding = typeof args.request.encoding === "string" && args.request.encoding ? args.request.encoding : "utf8";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",
@@ -26,7 +26,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@openai/codex-sdk": "^0.115.0",
-    "nats": "^2.29.3"
+    "nats": "^2.29.3",
+    "tar": "^7.5.13"
   },
   "devDependencies": {
     "@types/node": "^20",