doer-agent 0.1.9 → 0.2.0

package/dist/agent.js

@@ -1,9 +1,9 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType } from "nats";
+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));
 const AGENT_PROJECT_DIR = path.join(AGENT_MODULE_DIR, "..");
@@ -11,6 +11,8 @@ const AGENT_PACKAGE_JSON_PATH = path.join(AGENT_PROJECT_DIR, "package.json");
 let activeTaskLogContext = null;
 const activeTaskCancelRequests = new Map();
 let workspaceRootOverride = null;
+const fsRpcCodec = StringCodec();
+const shellRpcCodec = StringCodec();
 function sanitizeUserId(userId) {
     const normalized = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
     return normalized.length > 0 ? normalized : "anonymous";
@@ -534,6 +536,341 @@ function resolveTaskWorkspace(rawCwd) {
     }
     return resolvedCwd;
 }
+function buildAgentFsRpcSubject(userId, agentId) {
+    return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+function buildAgentShellRpcSubject(userId, agentId) {
+    return `doer.agent.shell.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+function normalizeFsRpcPath(rawPath) {
+    const root = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
+    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(root, rel);
+    if (!useAbsolute && abs !== root && !abs.startsWith(root + path.sep)) {
+        throw new Error("path escapes workspace root");
+    }
+    const formatPath = (target) => {
+        if (useAbsolute) {
+            return target.split(path.sep).join("/") || "/";
+        }
+        return path.relative(root, target).split(path.sep).join("/") || ".";
+    };
+    return { abs, formatPath };
+}
+function parseFsRpcAction(value) {
+    if (value === "list" || value === "stat" || value === "fetch_file" || value === "read_text") {
+        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);
+}
+async function executeFsRpc(args) {
+    const action = parseFsRpcAction(args.request.action);
+    const { abs, formatPath } = normalizeFsRpcPath(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 === "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 chatId = typeof args.request.chatId === "string" ? args.request.chatId : "";
+        const agentId = typeof args.request.agentId === "string" ? args.request.agentId : "";
+        if (!uploadUrl || !chatId || !agentId) {
+            throw new Error("missing upload parameters");
+        }
+        const data = await readFile(abs);
+        const fileName = path.basename(abs) || "file";
+        const form = new FormData();
+        form.append("file", new File([data], fileName));
+        form.append("chatId", chatId);
+        form.append("agentId", agentId);
+        const response = await fetch(uploadUrl, {
+            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,
+        };
+    }
+    const entry = await stat(abs);
+    if (!entry.isFile()) {
+        throw new Error("path is not a file");
+    }
+    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();
+    }
+}
+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({ request: payload, 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)));
+        writeAgentError(`fs rpc failed action=${action || "unknown"} error=${message}`);
+    }
+}
+function subscribeToFsRpc(args) {
+    const subject = buildAgentFsRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`fs rpc subscription error: ${message}`);
+                return;
+            }
+            void handleFsRpcMessage({
+                msg,
+                serverBaseUrl: args.serverBaseUrl,
+                userId: args.userId,
+                agentId: args.agentId,
+                agentToken: args.agentToken,
+            });
+        },
+    });
+    writeAgentInfo(`fs rpc subscribed subject=${subject}`);
+}
+function normalizeShellRpcRequest(args) {
+    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
+    if (!requestId) {
+        throw new Error("missing requestId");
+    }
+    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
+    if (!requestAgentId) {
+        throw new Error("missing agentId");
+    }
+    if (requestAgentId !== args.agentId) {
+        throw new Error("agent id mismatch");
+    }
+    const command = typeof args.request.command === "string" ? args.request.command.trim() : "";
+    if (!command) {
+        throw new Error("missing command");
+    }
+    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
+    if (!responseSubject) {
+        throw new Error("missing responseSubject");
+    }
+    const cwd = typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null;
+    const timeoutRaw = Number(args.request.timeoutMs);
+    const timeoutMs = Number.isFinite(timeoutRaw) ? Math.max(1000, Math.min(Math.floor(timeoutRaw), 300000)) : 30000;
+    return { requestId, command, cwd, timeoutMs, responseSubject };
+}
+function publishShellRpcResponse(args) {
+    args.nc.publish(args.responseSubject, shellRpcCodec.encode(JSON.stringify(args.payload)));
+}
+async function handleShellRpcMessage(args) {
+    let requestId = "unknown";
+    let responseSubject = "";
+    let stdout = "";
+    let stderr = "";
+    try {
+        const payload = JSON.parse(shellRpcCodec.decode(args.msg.data));
+        const request = normalizeShellRpcRequest({ request: payload, agentId: args.agentId });
+        requestId = request.requestId;
+        responseSubject = request.responseSubject;
+        const shellPath = resolveShellPath();
+        const taskWorkspace = resolveTaskWorkspace(request.cwd);
+        const runtimeBinPath = path.join(AGENT_PROJECT_DIR, "runtime/bin");
+        const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
+        const child = spawn(request.command, {
+            cwd: taskWorkspace,
+            shell: shellPath,
+            detached: process.platform !== "win32",
+            env: {
+                ...process.env,
+                WORKSPACE: taskWorkspace,
+                PATH: taskPath,
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            sendSignalToTaskProcess(child, "SIGTERM");
+            setTimeout(() => {
+                sendSignalToTaskProcess(child, "SIGKILL");
+            }, 1000).unref?.();
+        }, request.timeoutMs);
+        timeout.unref?.();
+        const result = await new Promise((resolve, reject) => {
+            child.once("error", reject);
+            child.once("close", (code, signal) => {
+                resolve({ exitCode: typeof code === "number" ? code : null, signal });
+            });
+        }).finally(() => {
+            clearTimeout(timeout);
+        });
+        publishShellRpcResponse({
+            nc: args.jetstream.nc,
+            responseSubject,
+            payload: {
+                requestId,
+                ok: !timedOut,
+                exitCode: result.exitCode,
+                signal: result.signal,
+                stdout,
+                stderr,
+                ...(timedOut ? { error: `Command timed out after ${request.timeoutMs}ms` } : {}),
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (responseSubject) {
+            publishShellRpcResponse({
+                nc: args.jetstream.nc,
+                responseSubject,
+                payload: {
+                    requestId,
+                    ok: false,
+                    exitCode: null,
+                    signal: null,
+                    stdout,
+                    stderr,
+                    error: message,
+                },
+            });
+        }
+        writeAgentError(`shell rpc failed requestId=${requestId} error=${message}`);
+    }
+}
+function subscribeToShellRpc(args) {
+    const subject = buildAgentShellRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`shell rpc subscription error: ${message}`);
+                return;
+            }
+            void handleShellRpcMessage({
+                msg,
+                jetstream: args.jetstream,
+                agentId: args.agentId,
+            });
+        },
+    });
+    writeAgentInfo(`shell rpc subscribed subject=${subject}`);
+}
 async function postJson(url, body) {
     const res = await fetch(url, {
         method: "POST",
@@ -980,12 +1317,16 @@ async function main() {
     });
     const maxConcurrency = Math.max(1, parseEnvInteger(process.env.DOER_AGENT_MAX_CONCURRENCY, 5));
     const agentVersion = await resolveAgentVersion();
+    const initialAgentId = typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "";
+    if (!initialAgentId) {
+        throw new Error("agent id missing from bootstrap");
+    }
     process.stdout.write(`\n[doer-agent v${agentVersion}]\n`);
     if (!usesDefaultServer) {
         process.stdout.write(`- server: ${serverBaseUrl}\n`);
     }
     process.stdout.write(`- userId: ${userId}\n`);
-    process.stdout.write(`- agentId: ${typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "unknown"}\n`);
+    process.stdout.write(`- agentId: ${initialAgentId}\n`);
     process.stdout.write(`\n- transport: nats\n`);
     process.stdout.write(`- natsServers: ${jetstream.servers.join(",")}\n`);
     process.stdout.write(`- natsStream: ${jetstream.stream}\n`);
@@ -1038,6 +1379,18 @@ async function main() {
         const taskPromise = taskPromiseFactory();
         trackInFlight(taskPromise);
     }
+    subscribeToFsRpc({
+        jetstream,
+        serverBaseUrl,
+        userId,
+        agentId: initialAgentId,
+        agentToken,
+    });
+    subscribeToShellRpc({
+        jetstream,
+        userId,
+        agentId: initialAgentId,
+    });
     for (const pendingTaskId of pendingTaskIds) {
         await waitForAvailableSlot();
         scheduleTask(async () => {
@@ -1167,6 +1520,22 @@ async function main() {
             natsBootstrap = refreshed.natsBootstrap;
             pendingTaskIds = refreshed.pendingTaskIds;
             jetstream = refreshed.jetstream;
+            const refreshedAgentId = typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "";
+            if (!refreshedAgentId) {
+                throw new Error("agent id missing from refreshed bootstrap");
+            }
+            subscribeToFsRpc({
+                jetstream,
+                serverBaseUrl,
+                userId,
+                agentId: refreshedAgentId,
+                agentToken,
+            });
+            subscribeToShellRpc({
+                jetstream,
+                userId,
+                agentId: refreshedAgentId,
+            });
             for (const pendingTaskId of pendingTaskIds) {
                 await waitForAvailableSlot();
                 scheduleTask(async () => {

package/package.json

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