@townco/ui 0.1.0 → 0.1.6

package/dist/sdk/transports/stdio.d.ts

@@ -5,24 +5,24 @@ import type { StdioTransportOptions, Transport } from "./types.js";
  * Uses JSON-RPC 2.0 over stdio to communicate with agents
  */
 export declare class StdioTransport implements Transport {
-    private options;
-    private agentProcess;
-    private connection;
-    private connected;
-    private sessionUpdateCallbacks;
-    private errorCallbacks;
-    private messageQueue;
-    private currentSessionId;
-    private chunkResolvers;
-    private streamComplete;
-    constructor(options: StdioTransportOptions);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    send(message: Message): Promise<void>;
-    receive(): AsyncIterableIterator<MessageChunk>;
-    isConnected(): boolean;
-    onSessionUpdate(callback: (update: SessionUpdate) => void): () => void;
-    onError(callback: (error: Error) => void): () => void;
-    private notifySessionUpdate;
-    private notifyError;
+	private options;
+	private agentProcess;
+	private connection;
+	private connected;
+	private sessionUpdateCallbacks;
+	private errorCallbacks;
+	private messageQueue;
+	private currentSessionId;
+	private chunkResolvers;
+	private streamComplete;
+	constructor(options: StdioTransportOptions);
+	connect(): Promise<void>;
+	disconnect(): Promise<void>;
+	send(message: Message): Promise<void>;
+	receive(): AsyncIterableIterator<MessageChunk>;
+	isConnected(): boolean;
+	onSessionUpdate(callback: (update: SessionUpdate) => void): () => void;
+	onError(callback: (error: Error) => void): () => void;
+	private notifySessionUpdate;
+	private notifyError;
 }

package/dist/sdk/transports/stdio.js

@@ -1,294 +1,297 @@
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
-import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
+import {
+	ClientSideConnection,
+	ndJsonStream,
+	PROTOCOL_VERSION,
+} from "@agentclientprotocol/sdk";
 /**
  * Stdio transport implementation using Agent Client Protocol SDK
  * Uses JSON-RPC 2.0 over stdio to communicate with agents
  */
 export class StdioTransport {
-    options;
-    agentProcess = null;
-    connection = null;
-    connected = false;
-    sessionUpdateCallbacks = new Set();
-    errorCallbacks = new Set();
-    messageQueue = [];
-    currentSessionId = null;
-    chunkResolvers = [];
-    streamComplete = false;
-    constructor(options) {
-        this.options = options;
-    }
-    async connect() {
-        if (this.connected) {
-            return;
-        }
-        try {
-            // Spawn the agent process
-            this.agentProcess = spawn(this.options.agentPath, this.options.agentArgs || [], {
-                cwd: this.options.workingDirectory || process.cwd(),
-                env: { ...process.env, ...this.options.environment },
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-            if (!this.agentProcess.stdin ||
-                !this.agentProcess.stdout ||
-                !this.agentProcess.stderr) {
-                throw new Error("Failed to create stdio pipes for agent process");
-            }
-            // Convert Node.js streams to Web streams
-            const outputStream = Writable.toWeb(this.agentProcess.stdin);
-            const inputStream = Readable.toWeb(this.agentProcess.stdout);
-            // Create the bidirectional stream using ndJsonStream
-            const stream = ndJsonStream(outputStream, inputStream);
-            // Create ACP client implementation factory
-            const self = this;
-            const clientFactory = (_agent) => {
-                return {
-                    async requestPermission(params) {
-                        // For now, auto-approve all permissions
-                        // In a real implementation, this should prompt the user
-                        console.log(`Permission requested:`, params);
-                        // @ts-expect-error - Type mismatch with ACP SDK v0.5.1
-                        return { outcome: "approved" };
-                    },
-                    async sessionUpdate(params) {
-                        // Handle session updates from the agent
-                        const paramsExtended = params;
-                        const update = paramsExtended.update;
-                        const sessionUpdate = {
-                            sessionId: self.currentSessionId || params.sessionId,
-                            status: "active",
-                        };
-                        // Queue message chunks if present - content is in update.content
-                        if (update?.content) {
-                            const content = update.content;
-                            let chunk = null;
-                            if (content.type === "text" && content.text) {
-                                chunk = {
-                                    id: params.sessionId,
-                                    role: "assistant",
-                                    contentDelta: { type: "text", text: content.text },
-                                    isComplete: false,
-                                };
-                            }
-                            else if (content.type === "tool_call") {
-                                chunk = {
-                                    id: params.sessionId,
-                                    role: "assistant",
-                                    contentDelta: content,
-                                    isComplete: false,
-                                };
-                            }
-                            if (chunk) {
-                                // Resolve any waiting receive() calls immediately
-                                const resolver = self.chunkResolvers.shift();
-                                if (resolver) {
-                                    resolver(chunk);
-                                }
-                                else {
-                                    // Only queue if no resolver is waiting
-                                    self.messageQueue.push(chunk);
-                                }
-                            }
-                        }
-                        self.notifySessionUpdate(sessionUpdate);
-                    },
-                    async writeTextFile(params) {
-                        const fs = await import("node:fs/promises");
-                        await fs.writeFile(params.path, params.content, "utf-8");
-                        return {};
-                    },
-                    async readTextFile(params) {
-                        const fs = await import("node:fs/promises");
-                        const content = await fs.readFile(params.path, "utf-8");
-                        return { content };
-                    },
-                };
-            };
-            // Create the client-side connection
-            this.connection = new ClientSideConnection(clientFactory, stream);
-            // Handle stderr for debugging
-            this.agentProcess.stderr.on("data", (data) => {
-                console.error(`Agent stderr: ${data}`);
-            });
-            // Handle process exit
-            this.agentProcess.on("exit", (code, signal) => {
-                this.connected = false;
-                const error = new Error(`Agent process exited with code ${code} and signal ${signal}`);
-                this.notifyError(error);
-            });
-            // Listen for connection closure
-            this.connection.closed.then(() => {
-                this.connected = false;
-            });
-            // Initialize the connection
-            const initResponse = await this.connection.initialize({
-                protocolVersion: PROTOCOL_VERSION,
-                clientCapabilities: {
-                    fs: {
-                        readTextFile: true,
-                        writeTextFile: true,
-                    },
-                },
-            });
-            console.log("ACP connection initialized:", initResponse);
-            this.connected = true;
-        }
-        catch (error) {
-            this.connected = false;
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.notifyError(err);
-            throw err;
-        }
-    }
-    async disconnect() {
-        if (!this.connected) {
-            return;
-        }
-        try {
-            // Terminate the agent process (this will close the connection)
-            if (this.agentProcess) {
-                this.agentProcess.kill();
-                this.agentProcess = null;
-            }
-            // Wait for connection to close
-            if (this.connection) {
-                await this.connection.closed;
-            }
-            this.connection = null;
-            this.connected = false;
-            this.currentSessionId = null;
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.notifyError(err);
-            throw err;
-        }
-    }
-    async send(message) {
-        if (!this.connected || !this.connection) {
-            throw new Error("Transport not connected");
-        }
-        try {
-            // Reset stream state for new message
-            this.streamComplete = false;
-            this.messageQueue = [];
-            // If no session, create one first
-            if (!this.currentSessionId) {
-                const sessionResponse = await this.connection.newSession({
-                    cwd: this.options.workingDirectory || process.cwd(),
-                    mcpServers: [],
-                });
-                this.currentSessionId = sessionResponse.sessionId;
-            }
-            // Convert our message format to ACP prompt format
-            const textContent = message.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("\n");
-            // Send the prompt - ACP expects "prompt" field with ContentBlock[]
-            const promptResponse = await this.connection.prompt({
-                sessionId: this.currentSessionId,
-                prompt: [
-                    {
-                        type: "text",
-                        text: textContent,
-                    },
-                ],
-            });
-            console.log("Prompt response:", promptResponse);
-            // Mark stream as complete after prompt finishes
-            this.streamComplete = true;
-            // Resolve any waiting receive() calls with completion
-            const resolver = this.chunkResolvers.shift();
-            if (resolver) {
-                resolver({
-                    id: this.currentSessionId || "unknown",
-                    role: "assistant",
-                    contentDelta: { type: "text", text: "" },
-                    isComplete: true,
-                });
-            }
-        }
-        catch (error) {
-            this.streamComplete = true;
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.notifyError(err);
-            throw err;
-        }
-    }
-    async *receive() {
-        // Keep yielding chunks until stream is complete
-        while (!this.streamComplete) {
-            // Check if there are queued messages
-            if (this.messageQueue.length > 0) {
-                const chunk = this.messageQueue.shift();
-                if (chunk) {
-                    yield chunk;
-                }
-            }
-            else {
-                // Wait for next chunk to arrive
-                const chunk = await new Promise((resolve) => {
-                    this.chunkResolvers.push(resolve);
-                });
-                if (chunk.isComplete) {
-                    yield chunk;
-                    return;
-                }
-                else {
-                    yield chunk;
-                }
-            }
-        }
-        // Yield any remaining queued messages
-        while (this.messageQueue.length > 0) {
-            const chunk = this.messageQueue.shift();
-            if (chunk) {
-                yield chunk;
-            }
-        }
-        // Mark the stream as complete
-        yield {
-            id: this.currentSessionId || "unknown",
-            role: "assistant",
-            contentDelta: { type: "text", text: "" },
-            isComplete: true,
-        };
-    }
-    isConnected() {
-        return this.connected;
-    }
-    onSessionUpdate(callback) {
-        this.sessionUpdateCallbacks.add(callback);
-        return () => {
-            this.sessionUpdateCallbacks.delete(callback);
-        };
-    }
-    onError(callback) {
-        this.errorCallbacks.add(callback);
-        return () => {
-            this.errorCallbacks.delete(callback);
-        };
-    }
-    notifySessionUpdate(update) {
-        for (const callback of this.sessionUpdateCallbacks) {
-            try {
-                callback(update);
-            }
-            catch (error) {
-                console.error("Error in session update callback:", error);
-            }
-        }
-    }
-    notifyError(error) {
-        for (const callback of this.errorCallbacks) {
-            try {
-                callback(error);
-            }
-            catch (err) {
-                console.error("Error in error callback:", err);
-            }
-        }
-    }
+	options;
+	agentProcess = null;
+	connection = null;
+	connected = false;
+	sessionUpdateCallbacks = new Set();
+	errorCallbacks = new Set();
+	messageQueue = [];
+	currentSessionId = null;
+	chunkResolvers = [];
+	streamComplete = false;
+	constructor(options) {
+		this.options = options;
+	}
+	async connect() {
+		if (this.connected) {
+			return;
+		}
+		try {
+			// Spawn the agent process
+			this.agentProcess = spawn(
+				this.options.agentPath,
+				this.options.agentArgs || [],
+				{
+					cwd: this.options.workingDirectory || process.cwd(),
+					env: { ...process.env, ...this.options.environment },
+					stdio: ["pipe", "pipe", "pipe"],
+				},
+			);
+			if (
+				!this.agentProcess.stdin ||
+				!this.agentProcess.stdout ||
+				!this.agentProcess.stderr
+			) {
+				throw new Error("Failed to create stdio pipes for agent process");
+			}
+			// Convert Node.js streams to Web streams
+			const outputStream = Writable.toWeb(this.agentProcess.stdin);
+			const inputStream = Readable.toWeb(this.agentProcess.stdout);
+			// Create the bidirectional stream using ndJsonStream
+			const stream = ndJsonStream(outputStream, inputStream);
+			// Create ACP client implementation factory
+			const self = this;
+			const clientFactory = (_agent) => {
+				return {
+					async requestPermission(params) {
+						// For now, auto-approve all permissions
+						// In a real implementation, this should prompt the user
+						console.log(`Permission requested:`, params);
+						// @ts-expect-error - Type mismatch with ACP SDK v0.5.1
+						return { outcome: "approved" };
+					},
+					async sessionUpdate(params) {
+						// Handle session updates from the agent
+						const paramsExtended = params;
+						const update = paramsExtended.update;
+						const sessionUpdate = {
+							sessionId: self.currentSessionId || params.sessionId,
+							status: "active",
+						};
+						// Queue message chunks if present - content is in update.content
+						if (update?.content) {
+							const content = update.content;
+							let chunk = null;
+							if (content.type === "text" && content.text) {
+								chunk = {
+									id: params.sessionId,
+									role: "assistant",
+									contentDelta: { type: "text", text: content.text },
+									isComplete: false,
+								};
+							} else if (content.type === "tool_call") {
+								chunk = {
+									id: params.sessionId,
+									role: "assistant",
+									contentDelta: content,
+									isComplete: false,
+								};
+							}
+							if (chunk) {
+								// Resolve any waiting receive() calls immediately
+								const resolver = self.chunkResolvers.shift();
+								if (resolver) {
+									resolver(chunk);
+								} else {
+									// Only queue if no resolver is waiting
+									self.messageQueue.push(chunk);
+								}
+							}
+						}
+						self.notifySessionUpdate(sessionUpdate);
+					},
+					async writeTextFile(params) {
+						const fs = await import("node:fs/promises");
+						await fs.writeFile(params.path, params.content, "utf-8");
+						return {};
+					},
+					async readTextFile(params) {
+						const fs = await import("node:fs/promises");
+						const content = await fs.readFile(params.path, "utf-8");
+						return { content };
+					},
+				};
+			};
+			// Create the client-side connection
+			this.connection = new ClientSideConnection(clientFactory, stream);
+			// Handle stderr for debugging
+			this.agentProcess.stderr.on("data", (data) => {
+				console.error(`Agent stderr: ${data}`);
+			});
+			// Handle process exit
+			this.agentProcess.on("exit", (code, signal) => {
+				this.connected = false;
+				const error = new Error(
+					`Agent process exited with code ${code} and signal ${signal}`,
+				);
+				this.notifyError(error);
+			});
+			// Listen for connection closure
+			this.connection.closed.then(() => {
+				this.connected = false;
+			});
+			// Initialize the connection
+			const initResponse = await this.connection.initialize({
+				protocolVersion: PROTOCOL_VERSION,
+				clientCapabilities: {
+					fs: {
+						readTextFile: true,
+						writeTextFile: true,
+					},
+				},
+			});
+			console.log("ACP connection initialized:", initResponse);
+			this.connected = true;
+		} catch (error) {
+			this.connected = false;
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.notifyError(err);
+			throw err;
+		}
+	}
+	async disconnect() {
+		if (!this.connected) {
+			return;
+		}
+		try {
+			// Terminate the agent process (this will close the connection)
+			if (this.agentProcess) {
+				this.agentProcess.kill();
+				this.agentProcess = null;
+			}
+			// Wait for connection to close
+			if (this.connection) {
+				await this.connection.closed;
+			}
+			this.connection = null;
+			this.connected = false;
+			this.currentSessionId = null;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.notifyError(err);
+			throw err;
+		}
+	}
+	async send(message) {
+		if (!this.connected || !this.connection) {
+			throw new Error("Transport not connected");
+		}
+		try {
+			// Reset stream state for new message
+			this.streamComplete = false;
+			this.messageQueue = [];
+			// If no session, create one first
+			if (!this.currentSessionId) {
+				const sessionResponse = await this.connection.newSession({
+					cwd: this.options.workingDirectory || process.cwd(),
+					mcpServers: [],
+				});
+				this.currentSessionId = sessionResponse.sessionId;
+			}
+			// Convert our message format to ACP prompt format
+			const textContent = message.content
+				.filter((c) => c.type === "text")
+				.map((c) => c.text)
+				.join("\n");
+			// Send the prompt - ACP expects "prompt" field with ContentBlock[]
+			const promptResponse = await this.connection.prompt({
+				sessionId: this.currentSessionId,
+				prompt: [
+					{
+						type: "text",
+						text: textContent,
+					},
+				],
+			});
+			console.log("Prompt response:", promptResponse);
+			// Mark stream as complete after prompt finishes
+			this.streamComplete = true;
+			// Resolve any waiting receive() calls with completion
+			const resolver = this.chunkResolvers.shift();
+			if (resolver) {
+				resolver({
+					id: this.currentSessionId || "unknown",
+					role: "assistant",
+					contentDelta: { type: "text", text: "" },
+					isComplete: true,
+				});
+			}
+		} catch (error) {
+			this.streamComplete = true;
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.notifyError(err);
+			throw err;
+		}
+	}
+	async *receive() {
+		// Keep yielding chunks until stream is complete
+		while (!this.streamComplete) {
+			// Check if there are queued messages
+			if (this.messageQueue.length > 0) {
+				const chunk = this.messageQueue.shift();
+				if (chunk) {
+					yield chunk;
+				}
+			} else {
+				// Wait for next chunk to arrive
+				const chunk = await new Promise((resolve) => {
+					this.chunkResolvers.push(resolve);
+				});
+				if (chunk.isComplete) {
+					yield chunk;
+					return;
+				} else {
+					yield chunk;
+				}
+			}
+		}
+		// Yield any remaining queued messages
+		while (this.messageQueue.length > 0) {
+			const chunk = this.messageQueue.shift();
+			if (chunk) {
+				yield chunk;
+			}
+		}
+		// Mark the stream as complete
+		yield {
+			id: this.currentSessionId || "unknown",
+			role: "assistant",
+			contentDelta: { type: "text", text: "" },
+			isComplete: true,
+		};
+	}
+	isConnected() {
+		return this.connected;
+	}
+	onSessionUpdate(callback) {
+		this.sessionUpdateCallbacks.add(callback);
+		return () => {
+			this.sessionUpdateCallbacks.delete(callback);
+		};
+	}
+	onError(callback) {
+		this.errorCallbacks.add(callback);
+		return () => {
+			this.errorCallbacks.delete(callback);
+		};
+	}
+	notifySessionUpdate(update) {
+		for (const callback of this.sessionUpdateCallbacks) {
+			try {
+				callback(update);
+			} catch (error) {
+				console.error("Error in session update callback:", error);
+			}
+		}
+	}
+	notifyError(error) {
+		for (const callback of this.errorCallbacks) {
+			try {
+				callback(error);
+			} catch (err) {
+				console.error("Error in error callback:", err);
+			}
+		}
+	}
 }