doer-agent 0.7.6 → 0.7.7

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

@@ -1,12 +1,16 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+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()
@@ -91,10 +95,39 @@ function normalizeProxyRecord(value) {
         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) {
@@ -118,6 +151,33 @@ async function writeProxyRegistry(workspaceRoot, proxies) {
     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);
@@ -136,54 +196,132 @@ async function createProxy(workspaceRoot, request) {
         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 handleProxyFetch(workspaceRoot, request) {
+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 headers = normalizeHeaders(request.headers);
     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");
     }
-    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");
+    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;
     }
-    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"
+    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") {
@@ -192,10 +330,16 @@ async function executeProxyRpc(args) {
     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) {

package/package.json

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