doer-agent 0.7.4 → 0.7.6

package/dist/agent-codex-app-rpc.js

@@ -62,6 +62,9 @@ function normalizeCodexAppRpcRequest(args) {
     const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
     const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
     const method = typeof args.request.method === "string" ? args.request.method.trim() : "";
+    const timeoutMs = typeof args.request.timeoutMs === "number" && Number.isFinite(args.request.timeoutMs)
+        ? Math.min(180_000, Math.max(1_000, Math.trunc(args.request.timeoutMs)))
+        : undefined;
     if (!requestId || !requestAgentId || requestAgentId !== args.agentId || actionRaw !== "request" || !method) {
         throw new Error("invalid codex app rpc request");
     }
@@ -70,6 +73,7 @@ function normalizeCodexAppRpcRequest(args) {
         action: "request",
         method,
         params: args.request.params,
+        timeoutMs,
     };
 }
 async function handleCodexAppRpcMessage(args) {
@@ -78,7 +82,7 @@ async function handleCodexAppRpcMessage(args) {
         const payload = JSON.parse(codexAppRpcCodec.decode(args.msg.data));
         const request = normalizeCodexAppRpcRequest({ request: payload, agentId: args.agentId });
         requestId = request.requestId;
-        const result = applyCodexAppRpcOmitRules(request.method, await args.manager.request(request.method, request.params));
+        const result = applyCodexAppRpcOmitRules(request.method, await args.manager.request(request.method, request.params, request.timeoutMs));
         args.msg.respond(codexAppRpcCodec.encode(JSON.stringify({
             requestId,
             ok: true,

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/dist/codex-app-server-client.js

@@ -22,9 +22,9 @@ export class CodexAppServerClient {
     constructor(options) {
         this.options = options;
     }
-    async request(method, params) {
+    async request(method, params, timeoutMs) {
         await this.start();
-        return await this.requestStarted(method, params);
+        return await this.requestStarted(method, params, timeoutMs);
     }
     async notify(method, params) {
         await this.start();
@@ -92,14 +92,14 @@ export class CodexAppServerClient {
         });
         await this.notify("initialized");
     }
-    async requestStarted(method, params) {
+    async requestStarted(method, params, timeoutMsOverride) {
         const child = this.child;
         if (!child || child.killed) {
             throw new Error("Codex app-server is not running");
         }
         const id = this.nextRequestId++;
         const payload = params === undefined ? { id, method } : { id, method, params };
-        const timeoutMs = this.options.requestTimeoutMs ?? 30_000;
+        const timeoutMs = timeoutMsOverride ?? this.options.requestTimeoutMs ?? 30_000;
         return await new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);

package/dist/codex-app-server-manager.js

@@ -117,9 +117,9 @@ export function createCodexAppServerManager(args) {
         }
     };
     return {
-        async request(method, params) {
+        async request(method, params, timeoutMs) {
             const activeClient = await getClient();
-            return await activeClient.request(method, params);
+            return await activeClient.request(method, params, timeoutMs);
         },
         async restart(reason) {
             generation += 1;

package/package.json

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