agent-dir 0.4.0 → 0.4.1

package/dist/src/server.js

@@ -5,6 +5,11 @@ import { createMcpHandler } from "./mcp.js";
 import { TelemetryRecorder } from "./telemetry/recorder.js";
 import { deleteFile, listFiles, readFile, writeFile } from "./tools/files.js";
 const MAX_BODY_BYTES = 10 * 1024 * 1024;
+const REQUEST_BODY_TIMEOUT_MS = 30_000;
+const REQUEST_TIMEOUT_MS = 120_000;
+const HEADERS_TIMEOUT_MS = 30_000;
+const KEEP_ALIVE_TIMEOUT_MS = 5_000;
+const HEALTH_PATH = "/__health";
 export function startServer({ root, port, token, commandConfig = {}, telemetry = { level: "none" }, }) {
     const mcp = createMcpHandler(root, commandConfig, telemetry);
     const httpTelemetry = new TelemetryRecorder({
@@ -15,13 +20,20 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
     });
     const server = http.createServer(async (req, res) => {
         const startedAt = performance.now();
+        const requestController = new AbortController();
+        req.once("aborted", () => requestController.abort());
+        res.once("close", () => {
+            if (!res.writableFinished)
+                requestController.abort();
+        });
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
         let authenticated = false;
         try {
-            const body = await readBody(req);
+            const body = await readBody(req, requestController.signal);
             const requestInit = {
                 method: req.method ?? "GET",
                 headers: toFetchHeaders(req.headers),
+                signal: requestController.signal,
             };
             if (body.length)
                 requestInit.body = body;
@@ -39,6 +51,10 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                 recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 401, authenticated, startedAt);
                 return;
             }
+            if (url.pathname === HEALTH_PATH && req.method === "HEAD") {
+                sendText(res, 200, "ok\n");
+                return;
+            }
             if (url.pathname === "/mcp") {
                 if (req.method !== "POST") {
                     res.setHeader("allow", "POST");
@@ -117,7 +133,12 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
             if (req.method === "DELETE") {
                 await deleteFile(root, relative);
                 sendText(res, 200, "File deleted successfully\n");
-                logRequest({ method: req.method, path: url.pathname, status: 200, detail: "REST DELETE" });
+                logRequest({
+                    method: req.method,
+                    path: url.pathname,
+                    status: 200,
+                    detail: "REST DELETE",
+                });
                 recordHttpTelemetry(httpTelemetry, req.method, url.pathname, 200, authenticated, startedAt);
                 return;
             }
@@ -131,8 +152,16 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
             recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 404, authenticated, startedAt);
         }
         catch (error) {
+            if (requestController.signal.aborted || res.destroyed)
+                return;
             const code = error.code;
-            const status = code === "ENOENT" ? 404 : code === "PAYLOAD_TOO_LARGE" ? 413 : 500;
+            const status = code === "ENOENT"
+                ? 404
+                : code === "PAYLOAD_TOO_LARGE"
+                    ? 413
+                    : code === "REQUEST_TIMEOUT"
+                        ? 408
+                        : 500;
             sendText(res, status, `${error instanceof Error ? error.message : String(error)}\n`);
             logRequest({
                 method: req.method ?? "UNKNOWN",
@@ -143,6 +172,9 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
             recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, status, authenticated, startedAt);
         }
     });
+    server.requestTimeout = REQUEST_TIMEOUT_MS;
+    server.headersTimeout = HEADERS_TIMEOUT_MS;
+    server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
     return new Promise((resolve, reject) => {
         server.once("error", reject);
         server.listen(port, "127.0.0.1", () => resolve({
@@ -531,12 +563,39 @@ function toFetchHeaders(headers) {
     }
     return result;
 }
-function readBody(req) {
+function readBody(req, signal) {
     return new Promise((resolve, reject) => {
         const chunks = [];
         let size = 0;
         let tooLarge = false;
-        req.on("data", (chunk) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            const error = new Error(`Request body timed out after ${REQUEST_BODY_TIMEOUT_MS / 1000}s.`);
+            error.code = "REQUEST_TIMEOUT";
+            finish(error);
+        }, REQUEST_BODY_TIMEOUT_MS);
+        const cleanup = () => {
+            clearTimeout(timer);
+            req.removeListener("aborted", onAborted);
+            req.removeListener("error", onError);
+            req.removeListener("data", onData);
+            req.removeListener("end", onEnd);
+            signal.removeEventListener("abort", onSignalAbort);
+        };
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error)
+                reject(error);
+            else
+                resolve(value ?? Buffer.alloc(0));
+        };
+        const onAborted = () => finish(new Error("Request aborted by the client."));
+        const onError = (error) => finish(error);
+        const onSignalAbort = () => finish(new Error("Request aborted by the client."));
+        const onData = (chunk) => {
             if (tooLarge)
                 return;
             const buffer = Buffer.from(chunk);
@@ -546,17 +605,25 @@ function readBody(req) {
                 return;
             }
             chunks.push(buffer);
-        });
-        req.on("end", () => {
+        };
+        const onEnd = () => {
             if (tooLarge) {
                 const error = new Error(`Request body exceeds the ${MAX_BODY_BYTES / 1024 / 1024} MiB limit.`);
                 error.code = "PAYLOAD_TOO_LARGE";
-                reject(error);
+                finish(error);
                 return;
             }
-            resolve(Buffer.concat(chunks));
-        });
-        req.on("error", reject);
+            finish(undefined, Buffer.concat(chunks));
+        };
+        if (signal.aborted) {
+            onSignalAbort();
+            return;
+        }
+        req.once("aborted", onAborted);
+        req.once("error", onError);
+        signal.addEventListener("abort", onSignalAbort, { once: true });
+        req.on("data", onData);
+        req.on("end", onEnd);
     });
 }
 function sendText(res, status, text, contentType = "text/plain; charset=utf-8") {

package/dist/src/telemetry/privacy.js

@@ -57,6 +57,7 @@ export function sanitizeAnonymousEvent(event) {
         return {
             event: "tunnel",
             state: event.state,
+            ...(event.healthState === undefined ? {} : { healthState: event.healthState }),
             ...(event.attempt === undefined ? {} : { attempt: boundedInteger(event.attempt) }),
             ...(event.attempts === undefined ? {} : { attempts: boundedInteger(event.attempts) }),
             ...(event.durationMs === undefined ? {} : { durationMs: boundedNumber(event.durationMs) }),

package/dist/src/telemetry/types.d.ts

@@ -46,7 +46,8 @@ export interface TelemetryCommandEvent {
 }
 export interface TelemetryTunnelEvent {
     event: "tunnel";
-    state: "online" | "disconnected" | "reconnecting" | "reconnected" | "failed";
+    state: "online" | "disconnected" | "reconnecting" | "reconnected" | "failed" | "health";
+    healthState?: "healthy" | "degraded" | "recovered";
     attempt?: number;
     attempts?: number;
     durationMs?: number;

package/dist/src/tunnel.js

@@ -6,6 +6,7 @@ const HEALTH_TIMEOUT_MS = 5_000;
 const HEALTH_FAILURE_THRESHOLD = 2;
 const RECONNECT_DELAY_MS = 1_000;
 const MAX_RECONNECT_ATTEMPTS = 5;
+const HEALTH_PATH = "/__health";
 const ANSI_ESCAPE = new RegExp(String.fromCharCode(0x1b) + String.raw `\[[0-?]*[ -/]*[@-~]`, "g");
 function cleanOutput(value) {
     return value.toString().replace(ANSI_ESCAPE, "");
@@ -55,6 +56,7 @@ export function startTunnel(options) {
         let healthTimer;
         let stopped = false;
         let healthFailures = 0;
+        let healthState = "healthy";
         const record = (event) => {
             if (!telemetry)
                 return;
@@ -75,6 +77,8 @@ export function startTunnel(options) {
                 });
             else if (event.type === "reconnected")
                 telemetry.record({ event: "tunnel", state: "reconnected", attempt: event.attempt });
+            else if (event.type === "health")
+                telemetry.record({ event: "tunnel", state: "health", healthState: event.state });
             else
                 telemetry.record({
                     event: "tunnel",
@@ -106,9 +110,16 @@ export function startTunnel(options) {
                 writeLine(`    MCP endpoint : ${event.url}/mcp`);
                 writeLine();
             }
+            else if (event.type === "health") {
+                if (event.state === "degraded")
+                    writeLine("  ⚠ TUNNEL HEALTH DEGRADED");
+                else if (event.state === "recovered")
+                    writeLine("  ✓ TUNNEL HEALTH RECOVERED");
+            }
             else {
-                writeLine(`  ✖ TUNNEL OFFLINE  ${event.reason}`);
-                writeLine(`    Reconnect attempts exhausted: ${event.attempts}`);
+                writeLine(`  ⚠ TUNNEL RECOVERY CYCLE EXHAUSTED  ${event.reason}`);
+                writeLine(`    Attempts completed : ${event.attempts}`);
+                writeLine("    Starting a fresh reconnect cycle.");
             }
         };
         const cleanupTimers = () => {
@@ -135,17 +146,25 @@ export function startTunnel(options) {
                 if (!url || stopped || reconnecting)
                     return;
                 try {
-                    const response = await fetch(url, {
+                    const response = await fetch(new URL(HEALTH_PATH, url), {
                         method: "HEAD",
                         ...(options.token ? { headers: { authorization: `Bearer ${options.token}` } } : {}),
                         signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
                     });
+                    if (!response.ok)
+                        throw new Error(`Health check returned HTTP ${response.status}.`);
                     healthFailures = 0;
-                    if (!response)
-                        return;
+                    if (healthState === "degraded") {
+                        healthState = "healthy";
+                        emit({ type: "health", state: "recovered" });
+                    }
                 }
                 catch {
                     healthFailures += 1;
+                    if (healthFailures === 1 && healthState === "healthy") {
+                        healthState = "degraded";
+                        emit({ type: "health", state: "degraded" });
+                    }
                     if (healthFailures >= HEALTH_FAILURE_THRESHOLD) {
                         healthFailures = 0;
                         handleDisconnect("Public tunnel health check failed.");
@@ -157,6 +176,7 @@ export function startTunnel(options) {
         const spawnTunnel = (attempt) => {
             if (stopped)
                 return;
+            reconnecting = false;
             const args = ["http", String(options.port)];
             if (!options.random && options.subdomain)
                 args.push("--subdomain", options.subdomain);
@@ -257,10 +277,12 @@ export function startTunnel(options) {
             if (stopped || reconnecting)
                 return;
             reconnecting = true;
+            if (child && !child.killed)
+                child.kill("SIGTERM");
             emit({ type: "disconnected", reason });
             if (attempts >= MAX_RECONNECT_ATTEMPTS) {
                 emit({ type: "failed", reason, attempts });
-                return;
+                attempts = 0;
             }
             attempts += 1;
             emit({ type: "reconnecting", attempt: attempts, reason });

package/dist/src/types.d.ts

@@ -72,4 +72,7 @@ export type TunnelEvent = {
     type: "failed";
     reason: string;
     attempts: number;
+} | {
+    type: "health";
+    state: "healthy" | "degraded" | "recovered";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dir",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Expose a local project to an AI agent through authenticated MCP, filesystem tools, and allowlisted development commands",
   "repository": {
     "type": "git",