doer-agent 0.7.5 → 0.7.6

package/dist/agent-fs-rpc.js

@@ -2,7 +2,7 @@ import path from "node:path";
 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";
+import { extract as extractTar } from "tar";
 import { validateImageBytes } from "./agent-runtime-utils.js";
 const fsRpcCodec = StringCodec();
 function normalizeFsRpcPath(workspaceRoot, rawPath) {
@@ -11,13 +11,10 @@ function normalizeFsRpcPath(workspaceRoot, rawPath) {
     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)) {
+    if (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 };
@@ -30,7 +27,6 @@ function parseFsRpcAction(value) {
         value === "write_text" ||
         value === "download_file" ||
         value === "delete_path" ||
-        value === "archive_dir" ||
         value === "extract_archive") {
         return value;
     }
@@ -92,18 +88,6 @@ function inferMimeType(filePath) {
 function sha256Hex(bytes) {
     return crypto.createHash("sha256").update(bytes).digest("hex");
 }
-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);
     const { abs, formatPath } = normalizeFsRpcPath(args.workspaceRoot, args.request.path);
@@ -146,37 +130,6 @@ 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(args.workspaceRoot, rawArchivePath);
-        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");
-        }
-        await mkdir(path.dirname(archiveTarget.abs), { recursive: true });
-        const archiveBytes = await createTarGzipBuffer(abs, ["."]);
-        await writeFile(archiveTarget.abs, archiveBytes);
-        const archiveStat = await stat(archiveTarget.abs);
-        return {
-            ok: true,
-            action,
-            path: formatPath(abs),
-            archivePath: archiveTarget.formatPath(archiveTarget.abs),
-            size: archiveStat.size,
-        };
-    }
     if (action === "upload_file") {
         const entry = await stat(abs);
         if (!entry.isFile()) {

package/dist/agent-http-proxy-rpc.js

@@ -0,0 +1,231 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { StringCodec } from "nats";
+const proxyRpcCodec = StringCodec();
+const PROXY_ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,30}[a-z0-9]$/;
+const MAX_PROXY_BODY_BYTES = 5 * 1024 * 1024;
+function getProxyRegistryPath(workspaceRoot) {
+    return path.join(workspaceRoot, ".doer-agent", "http-proxies.json");
+}
+function slugify(value) {
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-")
+        .slice(0, 32);
+    return PROXY_ID_PATTERN.test(slug) ? slug : `p${Date.now().toString(36)}`;
+}
+function normalizeProxyId(value) {
+    const id = typeof value === "string" ? value.trim().toLowerCase() : "";
+    if (!PROXY_ID_PATTERN.test(id)) {
+        throw new Error("invalid proxyId");
+    }
+    return id;
+}
+function normalizeName(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const name = value.trim();
+    return name ? name.slice(0, 120) : null;
+}
+function normalizeHost(value) {
+    const host = typeof value === "string" && value.trim() ? value.trim() : "127.0.0.1";
+    if (host !== "127.0.0.1" && host !== "localhost") {
+        throw new Error("proxy host must be localhost or 127.0.0.1");
+    }
+    return host;
+}
+function normalizePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("port must be between 1 and 65535");
+    }
+    return port;
+}
+function normalizeMethod(value) {
+    const method = typeof value === "string" ? value.trim().toUpperCase() : "GET";
+    if (!/^[A-Z]+$/.test(method)) {
+        throw new Error("invalid method");
+    }
+    return method;
+}
+function normalizePath(value) {
+    const raw = typeof value === "string" && value ? value : "/";
+    return raw.startsWith("/") ? raw : `/${raw}`;
+}
+function normalizeHeaders(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw !== "string") {
+            continue;
+        }
+        const normalizedKey = key.trim().toLowerCase();
+        if (!normalizedKey || normalizedKey === "host" || normalizedKey === "connection") {
+            continue;
+        }
+        out[normalizedKey] = raw;
+    }
+    return out;
+}
+function normalizeProxyRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const id = typeof row.id === "string" ? row.id.trim().toLowerCase() : "";
+    const host = normalizeHost(row.host);
+    const port = Number(row.port);
+    const createdAt = typeof row.createdAt === "string" ? row.createdAt : new Date().toISOString();
+    const updatedAt = typeof row.updatedAt === "string" ? row.updatedAt : createdAt;
+    if (!PROXY_ID_PATTERN.test(id) || !Number.isInteger(port) || port < 1 || port > 65535) {
+        return null;
+    }
+    return {
+        id,
+        name: normalizeName(row.name),
+        host,
+        port,
+        createdAt,
+        updatedAt,
+    };
+}
+async function readProxyRegistry(workspaceRoot) {
+    const raw = await readFile(getProxyRegistryPath(workspaceRoot), "utf8").catch(() => "");
+    if (!raw) {
+        return [];
+    }
+    const parsed = JSON.parse(raw);
+    const rows = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.proxies) ? parsed.proxies : [];
+    return rows
+        .map((row) => {
+        try {
+            return normalizeProxyRecord(row);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row));
+}
+async function writeProxyRegistry(workspaceRoot, proxies) {
+    const registryPath = getProxyRegistryPath(workspaceRoot);
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(registryPath, `${JSON.stringify({ proxies }, null, 2)}\n`, "utf8");
+}
+async function createProxy(workspaceRoot, request) {
+    const proxies = await readProxyRegistry(workspaceRoot);
+    const name = normalizeName(request.name);
+    const port = normalizePort(request.port);
+    const host = normalizeHost(request.host);
+    const requestedId = typeof request.proxyId === "string" && request.proxyId.trim()
+        ? normalizeProxyId(request.proxyId)
+        : slugify(name || `p-${port}`);
+    let id = requestedId;
+    for (let index = 2; proxies.some((proxy) => proxy.id === id); index += 1) {
+        id = `${requestedId.slice(0, 26)}-${index}`;
+    }
+    const now = new Date().toISOString();
+    const proxy = {
+        id,
+        name,
+        host,
+        port,
+        createdAt: now,
+        updatedAt: now,
+    };
+    await writeProxyRegistry(workspaceRoot, [...proxies, proxy].sort((a, b) => b.createdAt.localeCompare(a.createdAt)));
+    return proxy;
+}
+async function deleteProxy(workspaceRoot, proxyId) {
+    const proxies = await readProxyRegistry(workspaceRoot);
+    await writeProxyRegistry(workspaceRoot, proxies.filter((proxy) => proxy.id !== proxyId));
+}
+async function handleProxyFetch(workspaceRoot, request) {
+    const proxyId = normalizeProxyId(request.proxyId);
+    const proxy = (await readProxyRegistry(workspaceRoot)).find((item) => item.id === proxyId);
+    if (!proxy) {
+        throw new Error("proxy not found");
+    }
+    const method = normalizeMethod(request.method);
+    const requestPath = normalizePath(request.path);
+    const headers = normalizeHeaders(request.headers);
+    const bodyBase64 = typeof request.bodyBase64 === "string" ? request.bodyBase64 : "";
+    const body = bodyBase64 ? Buffer.from(bodyBase64, "base64") : undefined;
+    if ((body?.byteLength ?? 0) > MAX_PROXY_BODY_BYTES) {
+        throw new Error("proxy request body too large");
+    }
+    const url = new URL(requestPath, `http://${proxy.host}:${proxy.port}`);
+    const response = await fetch(url, {
+        method,
+        headers,
+        body: method === "GET" || method === "HEAD" ? undefined : body,
+        redirect: "manual",
+    });
+    const responseBuffer = Buffer.from(await response.arrayBuffer());
+    if (responseBuffer.byteLength > MAX_PROXY_BODY_BYTES) {
+        throw new Error("proxy response body too large");
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+    });
+    return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        bodyBase64: responseBuffer.toString("base64"),
+    };
+}
+async function executeProxyRpc(args) {
+    const action = args.request.action === "create" || args.request.action === "delete" || args.request.action === "handle"
+        ? args.request.action
+        : "list";
+    if (action === "list") {
+        return { ok: true, action, proxies: await readProxyRegistry(args.workspaceRoot) };
+    }
+    if (action === "create") {
+        return { ok: true, action, proxy: await createProxy(args.workspaceRoot, args.request) };
+    }
+    if (action === "delete") {
+        await deleteProxy(args.workspaceRoot, normalizeProxyId(args.request.proxyId));
+        return { ok: true, action };
+    }
+    return { ok: true, action, response: await handleProxyFetch(args.workspaceRoot, args.request) };
+}
+export async function handleHttpProxyRpcMessage(args) {
+    let requestId = "unknown";
+    try {
+        const request = JSON.parse(proxyRpcCodec.decode(args.msg.data));
+        requestId = typeof request.requestId === "string" ? request.requestId : "unknown";
+        const payload = await executeProxyRpc({ workspaceRoot: args.workspaceRoot, request });
+        args.msg.respond(proxyRpcCodec.encode(JSON.stringify({ requestId, ...payload })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.onError?.(`http proxy rpc failed requestId=${requestId} error=${message}`);
+        args.msg.respond(proxyRpcCodec.encode(JSON.stringify({ requestId, ok: false, error: message })));
+    }
+}
+export function subscribeToHttpProxyRpc(args) {
+    args.nc.subscribe(args.subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                args.onError(`http proxy rpc subscription error: ${message}`);
+                return;
+            }
+            void handleHttpProxyRpcMessage({
+                msg,
+                workspaceRoot: args.workspaceRoot,
+                onError: args.onError,
+            });
+        },
+    });
+    args.onInfo(`http proxy rpc subscribed subject=${args.subject}`);
+}

package/dist/agent-runtime-utils.js

@@ -25,6 +25,9 @@ export function buildAgentFsRpcSubject(userId, agentId) {
 export function buildAgentDaemonRpcSubject(userId, agentId) {
     return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+export function buildAgentHttpProxyRpcSubject(userId, agentId) {
+    return `doer.agent.http.proxy.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 export function buildAgentMaintenanceRpcSubject(userId, agentId) {
     return `doer.agent.maintenance.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }

package/dist/agent.js

@@ -13,8 +13,9 @@ import { connectBootstrapWithRetry } from "./agent-jetstream.js";
 import { runConnectedAgentSession } from "./agent-session-loop.js";
 import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
 import { subscribeToMaintenanceRpc } from "./agent-maintenance-rpc.js";
+import { subscribeToHttpProxyRpc } from "./agent-http-proxy-rpc.js";
 import { sendSignalToTaskProcess } from "./agent-task-execution.js";
-import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -306,6 +307,13 @@ async function main() {
                     onInfo: writeAgentInfo,
                     onError: writeAgentError,
                 });
+                subscribeToHttpProxyRpc({
+                    nc: jetstream.nc,
+                    subject: buildAgentHttpProxyRpcSubject(userId, initialAgentId),
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                });
             },
             onInfraError: writeAgentInfraError,
             sleep,

package/package.json

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