@townco/ui 0.1.6 → 0.1.7

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,297 +1,294 @@
 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);
+            }
+        }
+    }
 }