agent-dir 0.4.1 → 0.5.0

package/dist/src/tools/commands.d.ts

@@ -1,3 +1,10 @@
+import { type ChildProcess } from "node:child_process";
+export declare function appendBoundedOutput(current: string, chunk: Buffer | string): string;
+export declare function commandEnvironment(): NodeJS.ProcessEnv;
+export declare function terminateProcessTree(child: ChildProcess): void;
+export declare function processTreeSpawnOptions(): {
+    detached: boolean;
+};
 export interface CommandResult {
     command: string;
     exitCode: number;

package/dist/src/tools/commands.js

@@ -1,5 +1,58 @@
 import { spawn } from "node:child_process";
 const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+const MAX_CAPTURE_BYTES = 512_000;
+const TRUNCATION_MARKER = "\n…[output truncated at 512 KB]";
+export function appendBoundedOutput(current, chunk) {
+    if (current.endsWith(TRUNCATION_MARKER) ||
+        Buffer.byteLength(current, "utf8") >= MAX_CAPTURE_BYTES)
+        return current;
+    const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const available = MAX_CAPTURE_BYTES - Buffer.byteLength(current, "utf8");
+    if (incoming.byteLength <= available)
+        return current + incoming.toString("utf8");
+    const markerBytes = Buffer.byteLength(TRUNCATION_MARKER, "utf8");
+    const payloadBytes = Math.max(0, available - markerBytes);
+    let payload = incoming.subarray(0, payloadBytes).toString("utf8");
+    while (Buffer.byteLength(payload, "utf8") > payloadBytes)
+        payload = payload.slice(0, -1);
+    return current + payload + TRUNCATION_MARKER;
+}
+export function commandEnvironment() {
+    return Object.fromEntries(Object.entries(process.env).filter(([key]) => !/(?:TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTHORIZATION|ACCESS[_-]?KEY)/i.test(key)));
+}
+const FORCE_KILL_DELAY_MS = 1_000;
+export function terminateProcessTree(child) {
+    const pid = child.pid;
+    if (!pid || child.killed || child.exitCode !== null)
+        return;
+    if (process.platform === "win32") {
+        const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        killer.on("error", () => child.kill("SIGKILL"));
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        child.kill("SIGTERM");
+    }
+    const forceTimer = setTimeout(() => {
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch {
+            child.kill("SIGKILL");
+        }
+    }, FORCE_KILL_DELAY_MS);
+    forceTimer.unref();
+    child.once("close", () => clearTimeout(forceTimer));
+}
+export function processTreeSpawnOptions() {
+    return { detached: process.platform !== "win32" };
+}
 export function isCommandBlacklisted(command, args = [], blacklistedCommands = []) {
     const invocation = [command, ...args];
     return blacklistedCommands.some((entry) => {
@@ -17,7 +70,12 @@ export function runCommand(root, command, args = [], allowedCommands = [], black
     if (!Array.isArray(args) || args.some((arg) => typeof arg !== "string"))
         throw new Error("Command arguments must be strings.");
     return new Promise((resolve, reject) => {
-        const child = spawn(command, args, { cwd: root, shell: false, env: process.env });
+        const child = spawn(command, args, {
+            cwd: root,
+            shell: false,
+            env: commandEnvironment(),
+            ...processTreeSpawnOptions(),
+        });
         let stdout = "";
         let stderr = "";
         let finished = false;
@@ -27,14 +85,14 @@ export function runCommand(root, command, args = [], allowedCommands = [], black
                 return;
             finished = true;
             clearTimeout(timer);
-            child.kill("SIGTERM");
+            terminateProcessTree(child);
             reject(new Error(`Command '${command}' was aborted.`));
         };
         timer = setTimeout(() => {
             if (finished)
                 return;
             finished = true;
-            child.kill("SIGTERM");
+            terminateProcessTree(child);
             signal?.removeEventListener("abort", abort);
             reject(new Error(`Command '${command}' timed out after ${timeoutMs}ms.`));
         }, timeoutMs);
@@ -44,10 +102,10 @@ export function runCommand(root, command, args = [], allowedCommands = [], black
         }
         signal?.addEventListener("abort", abort, { once: true });
         child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
+            stdout = appendBoundedOutput(stdout, chunk);
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
+            stderr = appendBoundedOutput(stderr, chunk);
         });
         child.on("error", (error) => {
             if (finished)

package/dist/src/tools/git.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { appendBoundedOutput, commandEnvironment, processTreeSpawnOptions, terminateProcessTree, } from "./commands.js";
 function validatePaths(paths) {
     if (!Array.isArray(paths) ||
         paths.length === 0 ||
@@ -8,7 +9,12 @@ function validatePaths(paths) {
 }
 function runGit(root, args, timeoutMs = 30000) {
     return new Promise((resolve, reject) => {
-        const child = spawn("git", args, { cwd: root, shell: false, env: process.env });
+        const child = spawn("git", args, {
+            cwd: root,
+            shell: false,
+            env: commandEnvironment(),
+            ...processTreeSpawnOptions(),
+        });
         let stdout = "";
         let stderr = "";
         let finished = false;
@@ -16,14 +22,14 @@ function runGit(root, args, timeoutMs = 30000) {
             if (finished)
                 return;
             finished = true;
-            child.kill("SIGTERM");
+            terminateProcessTree(child);
             reject(new Error(`git ${args.join(" ")} timed out after ${timeoutMs}ms.`));
         }, timeoutMs);
         child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
+            stdout = appendBoundedOutput(stdout, chunk);
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
+            stderr = appendBoundedOutput(stderr, chunk);
         });
         child.on("error", (error) => {
             if (finished)

package/dist/src/tools/npm.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { appendBoundedOutput, commandEnvironment, processTreeSpawnOptions, terminateProcessTree, } from "./commands.js";
 export function runNpm(root, script, timeoutMs = 120000, allowedScripts = [], signal) {
     if (!/^[A-Za-z0-9:_-]+$/.test(script))
         throw new Error("Invalid npm script name.");
@@ -21,7 +22,8 @@ export function runNpm(root, script, timeoutMs = 120000, allowedScripts = [], si
             const child = spawn(executable, ["run", script], {
                 cwd: root,
                 shell: false,
-                env: process.env,
+                env: commandEnvironment(),
+                ...processTreeSpawnOptions(),
             });
             let stdout = "";
             let stderr = "";
@@ -32,14 +34,14 @@ export function runNpm(root, script, timeoutMs = 120000, allowedScripts = [], si
                     return;
                 finished = true;
                 clearTimeout(timer);
-                child.kill("SIGTERM");
+                terminateProcessTree(child);
                 reject(new Error(`npm run ${script} was aborted.`));
             };
             timer = setTimeout(() => {
                 if (finished)
                     return;
                 finished = true;
-                child.kill("SIGTERM");
+                terminateProcessTree(child);
                 signal?.removeEventListener("abort", abort);
                 reject(new Error(`npm run ${script} timed out after ${timeoutMs}ms.`));
             }, timeoutMs);
@@ -49,10 +51,10 @@ export function runNpm(root, script, timeoutMs = 120000, allowedScripts = [], si
             }
             signal?.addEventListener("abort", abort, { once: true });
             child.stdout.on("data", (chunk) => {
-                stdout += chunk.toString();
+                stdout = appendBoundedOutput(stdout, chunk);
             });
             child.stderr.on("data", (chunk) => {
-                stderr += chunk.toString();
+                stderr = appendBoundedOutput(stderr, chunk);
             });
             child.on("error", (error) => {
                 if (!finished) {

package/dist/src/tunnel.js

@@ -14,8 +14,12 @@ function cleanOutput(value) {
 function writeLine(line = "") {
     process.stdout.write(`${line}\r\n`);
 }
-function publicUrl(subdomain) {
-    return `https://${subdomain}.wormhole.bar`;
+function publicUrl(options) {
+    if (options.provider === "cloudflared" && options.hostname)
+        return `https://${options.hostname}`;
+    if (options.subdomain)
+        return `https://${options.subdomain}.wormhole.bar`;
+    throw new Error("Tunnel URL cannot be determined from the configured options.");
 }
 function reasonCategory(reason) {
     if (/timeout/i.test(reason))
@@ -35,8 +39,8 @@ function failureFromLine(line) {
     return registration?.[1] ? `Wormhole registration failed: ${registration[1].trim()}` : undefined;
 }
 export function startTunnel(options) {
-    if (options.provider !== "wormhole")
-        return Promise.reject(new Error(`Unsupported tunnel provider: ${options.provider}`));
+    if (options.provider === "cloudflared" && !options.hostname)
+        return Promise.reject(new Error("Cloudflared requires a hostname routed to a named Cloudflare Tunnel."));
     return new Promise((resolve, reject) => {
         const telemetry = options.telemetry && options.telemetry.level !== "none"
             ? new TelemetryRecorder({
@@ -146,12 +150,13 @@ export function startTunnel(options) {
                 if (!url || stopped || reconnecting)
                     return;
                 try {
+                    // A 401 is expected: it proves the public tunnel reaches the authenticated server.
+                    // Never send the Agent Dir bearer token to the public hostname.
                     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)
+                    if (!response.ok && response.status !== 401)
                         throw new Error(`Health check returned HTTP ${response.status}.`);
                     healthFailures = 0;
                     if (healthState === "degraded") {
@@ -167,7 +172,7 @@ export function startTunnel(options) {
                     }
                     if (healthFailures >= HEALTH_FAILURE_THRESHOLD) {
                         healthFailures = 0;
-                        handleDisconnect("Public tunnel health check failed.");
+                        handleDisconnect("Tunnel health check failed.");
                     }
                 }
             }, HEALTH_INTERVAL_MS);
@@ -177,10 +182,16 @@ export function startTunnel(options) {
             if (stopped)
                 return;
             reconnecting = false;
-            const args = ["http", String(options.port)];
-            if (!options.random && options.subdomain)
+            const args = options.provider === "wormhole" ? ["http", String(options.port)] : ["tunnel", "run"];
+            if (options.provider === "wormhole" && !options.random && options.subdomain)
                 args.push("--subdomain", options.subdomain);
-            child = spawn("wormhole", args, { stdio: ["ignore", "pipe", "pipe"] });
+            const executable = options.provider === "wormhole" ? "wormhole" : "cloudflared";
+            child = spawn(executable, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+                env: options.provider === "cloudflared" && options.cloudflaredToken
+                    ? { ...process.env, TUNNEL_TOKEN: options.cloudflaredToken }
+                    : process.env,
+            });
             let buffer = "";
             let connected = false;
             const cleanupAttempt = () => {
@@ -220,7 +231,7 @@ export function startTunnel(options) {
                     if (!resolved) {
                         if (!child) {
                             stop();
-                            reject(new Error("Wormhole connected without a child process."));
+                            reject(new Error(`${options.provider} connected without a child process.`));
                             return;
                         }
                         resolved = true;
@@ -245,10 +256,16 @@ export function startTunnel(options) {
                     return;
                 }
                 const explicit = line.match(/https:\/\/[^\s"'<>]+/)?.[0]?.replace(/[),.;]+$/, "");
-                if (explicit)
+                if (options.provider === "wormhole" && explicit)
                     connectedAt(explicit);
-                else if (/Status\s+.*connected/i.test(line) && options.subdomain)
-                    connectedAt(publicUrl(options.subdomain));
+                else if (options.provider === "wormhole" &&
+                    /Status\s+.*connected/i.test(line) &&
+                    options.subdomain)
+                    connectedAt(publicUrl(options));
+                else if (options.provider === "cloudflared" &&
+                    /registered tunnel connection|connection .* registered/i.test(line) &&
+                    options.hostname)
+                    connectedAt(publicUrl(options));
             };
             const onData = (chunk) => {
                 buffer += cleanOutput(chunk);
@@ -257,12 +274,12 @@ export function startTunnel(options) {
                 for (const line of lines)
                     processLine(line);
             };
-            const onError = (error) => disconnect(`Wormhole error: ${error.message}`);
+            const onError = (error) => disconnect(`${executable} error: ${error.message}`);
             const onExit = (code, signal) => {
                 const detail = signal ? `signal ${signal}` : `code ${code}`;
                 disconnect(startup
-                    ? `Wormhole exited before the tunnel was established (${detail}).`
-                    : `Wormhole process exited (${detail}).`);
+                    ? `${executable} exited before the tunnel was established (${detail}).`
+                    : `${executable} process exited (${detail}).`);
             };
             child.stdout?.on("data", onData);
             child.stderr?.on("data", onData);
@@ -270,7 +287,7 @@ export function startTunnel(options) {
             child.once("exit", onExit);
             timer = setTimeout(() => {
                 if (!connected)
-                    disconnect(`Timed out waiting for Wormhole to establish the tunnel after ${STARTUP_TIMEOUT_MS / 1000}s.`);
+                    disconnect(`Timed out waiting for ${executable} to establish the tunnel after ${STARTUP_TIMEOUT_MS / 1000}s.`);
             }, STARTUP_TIMEOUT_MS);
         };
         const handleDisconnect = (reason) => {

package/dist/src/types.d.ts

@@ -6,8 +6,20 @@ export interface NpmConfig {
 export interface Profile {
     directory: string;
     port: number;
-    tunnel: "none" | "wormhole";
+    tunnel: "none" | "wormhole" | "cloudflared";
+    defaultTunnel?: "none" | "wormhole" | "cloudflared";
+    tunnels?: {
+        wormhole?: {
+            subdomain?: string;
+            random?: boolean;
+        };
+        cloudflared?: {
+            hostname: string;
+            token?: string;
+        };
+    };
     subdomain?: string;
+    hostname?: string;
     token?: string;
     npm?: NpmConfig;
     commands?: string[];
@@ -40,9 +52,11 @@ export interface RequestLog {
     tool?: string;
 }
 export interface TunnelOptions {
-    provider: "wormhole";
+    provider: "wormhole" | "cloudflared";
     port: number;
+    cloudflaredToken?: string;
     subdomain?: string;
+    hostname?: string;
     random?: boolean;
     token?: string;
     telemetry?: TelemetryConfig;

package/package.json

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