@townco/agent 0.1.19 → 0.1.21

package/dist/acp-server/http.js

@@ -1,188 +1,427 @@
 import { createHash } from "node:crypto";
+import { gzipSync } from "node:zlib";
 import * as acp from "@agentclientprotocol/sdk";
 import { PGlite } from "@electric-sql/pglite";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
 import { makeRunnerFromDefinition } from "../runner";
+import { createLogger } from "../utils/logger.js";
 import { AgentAcpAdapter } from "./adapter";
-
+const logger = createLogger("agent");
+/**
+ * Compress a payload using gzip if it's too large for PostgreSQL NOTIFY
+ * Returns an object with the payload and metadata about compression
+ */
+function compressIfNeeded(rawMsg) {
+    const jsonStr = JSON.stringify(rawMsg);
+    const originalSize = jsonStr.length;
+    // If it fits without compression, send as-is
+    if (originalSize <= 7500) {
+        return {
+            payload: jsonStr,
+            isCompressed: false,
+            originalSize,
+            compressedSize: originalSize,
+        };
+    }
+    // Compress and encode as base64
+    const compressed = gzipSync(jsonStr);
+    const base64 = compressed.toString("base64");
+    // Wrap in a compression envelope
+    const envelope = JSON.stringify({
+        _compressed: true,
+        data: base64,
+    });
+    return {
+        payload: envelope,
+        isCompressed: true,
+        originalSize,
+        compressedSize: envelope.length,
+    };
+}
 // Use PGlite in-memory database for LISTEN/NOTIFY
 const pg = new PGlite();
 // Helper to create safe channel names from untrusted IDs
 function safeChannelName(prefix, id) {
-	const hash = createHash("sha256").update(id).digest("hex").slice(0, 16);
-	return `${prefix}_${hash}`;
+    const hash = createHash("sha256").update(id).digest("hex").slice(0, 16);
+    return `${prefix}_${hash}`;
 }
 export function makeHttpTransport(agent) {
-	const inbound = new TransformStream();
-	const outbound = new TransformStream();
-	const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
-	const agentRunner =
-		"definition" in agent ? agent : makeRunnerFromDefinition(agent);
-	new acp.AgentSideConnection(
-		(conn) => new AgentAcpAdapter(agentRunner, conn),
-		bridge,
-	);
-	const app = new Hono();
-	const decoder = new TextDecoder();
-	const encoder = new TextEncoder();
-	(async () => {
-		const reader = outbound.readable.getReader();
-		let buf = "";
-		for (;;) {
-			const { value, done } = await reader.read();
-			if (done) break;
-			buf += decoder.decode(value, { stream: true });
-			for (let nl = buf.indexOf("\n"); nl !== -1; nl = buf.indexOf("\n")) {
-				const line = buf.slice(0, nl).trim();
-				buf = buf.slice(nl + 1);
-				if (!line) continue;
-				let rawMsg;
-				try {
-					rawMsg = JSON.parse(line);
-				} catch {
-					// ignore malformed lines
-					continue;
-				}
-				// Validate the agent message with Zod schema
-				const parseResult = acp.agentOutgoingMessageSchema.safeParse(rawMsg);
-				if (!parseResult.success) {
-					console.error("Invalid agent message:", parseResult.error.issues);
-					continue;
-				}
-				//const msg = parseResult.data;
-				if (rawMsg == null || typeof rawMsg !== "object") {
-					console.warn("Malformed message, cannot route:", rawMsg);
-					continue;
-				}
-				if (
-					"id" in rawMsg &&
-					typeof rawMsg.id === "string" &&
-					rawMsg.id != null
-				) {
-					// This is a response to a request - send to response-specific channel
-					const channel = safeChannelName("response", rawMsg.id);
-					const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
-					await pg.query(`NOTIFY ${channel}, '${payload}'`);
-				} else if (
-					"params" in rawMsg &&
-					rawMsg.params != null &&
-					typeof rawMsg.params === "object" &&
-					"sessionId" in rawMsg.params &&
-					typeof rawMsg.params.sessionId === "string"
-				) {
-					// Other messages (notifications, requests from agent) go to
-					// session-specific channel
-					const sessionId = rawMsg.params.sessionId;
-					const channel = safeChannelName("notifications", sessionId);
-					const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
-					await pg.query(`NOTIFY ${channel}, '${payload}'`);
-				} else {
-					console.warn("Message without sessionId, cannot route:", rawMsg);
-				}
-			}
-		}
-	})();
-	// TODO: fix this for production
-	app.use(
-		"*",
-		cors({
-			origin: "*",
-			allowHeaders: ["content-type", "authorization", "x-session-id"],
-			allowMethods: ["GET", "POST", "OPTIONS"],
-		}),
-	);
-	app.get("/health", (c) => c.json({ ok: true }));
-	app.get("/events", (c) => {
-		const sessionId = c.req.header("X-Session-ID");
-		if (!sessionId) {
-			return c.json({ error: "X-Session-ID header required" }, 401);
-		}
-		return streamSSE(c, async (stream) => {
-			await stream.writeSSE({ event: "ping", data: "{}" });
-			const hb = setInterval(() => {
-				// Heartbeat to keep proxies from terminating idle connections
-				void stream.writeSSE({ event: "ping", data: "{}" });
-			}, 1000);
-			const channel = safeChannelName("notifications", sessionId);
-			const unsub = await pg.listen(channel, async (payload) => {
-				const json = JSON.parse(payload);
-				await stream.writeSSE({
-					event: "message",
-					data: JSON.stringify(json),
-				});
-			});
-			// Clean up when the client disconnects
-			stream.onAbort(() => {
-				console.log("/events connection closed");
-				clearInterval(hb);
-				unsub();
-			});
-			// Keep the connection open indefinitely
-			await stream.sleep(1000 * 60 * 60 * 24);
-		});
-	});
-	app.post("/rpc", async (c) => {
-		// Get and validate the request body
-		const rawBody = await c.req.json();
-		// Validate using Zod schema
-		const parseResult = acp.clientOutgoingMessageSchema.safeParse(rawBody);
-		if (!parseResult.success) {
-			return c.json(
-				{
-					error: "Invalid ACP message",
-					details: parseResult.error.issues,
-				},
-				400,
-			);
-		}
-		const body = parseResult.data;
-		// Ensure the request has an id
-		const id = "id" in body ? body.id : null;
-		const isRequest = id != null;
-		if (isRequest) {
-			// For requests, set up a listener before sending the request
-			const responseChannel = safeChannelName("response", String(id));
-			let responseResolver;
-			const responsePromise = new Promise((resolve) => {
-				responseResolver = resolve;
-			});
-			const unsub = await pg.listen(responseChannel, (payload) => {
-				const rawResponse = JSON.parse(payload);
-				responseResolver(rawResponse);
-			});
-			// Write NDJSON line into the ACP inbound stream
-			const writer = inbound.writable.getWriter();
-			await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
-			writer.releaseLock();
-			// Wait for response with 30 second timeout
-			const timeoutPromise = new Promise((_, reject) =>
-				setTimeout(() => reject(new Error("Request timeout")), 30000),
-			);
-			try {
-				const response = await Promise.race([responsePromise, timeoutPromise]);
-				return c.json(response);
-			} finally {
-				// Clean up the listener whether we got a response or timed out
-				unsub();
-			}
-		} else {
-			// For notifications, just send and return success
-			const writer = inbound.writable.getWriter();
-			await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
-			writer.releaseLock();
-			return c.json({
-				success: true,
-				message: "Notification sent to agent",
-			});
-		}
-	});
-	const port = Number.parseInt(process.env.PORT || "3100", 10);
-	console.log(`Starting HTTP server on port ${port}...`);
-	Bun.serve({
-		fetch: app.fetch,
-		port,
-	});
-	console.log(`HTTP server listening on http://localhost:${port}`);
+    const inbound = new TransformStream();
+    const outbound = new TransformStream();
+    const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
+    const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
+    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn), bridge);
+    const app = new Hono();
+    // Track active SSE streams by sessionId for direct output delivery
+    const sseStreams = new Map();
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    (async () => {
+        const reader = outbound.readable.getReader();
+        let buf = "";
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            for (let nl = buf.indexOf("\n"); nl !== -1; nl = buf.indexOf("\n")) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line)
+                    continue;
+                let rawMsg;
+                try {
+                    rawMsg = JSON.parse(line);
+                }
+                catch {
+                    // ignore malformed lines
+                    continue;
+                }
+                // Validate the agent message with Zod schema
+                const parseResult = acp.agentOutgoingMessageSchema.safeParse(rawMsg);
+                if (!parseResult.success) {
+                    logger.error("Invalid agent message", {
+                        issues: parseResult.error.issues,
+                    });
+                    continue;
+                }
+                //const msg = parseResult.data;
+                if (rawMsg == null || typeof rawMsg !== "object") {
+                    logger.warn("Malformed message, cannot route", { message: rawMsg });
+                    continue;
+                }
+                if ("id" in rawMsg &&
+                    typeof rawMsg.id === "string" &&
+                    rawMsg.id != null) {
+                    // This is a response to a request - send to response-specific channel
+                    const channel = safeChannelName("response", rawMsg.id);
+                    const { payload, isCompressed, originalSize, compressedSize } = compressIfNeeded(rawMsg);
+                    if (isCompressed) {
+                        logger.info("Compressed response payload", {
+                            requestId: rawMsg.id,
+                            originalSize,
+                            compressedSize,
+                            compressionRatio: ((1 - compressedSize / originalSize) * 100).toFixed(1) + "%",
+                        });
+                    }
+                    // Escape single quotes for PostgreSQL
+                    const escapedPayload = payload.replace(/'/g, "''");
+                    // Check if even compressed payload is too large
+                    if (compressedSize > 7500) {
+                        logger.error("Response payload too large even after compression", {
+                            requestId: rawMsg.id,
+                            originalSize,
+                            compressedSize,
+                        });
+                        // Send error response
+                        const errorResponse = {
+                            jsonrpc: "2.0",
+                            id: rawMsg.id,
+                            error: {
+                                code: -32603,
+                                message: "Response payload too large even after compression",
+                                data: {
+                                    originalSize,
+                                    compressedSize,
+                                },
+                            },
+                        };
+                        const errorPayload = JSON.stringify(errorResponse).replace(/'/g, "''");
+                        await pg.query(`NOTIFY ${channel}, '${errorPayload}'`);
+                        continue;
+                    }
+                    try {
+                        await pg.query(`NOTIFY ${channel}, '${escapedPayload}'`);
+                    }
+                    catch (error) {
+                        logger.error("Failed to send response", {
+                            error,
+                            requestId: rawMsg.id,
+                            originalSize,
+                            compressedSize,
+                        });
+                        // For responses, we still need to send something to unblock the client
+                        const errorResponse = {
+                            jsonrpc: "2.0",
+                            id: rawMsg.id,
+                            error: {
+                                code: -32603,
+                                message: "Failed to send response",
+                                data: {
+                                    originalSize,
+                                    compressedSize,
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        };
+                        const errorPayload = JSON.stringify(errorResponse).replace(/'/g, "''");
+                        await pg.query(`NOTIFY ${channel}, '${errorPayload}'`);
+                    }
+                }
+                else if ("params" in rawMsg &&
+                    rawMsg.params != null &&
+                    typeof rawMsg.params === "object" &&
+                    "sessionId" in rawMsg.params &&
+                    typeof rawMsg.params.sessionId === "string") {
+                    const sessionId = rawMsg.params.sessionId;
+                    const messageType = "method" in rawMsg && typeof rawMsg.method === "string"
+                        ? rawMsg.method
+                        : undefined;
+                    // Check if this is a tool_output update - send directly via SSE
+                    if (messageType === "session/update" &&
+                        "params" in rawMsg &&
+                        rawMsg.params != null &&
+                        typeof rawMsg.params === "object" &&
+                        "update" in rawMsg.params &&
+                        rawMsg.params.update != null &&
+                        typeof rawMsg.params.update === "object" &&
+                        "sessionUpdate" in rawMsg.params.update &&
+                        rawMsg.params.update.sessionUpdate === "tool_output") {
+                        // Send tool output directly via SSE, bypassing PostgreSQL NOTIFY
+                        const stream = sseStreams.get(sessionId);
+                        if (stream) {
+                            try {
+                                await stream.writeSSE({
+                                    event: "message",
+                                    data: JSON.stringify(rawMsg),
+                                });
+                                logger.debug("Sent tool output", {
+                                    sessionId,
+                                    payloadSize: JSON.stringify(rawMsg).length,
+                                });
+                            }
+                            catch (error) {
+                                logger.error("Failed to send tool output", {
+                                    error,
+                                    sessionId,
+                                });
+                            }
+                        }
+                        else {
+                            logger.warn("No SSE stream found for tool output", { sessionId });
+                        }
+                        continue;
+                    }
+                    // Other messages (notifications, requests from agent) go to
+                    // session-specific channel via PostgreSQL NOTIFY
+                    const channel = safeChannelName("notifications", sessionId);
+                    const { payload, isCompressed, originalSize, compressedSize } = compressIfNeeded(rawMsg);
+                    if (isCompressed) {
+                        logger.info("Compressed notification payload", {
+                            sessionId,
+                            messageType,
+                            originalSize,
+                            compressedSize,
+                            compressionRatio: ((1 - compressedSize / originalSize) * 100).toFixed(1) + "%",
+                        });
+                    }
+                    // Escape single quotes for PostgreSQL
+                    const escapedPayload = payload.replace(/'/g, "''");
+                    // Check if even compressed payload is too large
+                    if (compressedSize > 7500) {
+                        logger.error("Notification payload too large even after compression, skipping", {
+                            sessionId,
+                            messageType,
+                            originalSize,
+                            compressedSize,
+                        });
+                        continue;
+                    }
+                    try {
+                        await pg.query(`NOTIFY ${channel}, '${escapedPayload}'`);
+                    }
+                    catch (error) {
+                        logger.error("Failed to send notification", {
+                            error,
+                            sessionId,
+                            messageType,
+                            originalSize,
+                            compressedSize,
+                        });
+                    }
+                }
+                else {
+                    logger.warn("Message without sessionId, cannot route", {
+                        message: rawMsg,
+                    });
+                }
+            }
+        }
+    })();
+    // TODO: fix this for production
+    app.use("*", cors({
+        origin: "*",
+        allowHeaders: ["content-type", "authorization", "x-session-id"],
+        allowMethods: ["GET", "POST", "OPTIONS"],
+    }));
+    app.get("/health", (c) => c.json({ ok: true }));
+    app.get("/events", (c) => {
+        const sessionId = c.req.header("X-Session-ID");
+        if (!sessionId) {
+            logger.warn("GET /events - Missing X-Session-ID header");
+            return c.json({ error: "X-Session-ID header required" }, 401);
+        }
+        logger.debug("GET /events - SSE connection opened", { sessionId });
+        return streamSSE(c, async (stream) => {
+            // Register this stream for direct tool output delivery
+            sseStreams.set(sessionId, stream);
+            await stream.writeSSE({ event: "ping", data: "{}" });
+            const hb = setInterval(() => {
+                // Heartbeat to keep proxies from terminating idle connections
+                void stream.writeSSE({ event: "ping", data: "{}" });
+            }, 1000);
+            const channel = safeChannelName("notifications", sessionId);
+            const unsub = await pg.listen(channel, async (payload) => {
+                let json = JSON.parse(payload);
+                // Check if the message is compressed
+                if (json &&
+                    typeof json === "object" &&
+                    "_compressed" in json &&
+                    json._compressed === true &&
+                    "data" in json &&
+                    typeof json.data === "string") {
+                    // This is a compressed message - decompress it
+                    try {
+                        const { gunzipSync } = await import("node:zlib");
+                        const compressed = Buffer.from(json.data, "base64");
+                        const decompressed = gunzipSync(compressed);
+                        json = JSON.parse(decompressed.toString());
+                        logger.trace("Decompressed SSE message", { sessionId, channel });
+                    }
+                    catch (error) {
+                        logger.error("Failed to decompress message", {
+                            error,
+                            sessionId,
+                            channel,
+                        });
+                        return;
+                    }
+                }
+                logger.trace("Sending SSE message", { sessionId, channel });
+                await stream.writeSSE({
+                    event: "message",
+                    data: JSON.stringify(json),
+                });
+            });
+            // Clean up when the client disconnects
+            stream.onAbort(() => {
+                logger.debug("GET /events - SSE connection closed", { sessionId });
+                clearInterval(hb);
+                unsub();
+                sseStreams.delete(sessionId);
+            });
+            // Keep the connection open indefinitely
+            await stream.sleep(1000 * 60 * 60 * 24);
+        });
+    });
+    app.post("/rpc", async (c) => {
+        // Get and validate the request body
+        const rawBody = await c.req.json();
+        // Validate using Zod schema
+        const parseResult = acp.clientOutgoingMessageSchema.safeParse(rawBody);
+        if (!parseResult.success) {
+            logger.warn("POST /rpc - Invalid ACP message", {
+                issues: parseResult.error.issues,
+            });
+            return c.json({
+                error: "Invalid ACP message",
+                details: parseResult.error.issues,
+            }, 400);
+        }
+        const body = parseResult.data;
+        // Ensure the request has an id
+        const id = "id" in body ? body.id : null;
+        const isRequest = id != null;
+        const method = "method" in body ? body.method : "notification";
+        logger.debug("POST /rpc - Received request", { method, id, isRequest });
+        if (isRequest) {
+            // For requests, set up a listener before sending the request
+            const responseChannel = safeChannelName("response", String(id));
+            let responseResolver;
+            const responsePromise = new Promise((resolve) => {
+                responseResolver = resolve;
+            });
+            const unsub = await pg.listen(responseChannel, async (payload) => {
+                let rawResponse = JSON.parse(payload);
+                // Check if the response is compressed
+                if (rawResponse &&
+                    typeof rawResponse === "object" &&
+                    "_compressed" in rawResponse &&
+                    rawResponse._compressed === true &&
+                    "data" in rawResponse &&
+                    typeof rawResponse.data === "string") {
+                    // This is a compressed response - decompress it
+                    try {
+                        const { gunzipSync } = await import("node:zlib");
+                        const compressed = Buffer.from(rawResponse.data, "base64");
+                        const decompressed = gunzipSync(compressed);
+                        rawResponse = JSON.parse(decompressed.toString());
+                        logger.trace("Decompressed RPC response", { id });
+                    }
+                    catch (error) {
+                        logger.error("Failed to decompress response", {
+                            error,
+                            requestId: id,
+                        });
+                        rawResponse = {
+                            jsonrpc: "2.0",
+                            id,
+                            error: {
+                                code: -32603,
+                                message: "Failed to decompress response",
+                                data: {
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        };
+                    }
+                }
+                responseResolver(rawResponse);
+            });
+            // Write NDJSON line into the ACP inbound stream
+            const writer = inbound.writable.getWriter();
+            await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
+            writer.releaseLock();
+            // Wait for response with 30 second timeout
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), 30000));
+            try {
+                const response = await Promise.race([responsePromise, timeoutPromise]);
+                logger.debug("POST /rpc - Response received", { id });
+                return c.json(response);
+            }
+            catch (error) {
+                logger.error("POST /rpc - Request timeout", {
+                    id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+            finally {
+                // Clean up the listener whether we got a response or timed out
+                unsub();
+            }
+        }
+        else {
+            // For notifications, just send and return success
+            const writer = inbound.writable.getWriter();
+            await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
+            writer.releaseLock();
+            return c.json({
+                success: true,
+                message: "Notification sent to agent",
+            });
+        }
+    });
+    const port = Number.parseInt(process.env.PORT || "3100", 10);
+    logger.info("Starting HTTP server", { port });
+    Bun.serve({
+        fetch: app.fetch,
+        port,
+    });
+    logger.info("HTTP server listening", {
+        url: `http://localhost:${port}`,
+        port,
+    });
 }

package/dist/definition/index.d.ts

@@ -19,6 +19,9 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
     tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"filesystem">;
+        working_directory: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/definition/index.js

@@ -29,8 +29,18 @@ const CustomToolSchema = z.object({
     type: z.literal("custom"),
     modulePath: z.string(),
 });
+/** Filesystem tool configuration schema. */
+const FilesystemToolSchema = z.object({
+    type: z.literal("filesystem"),
+    /** If omitted, defaults to process.cwd() at runtime */
+    working_directory: z.string().optional(),
+});
 /** Tool schema - can be a string (built-in tool) or custom tool object. */
-const ToolSchema = z.union([z.string(), CustomToolSchema]);
+const ToolSchema = z.union([
+    z.string(),
+    CustomToolSchema,
+    FilesystemToolSchema,
+]);
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({
     systemPrompt: z.string().nullable(),

package/dist/dev-agent/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};