doer-agent 0.3.1 → 0.3.4

package/dist/agent.js

@@ -1,8 +1,9 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, statSync, watch } from "node:fs";
-import { chmod, mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, readFile, readdir, realpath, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { gunzipSync, gzipSync } from "node:zlib";
 import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, StringCodec } from "nats";
 const DEFAULT_SERVER_BASE_URL = "https://doer.cranix.net";
 const AGENT_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -2427,7 +2428,9 @@ function parseFsRpcAction(value) {
         value === "read_file" ||
         value === "write_file" ||
         value === "download_file" ||
-        value === "delete_path") {
+        value === "delete_path" ||
+        value === "archive_dir" ||
+        value === "extract_archive") {
         return value;
     }
     throw new Error("unsupported action");
@@ -2485,6 +2488,34 @@ 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;
+}
+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 executeFsRpc(args) {
     const action = parseFsRpcAction(args.request.action);
     const { abs, formatPath } = normalizeFsRpcPath(args.request.path);
@@ -2527,6 +2558,34 @@ async function executeFsRpc(args) {
             total: items.length,
         };
     }
+    if (action === "archive_dir") {
+        const entry = await stat(abs);
+        if (!entry.isDirectory()) {
+            throw new Error("path is not a directory");
+        }
+        const rawArchivePath = typeof args.request.archivePath === "string" ? args.request.archivePath : "";
+        if (!rawArchivePath) {
+            throw new Error("archivePath is required");
+        }
+        const archiveTarget = normalizeFsRpcPath(rawArchivePath);
+        const files = await collectDirectoryFiles(abs);
+        if (!files.some((file) => file.relPath === "SKILL.md")) {
+            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 archiveStat = await stat(archiveTarget.abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            archivePath: archiveTarget.formatPath(archiveTarget.abs),
+            size: archiveStat.size,
+        };
+    }
     if (action === "fetch_file") {
         const entry = await stat(abs);
         if (!entry.isFile()) {
@@ -2537,12 +2596,13 @@ async function executeFsRpc(args) {
         if (!uploadUrl || !agentId) {
             throw new Error("missing upload parameters");
         }
+        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(uploadUrl, {
+        const response = await fetch(resolvedUploadUrl, {
             method: "POST",
             headers: { Authorization: `Bearer ${args.agentToken}` },
             body: form,
@@ -2627,6 +2687,37 @@ async function executeFsRpc(args) {
             mtimeMs: entry.mtimeMs,
         };
     }
+    if (action === "extract_archive") {
+        const archiveEntry = await stat(abs);
+        if (!archiveEntry.isFile()) {
+            throw new Error("path is not a file");
+        }
+        const rawDestinationPath = typeof args.request.destinationPath === "string" ? args.request.destinationPath : "";
+        if (!rawDestinationPath) {
+            throw new Error("destinationPath is required");
+        }
+        const destinationTarget = normalizeFsRpcPath(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 targetPath = path.join(destinationTarget.abs, relPath);
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await writeFile(targetPath, Buffer.from(contentBase64, "base64"));
+        }
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: destinationTarget.formatPath(destinationTarget.abs),
+        };
+    }
     const entry = await stat(abs);
     if (!entry.isFile()) {
         throw new Error("path is not a file");
@@ -3273,6 +3364,7 @@ function stopAllSessionWatchers() {
 }
 async function startSessionWatch(args) {
     const resolvedFile = resolveSessionFilePath(args.filePath);
+    const canonicalFile = await realpath(resolvedFile).catch(() => resolvedFile);
     const watchId = `watch_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
     let watcher = null;
     let active = true;
@@ -3297,9 +3389,9 @@ async function startSessionWatch(args) {
             return;
         }
         active = false;
+        activeSessionWatchers.delete(watchId);
         watcher?.close();
         watcher = null;
-        activeSessionWatchers.delete(watchId);
     };
     const notifyFromContent = () => {
         emitEvent({
@@ -3307,8 +3399,13 @@ async function startSessionWatch(args) {
             at: formatLocalTimestamp(),
         });
     };
-    watcher = watch(resolvedFile, () => {
-        notifyFromContent();
+    watcher = watch(canonicalFile, { persistent: false }, (eventType) => {
+        if (!active) {
+            return;
+        }
+        if (eventType === "change" || eventType === "rename") {
+            notifyFromContent();
+        }
     });
     activeSessionWatchers.set(watchId, cleanup);
     emitEvent({ type: "stream.started", watchId, at: formatLocalTimestamp() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",