@townco/ui 0.1.17 → 0.1.19

package/dist/sdk/schemas/session.d.ts

@@ -3,12 +3,12 @@ import { z } from "zod";
  * Session status
  */
 export declare const SessionStatus: z.ZodEnum<{
+    error: "error";
     idle: "idle";
     connecting: "connecting";
     connected: "connected";
     active: "active";
     streaming: "streaming";
-    error: "error";
     disconnected: "disconnected";
 }>;
 export type SessionStatus = z.infer<typeof SessionStatus>;
@@ -40,12 +40,12 @@ export type SessionMetadata = z.infer<typeof SessionMetadata>;
 export declare const Session: z.ZodObject<{
     id: z.ZodString;
     status: z.ZodEnum<{
+        error: "error";
         idle: "idle";
         connecting: "connecting";
         connected: "connected";
         active: "active";
         streaming: "streaming";
-        error: "error";
         disconnected: "disconnected";
     }>;
     config: z.ZodObject<{
@@ -108,12 +108,12 @@ export type Session = z.infer<typeof Session>;
 export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
     sessionId: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
         idle: "idle";
         connecting: "connecting";
         connected: "connected";
         active: "active";
         streaming: "streaming";
-        error: "error";
         disconnected: "disconnected";
     }>>;
     message: z.ZodOptional<z.ZodObject<{
@@ -214,12 +214,12 @@ export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     sessionId: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
         idle: "idle";
         connecting: "connecting";
         connected: "connected";
         active: "active";
         streaming: "streaming";
-        error: "error";
         disconnected: "disconnected";
     }>>;
     message: z.ZodOptional<z.ZodObject<{
@@ -305,12 +305,12 @@ export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     sessionId: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
         idle: "idle";
         connecting: "connecting";
         connected: "connected";
         active: "active";
         streaming: "streaming";
-        error: "error";
         disconnected: "disconnected";
     }>>;
     message: z.ZodOptional<z.ZodObject<{
@@ -361,12 +361,12 @@ export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     sessionId: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
         idle: "idle";
         connecting: "connecting";
         connected: "connected";
         active: "active";
         streaming: "streaming";
-        error: "error";
         disconnected: "disconnected";
     }>>;
     message: z.ZodOptional<z.ZodObject<{

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

@@ -5,59 +5,59 @@ import type { HttpTransportOptions, Transport } from "./types.js";
  * Uses POST /rpc for client->agent messages and GET /events (SSE) for agent->client
  */
 export declare class HttpTransport implements Transport {
-	private connected;
-	private sessionUpdateCallbacks;
-	private errorCallbacks;
-	private messageQueue;
-	private currentSessionId;
-	private chunkResolvers;
-	private streamComplete;
-	private sseAbortController;
-	private reconnectAttempts;
-	private maxReconnectAttempts;
-	private reconnectDelay;
-	private reconnecting;
-	private abortController;
-	private options;
-	constructor(options: HttpTransportOptions);
-	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;
-	/**
-	 * Send an ACP RPC request to the server
-	 */
-	private sendRpcRequest;
-	/**
-	 * Connect to the SSE event stream
-	 * Uses fetch-based SSE to support custom headers (X-Session-ID)
-	 */
-	private connectSSE;
-	/**
-	 * Handle SSE disconnection with automatic reconnection
-	 */
-	private handleSSEDisconnect;
-	/**
-	 * Handle an incoming SSE message
-	 */
-	private handleSSEMessage;
-	/**
-	 * Handle a session notification from the agent
-	 */
-	private handleSessionNotification;
-	/**
-	 * Generate a unique request ID
-	 */
-	private generateRequestId;
-	/**
-	 * Notify all session update callbacks
-	 */
-	private notifySessionUpdate;
-	/**
-	 * Notify all error callbacks
-	 */
-	private notifyError;
+    private connected;
+    private sessionUpdateCallbacks;
+    private errorCallbacks;
+    private messageQueue;
+    private currentSessionId;
+    private chunkResolvers;
+    private streamComplete;
+    private sseAbortController;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private reconnecting;
+    private abortController;
+    private options;
+    constructor(options: HttpTransportOptions);
+    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;
+    /**
+     * Send an ACP RPC request to the server
+     */
+    private sendRpcRequest;
+    /**
+     * Connect to the SSE event stream
+     * Uses fetch-based SSE to support custom headers (X-Session-ID)
+     */
+    private connectSSE;
+    /**
+     * Handle SSE disconnection with automatic reconnection
+     */
+    private handleSSEDisconnect;
+    /**
+     * Handle an incoming SSE message
+     */
+    private handleSSEMessage;
+    /**
+     * Handle a session notification from the agent
+     */
+    private handleSessionNotification;
+    /**
+     * Generate a unique request ID
+     */
+    private generateRequestId;
+    /**
+     * Notify all session update callbacks
+     */
+    private notifySessionUpdate;
+    /**
+     * Notify all error callbacks
+     */
+    private notifyError;
 }

package/dist/sdk/transports/http.js

@@ -217,9 +217,9 @@ export class HttpTransport {
             "Content-Type": "application/json",
             ...this.options.headers,
         };
-        const timeout = this.options.timeout || 30000;
+        const timeoutMs = this.options.timeout ?? 10 * 60 * 1000;
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
         try {
             const response = await fetch(`${this.options.baseUrl}/rpc`, {
                 method: "POST",
@@ -242,7 +242,7 @@ export class HttpTransport {
         catch (error) {
             clearTimeout(timeoutId);
             if (error instanceof Error && error.name === "AbortError") {
-                throw new Error(`Request timeout after ${timeout}ms`);
+                throw new Error(`Request timeout after ${timeoutMs}ms`);
             }
             throw error;
         }

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/types.d.ts

@@ -3,61 +3,61 @@ import type { Message, MessageChunk, SessionUpdate } from "../schemas/index.js";
  * Transport interface for different communication methods
  */
 export interface Transport {
-	/**
-	 * Initialize the transport connection
-	 */
-	connect(): Promise<void>;
-	/**
-	 * Close the transport connection
-	 */
-	disconnect(): Promise<void>;
-	/**
-	 * Send a message through the transport
-	 */
-	send(message: Message): Promise<void>;
-	/**
-	 * Receive messages from the transport
-	 * Returns an async iterator for streaming support
-	 */
-	receive(): AsyncIterableIterator<MessageChunk>;
-	/**
-	 * Get current connection status
-	 */
-	isConnected(): boolean;
-	/**
-	 * Subscribe to session updates
-	 */
-	onSessionUpdate(callback: (update: SessionUpdate) => void): () => void;
-	/**
-	 * Subscribe to errors
-	 */
-	onError(callback: (error: Error) => void): () => void;
+    /**
+     * Initialize the transport connection
+     */
+    connect(): Promise<void>;
+    /**
+     * Close the transport connection
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a message through the transport
+     */
+    send(message: Message): Promise<void>;
+    /**
+     * Receive messages from the transport
+     * Returns an async iterator for streaming support
+     */
+    receive(): AsyncIterableIterator<MessageChunk>;
+    /**
+     * Get current connection status
+     */
+    isConnected(): boolean;
+    /**
+     * Subscribe to session updates
+     */
+    onSessionUpdate(callback: (update: SessionUpdate) => void): () => void;
+    /**
+     * Subscribe to errors
+     */
+    onError(callback: (error: Error) => void): () => void;
 }
 /**
  * Stdio transport options
  */
 export interface StdioTransportOptions {
-	agentPath: string;
-	agentArgs?: string[];
-	environment?: Record<string, string>;
-	workingDirectory?: string;
-	timeout?: number;
+    agentPath: string;
+    agentArgs?: string[];
+    environment?: Record<string, string>;
+    workingDirectory?: string;
+    timeout?: number;
 }
 /**
  * HTTP transport options
  */
 export interface HttpTransportOptions {
-	baseUrl: string;
-	apiKey?: string;
-	timeout?: number;
-	headers?: Record<string, string>;
+    baseUrl: string;
+    apiKey?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
 }
 /**
  * WebSocket transport options
  */
 export interface WebSocketTransportOptions {
-	url: string;
-	protocols?: string[];
-	reconnect?: boolean;
-	reconnectDelay?: number;
+    url: string;
+    protocols?: string[];
+    reconnect?: boolean;
+    reconnectDelay?: number;
 }

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

@@ -5,16 +5,16 @@ import type { Transport, WebSocketTransportOptions } from "./types.js";
  * Will be implemented when HTTP ACP server with WebSocket support is ready
  */
 export declare class WebSocketTransport implements Transport {
-	private ws;
-	private connected;
-	private sessionUpdateCallbacks;
-	private errorCallbacks;
-	constructor(_options: WebSocketTransportOptions);
-	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 ws;
+    private connected;
+    private sessionUpdateCallbacks;
+    private errorCallbacks;
+    constructor(_options: WebSocketTransportOptions);
+    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;
 }

package/dist/sdk/transports/websocket.js

@@ -3,56 +3,50 @@
  * Will be implemented when HTTP ACP server with WebSocket support is ready
  */
 export class WebSocketTransport {
-	ws = null;
-	connected = false;
-	sessionUpdateCallbacks = new Set();
-	errorCallbacks = new Set();
-	// biome-ignore lint/complexity/noUselessConstructor: Constructor needed for type compatibility with other transports
-	constructor(_options) {
-		// Options will be used when WebSocket transport is implemented
-	}
-	async connect() {
-		// TODO: Implement WebSocket connection
-		throw new Error(
-			"WebSocketTransport not yet implemented. Waiting for HTTP ACP server.",
-		);
-	}
-	async disconnect() {
-		if (this.ws) {
-			this.ws.close();
-			this.ws = null;
-		}
-		this.connected = false;
-	}
-	async send(_message) {
-		if (!this.connected || !this.ws) {
-			throw new Error("Transport not connected");
-		}
-		// TODO: Implement WebSocket message sending
-		throw new Error(
-			"WebSocketTransport not yet implemented. Waiting for HTTP ACP server.",
-		);
-	}
-	// biome-ignore lint/correctness/useYield: .
-	async *receive() {
-		// TODO: Implement WebSocket message receiving
-		throw new Error(
-			"WebSocketTransport not yet implemented. Waiting for HTTP ACP server.",
-		);
-	}
-	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);
-		};
-	}
+    ws = null;
+    connected = false;
+    sessionUpdateCallbacks = new Set();
+    errorCallbacks = new Set();
+    // biome-ignore lint/complexity/noUselessConstructor: Constructor needed for type compatibility with other transports
+    constructor(_options) {
+        // Options will be used when WebSocket transport is implemented
+    }
+    async connect() {
+        // TODO: Implement WebSocket connection
+        throw new Error("WebSocketTransport not yet implemented. Waiting for HTTP ACP server.");
+    }
+    async disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+    }
+    async send(_message) {
+        if (!this.connected || !this.ws) {
+            throw new Error("Transport not connected");
+        }
+        // TODO: Implement WebSocket message sending
+        throw new Error("WebSocketTransport not yet implemented. Waiting for HTTP ACP server.");
+    }
+    // biome-ignore lint/correctness/useYield: .
+    async *receive() {
+        // TODO: Implement WebSocket message receiving
+        throw new Error("WebSocketTransport not yet implemented. Waiting for HTTP ACP server.");
+    }
+    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);
+        };
+    }
 }

package/dist/tui/components/ChatView.d.ts

@@ -1,7 +1,5 @@
 import type { AcpClient } from "../../sdk/client/index.js";
 export interface ChatViewProps {
-	client: AcpClient | null;
+    client: AcpClient | null;
 }
-export declare function ChatView({
-	client,
-}: ChatViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChatView({ client }: ChatViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/tui/components/GameOfLife.js

@@ -1,79 +1,50 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { useEffect, useState } from "react";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-
 const ROWS = 12;
 const COLS = 60;
 // Initialize with a random pattern
 function createRandomGrid() {
-	return Array.from({ length: ROWS }, () =>
-		Array.from({ length: COLS }, () => Math.random() < 0.3),
-	);
+    return Array.from({ length: ROWS }, () => Array.from({ length: COLS }, () => Math.random() < 0.3));
 }
 // Count living neighbors
 function countNeighbors(grid, row, col) {
-	let count = 0;
-	for (let i = -1; i <= 1; i++) {
-		for (let j = -1; j <= 1; j++) {
-			if (i === 0 && j === 0) continue;
-			const newRow = (row + i + ROWS) % ROWS;
-			const newCol = (col + j + COLS) % COLS;
-			if (grid[newRow]?.[newCol]) count++;
-		}
-	}
-	return count;
+    let count = 0;
+    for (let i = -1; i <= 1; i++) {
+        for (let j = -1; j <= 1; j++) {
+            if (i === 0 && j === 0)
+                continue;
+            const newRow = (row + i + ROWS) % ROWS;
+            const newCol = (col + j + COLS) % COLS;
+            if (grid[newRow]?.[newCol])
+                count++;
+        }
+    }
+    return count;
 }
 // Compute next generation
 function nextGeneration(grid) {
-	return grid.map((row, i) =>
-		row.map((cell, j) => {
-			const neighbors = countNeighbors(grid, i, j);
-			if (cell) {
-				return neighbors === 2 || neighbors === 3;
-			} else {
-				return neighbors === 3;
-			}
-		}),
-	);
+    return grid.map((row, i) => row.map((cell, j) => {
+        const neighbors = countNeighbors(grid, i, j);
+        if (cell) {
+            return neighbors === 2 || neighbors === 3;
+        }
+        else {
+            return neighbors === 3;
+        }
+    }));
 }
 export function GameOfLife() {
-	const [grid, setGrid] = useState(createRandomGrid);
-	const [generation, setGeneration] = useState(0);
-	// Generate stable row IDs on mount
-	const rowIds = useState(() =>
-		Array.from({ length: ROWS }, (_, i) => `row-${i}`),
-	)[0];
-	useEffect(() => {
-		const interval = setInterval(() => {
-			setGrid((prevGrid) => nextGeneration(prevGrid));
-			setGeneration((prev) => prev + 1);
-		}, 150);
-		return () => clearInterval(interval);
-	}, []);
-	return _jsxs(Box, {
-		flexDirection: "column",
-		paddingX: 1,
-		children: [
-			_jsxs(Text, {
-				color: "gray",
-				italic: true,
-				children: ["Conway's Game of Life (generation ", generation, ")"],
-			}),
-			grid.map((row, i) =>
-				_jsx(
-					Text,
-					{
-						color: "green",
-						children: row.map((cell) => (cell ? "█" : " ")).join(""),
-					},
-					rowIds[i],
-				),
-			),
-			_jsx(Text, {
-				color: "gray",
-				italic: true,
-				children: "Start typing to begin...",
-			}),
-		],
-	});
+    const [grid, setGrid] = useState(createRandomGrid);
+    const [generation, setGeneration] = useState(0);
+    // Generate stable row IDs on mount
+    const rowIds = useState(() => Array.from({ length: ROWS }, (_, i) => `row-${i}`))[0];
+    useEffect(() => {
+        const interval = setInterval(() => {
+            setGrid((prevGrid) => nextGeneration(prevGrid));
+            setGeneration((prev) => prev + 1);
+        }, 150);
+        return () => clearInterval(interval);
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { color: "gray", italic: true, children: ["Conway's Game of Life (generation ", generation, ")"] }), grid.map((row, i) => (_jsx(Text, { color: "green", children: row.map((cell) => (cell ? "█" : " ")).join("") }, rowIds[i]))), _jsx(Text, { color: "gray", italic: true, children: "Start typing to begin..." })] }));
 }

package/dist/tui/components/InputBox.d.ts

@@ -1,20 +1,13 @@
 export interface InputBoxProps {
-	value: string;
-	isSubmitting: boolean;
-	attachedFiles: Array<{
-		name: string;
-		path: string;
-		size: number;
-	}>;
-	onChange: (value: string) => void;
-	onSubmit: () => void;
-	onEscape?: () => void;
+    value: string;
+    isSubmitting: boolean;
+    attachedFiles: Array<{
+        name: string;
+        path: string;
+        size: number;
+    }>;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+    onEscape?: () => void;
 }
-export declare function InputBox({
-	value,
-	isSubmitting,
-	attachedFiles,
-	onChange,
-	onSubmit,
-	onEscape,
-}: InputBoxProps): import("react/jsx-runtime").JSX.Element;
+export declare function InputBox({ value, isSubmitting, attachedFiles, onChange, onSubmit, onEscape, }: InputBoxProps): import("react/jsx-runtime").JSX.Element;