doer-agent 0.7.5 → 0.7.7

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,375 @@
+import { appendFile, readFile, writeFile, mkdir, unlink } 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;
+const MAX_PROXY_LOGS = 100;
+function getProxyRegistryPath(workspaceRoot) {
+    return path.join(workspaceRoot, ".doer-agent", "http-proxies.json");
+}
+function getProxyLogsPath(workspaceRoot, proxyId) {
+    return path.join(workspaceRoot, ".doer-agent", "http-proxy-logs", `${proxyId}.jsonl`);
+}
+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,
+        enabled: row.enabled !== false,
+        createdAt,
+        updatedAt,
+    };
+}
+function normalizeProxyLogRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const id = typeof row.id === "string" && row.id.trim() ? row.id.trim() : "";
+    const at = typeof row.at === "string" && row.at.trim() ? row.at.trim() : "";
+    const method = typeof row.method === "string" && row.method.trim() ? row.method.trim().toUpperCase() : "";
+    const requestPath = typeof row.path === "string" && row.path.trim() ? row.path.trim() : "/";
+    const status = typeof row.status === "number" && Number.isInteger(row.status) ? row.status : null;
+    const durationMs = typeof row.durationMs === "number" && Number.isFinite(row.durationMs) ? Math.max(0, Math.round(row.durationMs)) : 0;
+    const requestBytes = typeof row.requestBytes === "number" && Number.isFinite(row.requestBytes) ? Math.max(0, Math.round(row.requestBytes)) : 0;
+    const responseBytes = typeof row.responseBytes === "number" && Number.isFinite(row.responseBytes) ? Math.max(0, Math.round(row.responseBytes)) : 0;
+    if (!id || !at || !method) {
+        return null;
+    }
+    return {
+        id,
+        at,
+        method,
+        path: requestPath,
+        status,
+        durationMs,
+        requestBytes,
+        responseBytes,
+        error: typeof row.error === "string" && row.error.trim() ? row.error.trim().slice(0, 500) : null,
+    };
+}
+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");
+}
+function normalizeLimit(value, fallback) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        return fallback;
+    }
+    return Math.max(1, Math.min(Math.floor(numeric), 1000));
+}
+async function readProxyLogs(workspaceRoot, proxyId, limit) {
+    const raw = await readFile(getProxyLogsPath(workspaceRoot, proxyId), "utf8").catch(() => "");
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(-limit)
+        .map((line) => {
+        try {
+            return normalizeProxyLogRecord(JSON.parse(line));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((log) => Boolean(log));
+}
+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,
+        enabled: request.enabled !== false,
+        createdAt: now,
+        updatedAt: now,
+    };
+    await writeProxyRegistry(workspaceRoot, [...proxies, proxy].sort((a, b) => b.createdAt.localeCompare(a.createdAt)));
+    return proxy;
+}
+async function updateProxy(workspaceRoot, request) {
+    const proxyId = normalizeProxyId(request.proxyId);
+    const proxies = await readProxyRegistry(workspaceRoot);
+    const proxy = proxies.find((item) => item.id === proxyId);
+    if (!proxy) {
+        throw new Error("proxy not found");
+    }
+    const updated = {
+        ...proxy,
+        name: request.name === undefined ? proxy.name : normalizeName(request.name),
+        host: request.host === undefined ? proxy.host : normalizeHost(request.host),
+        port: request.port === undefined ? proxy.port : normalizePort(request.port),
+        enabled: request.enabled === undefined ? proxy.enabled : request.enabled !== false,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeProxyRegistry(workspaceRoot, proxies.map((item) => (item.id === proxyId ? updated : item)));
+    return updated;
+}
+async function deleteProxy(workspaceRoot, proxyId) {
+    const proxies = await readProxyRegistry(workspaceRoot);
+    await writeProxyRegistry(workspaceRoot, proxies.filter((proxy) => proxy.id !== proxyId));
+    await unlink(getProxyLogsPath(workspaceRoot, proxyId)).catch(() => undefined);
+}
+async function appendProxyLog(workspaceRoot, proxyId, log) {
+    const entry = {
+        id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+        at: new Date().toISOString(),
+        ...log,
+    };
+    const logsPath = getProxyLogsPath(workspaceRoot, proxyId);
+    await mkdir(path.dirname(logsPath), { recursive: true });
+    await appendFile(logsPath, `${JSON.stringify(entry)}\n`, "utf8");
+}
+async function readProxyLogsForRequest(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");
+    }
+    return {
+        proxy,
+        events: await readProxyLogs(workspaceRoot, proxyId, normalizeLimit(request.limit, MAX_PROXY_LOGS)),
+    };
+}
+async function handleProxyFetch(workspaceRoot, request) {
+    const proxyId = normalizeProxyId(request.proxyId);
+    const proxy = (await readProxyRegistry(workspaceRoot)).find((item) => item.id === proxyId);
+    const startedAt = Date.now();
+    const method = normalizeMethod(request.method);
+    const requestPath = normalizePath(request.path);
+    const bodyBase64 = typeof request.bodyBase64 === "string" ? request.bodyBase64 : "";
+    const body = bodyBase64 ? Buffer.from(bodyBase64, "base64") : undefined;
+    const requestBytes = body?.byteLength ?? 0;
+    let status = null;
+    let responseBytes = 0;
+    let errorMessage = null;
+    const finishLog = async () => {
+        await appendProxyLog(workspaceRoot, proxyId, {
+            method,
+            path: requestPath,
+            status,
+            durationMs: Date.now() - startedAt,
+            requestBytes,
+            responseBytes,
+            error: errorMessage,
+        }).catch(() => undefined);
+    };
+    if (!proxy) {
+        throw new Error("proxy not found");
+    }
+    if (!proxy.enabled) {
+        errorMessage = "proxy disabled";
+        await finishLog();
+        throw new Error("proxy disabled");
+    }
+    const headers = normalizeHeaders(request.headers);
+    if ((body?.byteLength ?? 0) > MAX_PROXY_BODY_BYTES) {
+        errorMessage = "proxy request body too large";
+        await finishLog();
+        throw new Error("proxy request body too large");
+    }
+    try {
+        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",
+        });
+        status = response.status;
+        const responseBuffer = Buffer.from(await response.arrayBuffer());
+        responseBytes = responseBuffer.byteLength;
+        if (responseBuffer.byteLength > MAX_PROXY_BODY_BYTES) {
+            errorMessage = "proxy response body too large";
+            await finishLog();
+            throw new Error("proxy response body too large");
+        }
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+        await finishLog();
+        return {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            bodyBase64: responseBuffer.toString("base64"),
+        };
+    }
+    catch (error) {
+        if (!errorMessage) {
+            errorMessage = error instanceof Error ? error.message : String(error);
+            await finishLog();
+        }
+        throw error;
+    }
+}
+async function executeProxyRpc(args) {
+    const action = args.request.action === "create" || args.request.action === "update" || args.request.action === "delete" || args.request.action === "logs" || 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 === "update") {
+        return { ok: true, action, proxy: await updateProxy(args.workspaceRoot, args.request) };
+    }
+    if (action === "delete") {
+        await deleteProxy(args.workspaceRoot, normalizeProxyId(args.request.proxyId));
+        return { ok: true, action };
+    }
+    if (action === "logs") {
+        return { ok: true, action, ...await readProxyLogsForRequest(args.workspaceRoot, args.request) };
+    }
+    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.7",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",