doer-agent 0.4.2 → 0.4.4

package/dist/agent-fs-rpc.js

@@ -0,0 +1,405 @@
+import path from "node:path";
+import { gunzipSync, gzipSync } from "node:zlib";
+import { mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { StringCodec } from "nats";
+const fsRpcCodec = StringCodec();
+function normalizeFsRpcPath(workspaceRoot, rawPath) {
+    const raw = typeof rawPath === "string" && rawPath.trim() ? rawPath.trim() : ".";
+    const normalizedRaw = raw.replace(/\\/g, "/");
+    const useAbsolute = path.isAbsolute(normalizedRaw);
+    const rel = normalizedRaw.replace(/^\/+/, "") || ".";
+    const abs = useAbsolute ? path.resolve(normalizedRaw) : path.resolve(workspaceRoot, rel);
+    if (!useAbsolute && abs !== workspaceRoot && !abs.startsWith(workspaceRoot + path.sep)) {
+        throw new Error("path escapes workspace root");
+    }
+    const formatPath = (target) => {
+        if (useAbsolute) {
+            return target.split(path.sep).join("/") || "/";
+        }
+        return path.relative(workspaceRoot, target).split(path.sep).join("/") || ".";
+    };
+    return { abs, formatPath };
+}
+function parseFsRpcAction(value) {
+    if (value === "list" ||
+        value === "stat" ||
+        value === "fetch_file" ||
+        value === "read_text" ||
+        value === "read_file" ||
+        value === "write_file" ||
+        value === "download_file" ||
+        value === "delete_path" ||
+        value === "archive_dir" ||
+        value === "extract_archive") {
+        return value;
+    }
+    throw new Error("unsupported action");
+}
+function normalizeFsRpcNumber(value, fallback) {
+    const n = Number(value);
+    if (!Number.isFinite(n)) {
+        return fallback;
+    }
+    return Math.floor(n);
+}
+function inferMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".txt" || ext === ".md" || ext === ".log") {
+        return "text/plain";
+    }
+    if (ext === ".json") {
+        return "application/json";
+    }
+    if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
+        return "text/javascript";
+    }
+    if (ext === ".ts" || ext === ".tsx") {
+        return "text/typescript";
+    }
+    if (ext === ".jsx") {
+        return "text/jsx";
+    }
+    if (ext === ".css") {
+        return "text/css";
+    }
+    if (ext === ".html" || ext === ".htm") {
+        return "text/html";
+    }
+    if (ext === ".xml") {
+        return "application/xml";
+    }
+    if (ext === ".svg") {
+        return "image/svg+xml";
+    }
+    if (ext === ".png") {
+        return "image/png";
+    }
+    if (ext === ".jpg" || ext === ".jpeg") {
+        return "image/jpeg";
+    }
+    if (ext === ".gif") {
+        return "image/gif";
+    }
+    if (ext === ".webp") {
+        return "image/webp";
+    }
+    if (ext === ".pdf") {
+        return "application/pdf";
+    }
+    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.workspaceRoot, args.request.path);
+    if (action === "stat") {
+        const entry = await stat(abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            kind: entry.isDirectory() ? "dir" : "file",
+            size: entry.size,
+            mtimeMs: entry.mtimeMs,
+        };
+    }
+    if (action === "list") {
+        const entry = await stat(abs);
+        if (!entry.isDirectory()) {
+            throw new Error("path is not a directory");
+        }
+        const limit = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.limit, 200), 1000));
+        const rows = await readdir(abs, { withFileTypes: true });
+        const items = await Promise.all(rows.map(async (row) => {
+            const child = path.join(abs, row.name);
+            const childStat = await stat(child);
+            return {
+                name: row.name,
+                path: formatPath(child),
+                kind: row.isDirectory() ? "dir" : "file",
+                size: childStat.size,
+                mtimeMs: childStat.mtimeMs,
+            };
+        }));
+        items.sort((a, b) => (a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1));
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            items: items.slice(0, limit),
+            truncated: items.length > limit,
+            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(args.workspaceRoot, 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()) {
+            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 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 text = await response.text();
+        let upload = {};
+        try {
+            upload = JSON.parse(text || "{}");
+        }
+        catch {
+            upload = {};
+        }
+        if (!response.ok) {
+            const message = typeof upload.error === "string" ? upload.error : `upload failed: ${response.status}`;
+            throw new Error(message);
+        }
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            size: entry.size,
+            upload,
+        };
+    }
+    if (action === "write_file") {
+        const contentBase64 = typeof args.request.contentBase64 === "string" ? args.request.contentBase64 : "";
+        if (!contentBase64) {
+            throw new Error("contentBase64 is required");
+        }
+        const parentDir = path.dirname(abs);
+        await mkdir(parentDir, { recursive: true });
+        const bytes = Buffer.from(contentBase64, "base64");
+        await writeFile(abs, bytes);
+        const entry = await stat(abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: abs.split(path.sep).join("/"),
+            size: entry.size,
+            mimeType: inferMimeType(abs),
+            mtimeMs: entry.mtimeMs,
+        };
+    }
+    if (action === "delete_path") {
+        await rm(abs, { recursive: true, force: true });
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: abs.split(path.sep).join("/"),
+        };
+    }
+    if (action === "download_file") {
+        const downloadPath = typeof args.request.downloadPath === "string" ? args.request.downloadPath.trim() : "";
+        if (!downloadPath) {
+            throw new Error("downloadPath is required");
+        }
+        const downloadUrl = new URL(downloadPath, `${args.serverBaseUrl}/`).toString();
+        const serverOrigin = new URL(args.serverBaseUrl).origin;
+        const headers = {};
+        if (new URL(downloadUrl).origin === serverOrigin) {
+            headers.Authorization = `Bearer ${args.agentToken}`;
+        }
+        const response = await fetch(downloadUrl, {
+            method: "GET",
+            headers,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new Error(text || `download failed: ${response.status}`);
+        }
+        const bytes = Buffer.from(await response.arrayBuffer());
+        const parentDir = path.dirname(abs);
+        await mkdir(parentDir, { recursive: true });
+        await writeFile(abs, bytes);
+        const entry = await stat(abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: abs.split(path.sep).join("/"),
+            size: entry.size,
+            mimeType: inferMimeType(abs),
+            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(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 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");
+    }
+    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";
+    const fd = await open(abs, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const readResult = await fd.read(buffer, 0, length, offset);
+        const slice = buffer.subarray(0, readResult.bytesRead);
+        try {
+            const text = slice.toString(encoding);
+            return {
+                ok: true,
+                action,
+                path: formatPath(abs),
+                offset,
+                length: readResult.bytesRead,
+                totalSize: entry.size,
+                eof: offset + readResult.bytesRead >= entry.size,
+                encoding,
+                text,
+                bytesRead: readResult.bytesRead,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "failed to decode text";
+            return {
+                ok: false,
+                action,
+                path: formatPath(abs),
+                error: message,
+            };
+        }
+    }
+    finally {
+        await fd.close();
+    }
+}
+export async function handleFsRpcMessage(args) {
+    let payload = {};
+    try {
+        payload = JSON.parse(fsRpcCodec.decode(args.msg.data));
+        if (typeof payload.agentId === "string" && payload.agentId.trim() && payload.agentId !== args.agentId) {
+            throw new Error("agent id mismatch");
+        }
+        const result = await executeFsRpc({
+            workspaceRoot: args.workspaceRoot,
+            request: payload,
+            serverBaseUrl: args.serverBaseUrl,
+            agentToken: args.agentToken,
+        });
+        args.msg.respond(fsRpcCodec.encode(JSON.stringify(result)));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        const action = typeof payload.action === "string" ? payload.action : "";
+        const response = {
+            ok: false,
+            action,
+            path: typeof payload.path === "string" ? payload.path : ".",
+            error: message,
+        };
+        args.msg.respond(fsRpcCodec.encode(JSON.stringify(response)));
+        args.onError(`fs rpc failed action=${action || "unknown"} error=${message}`);
+    }
+}