@townco/cli 0.1.19 → 0.1.21

package/dist/commands/run.js

@@ -1,16 +1,78 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { agentExists, getAgentPath } from "@townco/agent/storage";
-import { render } from "ink";
+import { createLogger } from "@townco/agent/utils";
+import { AcpClient } from "@townco/ui";
+import { ChatView } from "@townco/ui/tui";
+import { Box, render, Text } from "ink";
 import open from "open";
-import { useCallback, useMemo, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { LogsPane } from "../components/LogsPane.js";
 import { TabbedOutput } from "../components/TabbedOutput.js";
 import { findAvailablePort } from "../lib/port-utils.js";
-function GuiRunner({ agentProcess, guiProcess, agentPort, onExit, }) {
+function TuiRunner({ agentPath, workingDir, onExit }) {
+    const [client, setClient] = useState(null);
+    const [error, setError] = useState(null);
+    // Session start time for log filtering - set once when component mounts
+    const sessionStartTime = useMemo(() => {
+        const now = new Date();
+        now.setSeconds(now.getSeconds() - 1);
+        return now.toISOString();
+    }, []);
+    // Create logger with agent directory as logs location
+    const logger = useMemo(() => createLogger("tui", "debug", { silent: true, logsDir: workingDir }), [workingDir]);
+    useEffect(() => {
+        try {
+            logger.info("Creating ACP client", { agentPath, workingDir });
+            const newClient = new AcpClient({
+                type: "stdio",
+                options: {
+                    agentPath,
+                    workingDirectory: workingDir,
+                },
+            });
+            setClient(newClient);
+            return () => {
+                logger.debug("Disconnecting ACP client");
+                newClient.disconnect().catch((err) => {
+                    logger.error("Failed to disconnect client", { error: err });
+                });
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : "Failed to create ACP client";
+            logger.error("Failed to create ACP client", { error: errorMsg });
+            setError(errorMsg);
+            return undefined;
+        }
+    }, [agentPath, workingDir, logger]);
+    const customTabs = useMemo(() => [
+        {
+            name: "Chat",
+            type: "custom",
+            render: () => {
+                if (error) {
+                    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", error] }), _jsx(Text, { color: "gray", children: "Please check your agent path and try again." })] }));
+                }
+                if (!client) {
+                    return (_jsx(Box, { padding: 1, children: _jsx(Text, { dimColor: true, children: "Loading chat interface..." }) }));
+                }
+                return _jsx(ChatView, { client: client });
+            },
+        },
+        {
+            name: "Logs",
+            type: "custom",
+            render: () => (_jsx(LogsPane, { logsDir: join(workingDir, ".logs"), sessionStartTime: sessionStartTime })),
+        },
+    ], [client, error, workingDir, sessionStartTime]);
+    return (_jsx(TabbedOutput, { processes: [], customTabs: customTabs, onExit: onExit }));
+}
+function GuiRunner({ agentProcess, guiProcess, agentPort, agentPath, logger, onExit, }) {
     const browserOpenedRef = useRef(false);
     const handlePortDetected = useCallback((processIndex, port) => {
         // Process index 1 is the GUI process
@@ -19,13 +81,16 @@ function GuiRunner({ agentProcess, guiProcess, agentPort, onExit, }) {
             if (!browserOpenedRef.current) {
                 browserOpenedRef.current = true;
                 const guiUrl = `http://localhost:${port}`;
+                logger.info("Opening browser", { url: guiUrl });
                 open(guiUrl).catch((error) => {
-                    // Silently fail - user can open manually
-                    console.warn(`Could not automatically open browser: ${error.message}`);
+                    logger.warn("Could not automatically open browser", {
+                        error: error.message,
+                        url: guiUrl,
+                    });
                 });
             }
         }
-    }, []);
+    }, [logger]);
     // Memoize processes array based only on actual process objects and initial ports
     // Don't include guiPort as dependency to prevent re-creating array when port is detected
     // TabbedOutput will update the displayed port internally via onPortDetected callback
@@ -33,9 +98,9 @@ function GuiRunner({ agentProcess, guiProcess, agentPort, onExit, }) {
         { name: "Agent", process: agentProcess, port: agentPort },
         { name: "GUI", process: guiProcess }, // Port will be detected dynamically
     ], [agentProcess, guiProcess, agentPort]);
-    return (_jsx(TabbedOutput, { processes: processes, onExit: onExit, onPortDetected: handlePortDetected }));
+    return (_jsx(TabbedOutput, { processes: processes, logsDir: join(agentPath, ".logs"), onExit: onExit, onPortDetected: handlePortDetected }));
 }
-async function loadEnvVars() {
+async function loadEnvVars(logger) {
     const envPath = join(homedir(), ".config", "town", ".env");
     const envVars = {};
     if (!existsSync(envPath)) {
@@ -53,9 +118,16 @@ async function loadEnvVars() {
                 envVars[key.trim()] = value;
             }
         }
+        logger?.debug("Loaded environment variables", {
+            path: envPath,
+            count: Object.keys(envVars).length,
+        });
     }
-    catch (_error) {
-        console.warn(`Warning: Could not load environment variables from ${envPath}`);
+    catch (error) {
+        logger?.warn("Could not load environment variables", {
+            path: envPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
     }
     return envVars;
 }
@@ -72,6 +144,16 @@ export async function runCommand(options) {
     }
     const agentPath = getAgentPath(name);
     const binPath = join(agentPath, "bin.ts");
+    // Create logger with agent directory as logs location
+    const logger = createLogger("cli", "debug", {
+        silent: true,
+        logsDir: agentPath,
+    });
+    logger.info("Starting agent", {
+        name,
+        mode: gui ? "gui" : http ? "http" : "tui",
+        agentPath,
+    });
     // If GUI mode, run with tabbed interface
     if (gui) {
         const guiPath = join(agentPath, "gui");
@@ -81,6 +163,7 @@ export async function runCommand(options) {
             await stat(guiPath);
         }
         catch {
+            logger.error("GUI not found for agent", { name, guiPath });
             console.error(`Error: GUI not found for agent "${name}".`);
             console.log(`\nThe GUI was not bundled with this agent.`);
             console.log(`Recreate the agent with "town create" to include the GUI.`);
@@ -89,8 +172,16 @@ export async function runCommand(options) {
         // Find an available port for the agent
         const availablePort = await findAvailablePort(port);
         if (availablePort !== port) {
+            logger.info("Port in use, using alternative", {
+                requestedPort: port,
+                actualPort: availablePort,
+            });
             console.log(`Port ${port} is in use, using port ${availablePort} instead`);
         }
+        logger.info("Starting GUI mode", {
+            agentPort: availablePort,
+            guiPort: 5173,
+        });
         console.log(`Starting agent "${name}" with GUI...`);
         console.log(`Agent HTTP server will run on port ${availablePort}`);
         console.log(`GUI dev server will run on port 5173\n`);
@@ -120,7 +211,7 @@ export async function runCommand(options) {
             },
         });
         // Render the tabbed UI with dynamic port detection
-        const { waitUntilExit } = render(_jsx(GuiRunner, { agentProcess: agentProcess, guiProcess: guiProcess, agentPort: availablePort, onExit: () => {
+        const { waitUntilExit } = render(_jsx(GuiRunner, { agentProcess: agentProcess, guiProcess: guiProcess, agentPort: availablePort, agentPath: agentPath, logger: logger, onExit: () => {
                 agentProcess.kill();
                 guiProcess.kill();
             } }));
@@ -131,8 +222,13 @@ export async function runCommand(options) {
         // Find an available port for the agent
         const availablePort = await findAvailablePort(port);
         if (availablePort !== port) {
+            logger.info("Port in use, using alternative", {
+                requestedPort: port,
+                actualPort: availablePort,
+            });
             console.log(`Port ${port} is in use, using port ${availablePort} instead\n`);
         }
+        logger.info("Starting HTTP mode", { port: availablePort });
         console.log(`Starting agent "${name}" in HTTP mode on port ${availablePort}...`);
         console.log(`\nEndpoints:`);
         console.log(`  http://localhost:${availablePort}/health - Health check`);
@@ -150,11 +246,13 @@ export async function runCommand(options) {
             },
         });
         agentProcess.on("error", (error) => {
+            logger.error("Failed to start agent", { error: error.message });
             console.error(`Failed to start agent: ${error.message}`);
             process.exit(1);
         });
         agentProcess.on("close", (code) => {
             if (code !== 0 && code !== null) {
+                logger.error("Agent exited with error code", { code });
                 console.error(`Agent exited with code ${code}`);
                 process.exit(code);
             }
@@ -162,38 +260,15 @@ export async function runCommand(options) {
         return;
     }
     // Default: Start TUI interface with the agent
-    console.log(`Starting interactive terminal for agent "${name}"...\n`);
-    // Get path to TUI from agent's tui directory
-    const tuiPath = join(agentPath, "tui", "dist", "index.js");
-    // Check if TUI exists
-    try {
-        const { stat } = await import("node:fs/promises");
-        await stat(tuiPath);
-    }
-    catch {
-        console.error(`Error: TUI not found for agent "${name}".`);
-        console.log(`\nThe TUI was not bundled with this agent.`);
-        console.log(`Recreate the agent with "town create" to include the TUI.`);
-        process.exit(1);
+    logger.info("Starting TUI mode", { name, agentPath });
+    // Set stdin to raw mode for Ink
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
     }
-    // Run TUI with the agent
-    const tuiProcess = spawn("bun", [tuiPath, "--agent", binPath], {
-        cwd: agentPath,
-        stdio: "inherit",
-        env: {
-            ...process.env,
-            ...configEnvVars,
-            NODE_ENV: process.env.NODE_ENV || "production",
-        },
-    });
-    tuiProcess.on("error", (error) => {
-        console.error(`Failed to start TUI: ${error.message}`);
-        process.exit(1);
-    });
-    tuiProcess.on("close", (code) => {
-        if (code !== 0 && code !== null) {
-            console.error(`TUI exited with code ${code}`);
-            process.exit(code);
-        }
-    });
+    // Render the tabbed UI with Chat and Logs
+    const { waitUntilExit } = render(_jsx(TuiRunner, { agentPath: binPath, workingDir: agentPath, onExit: () => {
+            // Cleanup is handled by the ACP client disconnect
+        } }));
+    await waitUntilExit();
+    process.exit(0);
 }

package/dist/components/LogsPane.d.ts

@@ -0,0 +1,5 @@
+export interface LogsPaneProps {
+    logsDir?: string;
+    sessionStartTime?: string;
+}
+export declare function LogsPane({ logsDir: customLogsDir, sessionStartTime: providedSessionStartTime, }?: LogsPaneProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/LogsPane.js

@@ -0,0 +1,238 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useEffect, useMemo, useState } from "react";
+const LOG_COLORS = {
+    trace: "gray",
+    debug: "blue",
+    info: "green",
+    warn: "yellow",
+    error: "red",
+    fatal: "redBright",
+};
+const SERVICE_COLORS = ["cyan", "magenta", "blue", "green", "yellow"];
+// Fuzzy search: checks if query characters appear in order in the target string
+function fuzzyMatch(query, target) {
+    if (!query)
+        return true;
+    const lowerQuery = query.toLowerCase();
+    const lowerTarget = target.toLowerCase();
+    let queryIndex = 0;
+    for (let i = 0; i < lowerTarget.length && queryIndex < lowerQuery.length; i++) {
+        if (lowerTarget[i] === lowerQuery[queryIndex]) {
+            queryIndex++;
+        }
+    }
+    return queryIndex === lowerQuery.length;
+}
+export function LogsPane({ logsDir: customLogsDir, sessionStartTime: providedSessionStartTime, } = {}) {
+    const [logLines, setLogLines] = useState([]);
+    const [serviceFilter, setServiceFilter] = useState(null);
+    const [levelFilter, setLevelFilter] = useState(null);
+    const [availableServices, setAvailableServices] = useState([]);
+    const [scrollOffset, setScrollOffset] = useState(0); // 0 = at bottom, positive = scrolled up
+    const [searchMode, setSearchMode] = useState(false);
+    const [searchQuery, setSearchQuery] = useState("");
+    // Use provided session start time or default to 1 second before component mount
+    const sessionStartTime = useMemo(() => {
+        if (providedSessionStartTime)
+            return providedSessionStartTime;
+        const now = new Date();
+        now.setSeconds(now.getSeconds() - 1);
+        return now.toISOString();
+    }, [providedSessionStartTime]);
+    const logsDir = customLogsDir ?? join(process.cwd(), ".logs");
+    // Update available services based on logs from current session
+    useEffect(() => {
+        const servicesWithLogs = new Set(logLines.map((log) => log.service));
+        const newServices = Array.from(servicesWithLogs);
+        setAvailableServices(newServices);
+        // Clear service filter if the selected service is no longer available
+        if (serviceFilter && !newServices.includes(serviceFilter)) {
+            setServiceFilter(null);
+        }
+    }, [logLines, serviceFilter]);
+    // Tail all log files and merge output
+    useEffect(() => {
+        if (!existsSync(logsDir)) {
+            setLogLines([
+                {
+                    timestamp: new Date().toISOString(),
+                    level: "info",
+                    service: "logs",
+                    message: `No logs directory found at ${logsDir}`,
+                },
+            ]);
+            return;
+        }
+        const logFiles = readdirSync(logsDir).filter((f) => f.endsWith(".log"));
+        if (logFiles.length === 0) {
+            setLogLines([
+                {
+                    timestamp: new Date().toISOString(),
+                    level: "info",
+                    service: "logs",
+                    message: "No log files found. Logs will appear here once services start logging.",
+                },
+            ]);
+            return;
+        }
+        // Tail all log files (get last 50 lines, then follow)
+        const tailProcesses = logFiles.map((file) => {
+            const filePath = join(logsDir, file);
+            const tail = spawn("tail", ["-f", "-n", "50", filePath]);
+            tail.stdout.on("data", (data) => {
+                const lines = data
+                    .toString()
+                    .split("\n")
+                    .filter((line) => line.trim());
+                const entries = lines
+                    .map((line) => {
+                    try {
+                        const parsed = JSON.parse(line);
+                        return parsed;
+                    }
+                    catch {
+                        // If not JSON, create a simple entry
+                        return {
+                            timestamp: new Date().toISOString(),
+                            level: "info",
+                            service: file.replace(".log", ""),
+                            message: line,
+                            _raw: line,
+                        };
+                    }
+                })
+                    .filter((entry) => entry.timestamp >= sessionStartTime);
+                setLogLines((prev) => {
+                    const combined = [...prev, ...entries];
+                    // Sort by timestamp and keep last 200 entries
+                    const sorted = combined.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+                    return sorted.slice(-200);
+                });
+            });
+            return tail;
+        });
+        // Cleanup
+        return () => {
+            for (const tail of tailProcesses) {
+                tail.kill();
+            }
+        };
+    }, [logsDir, sessionStartTime]);
+    // Apply filters
+    const filteredLogs = logLines.filter((log) => {
+        if (serviceFilter && log.service !== serviceFilter) {
+            return false;
+        }
+        if (levelFilter) {
+            const levelOrder = [
+                "trace",
+                "debug",
+                "info",
+                "warn",
+                "error",
+                "fatal",
+            ];
+            const logLevelIndex = levelOrder.indexOf(log.level);
+            const filterLevelIndex = levelOrder.indexOf(levelFilter);
+            if (logLevelIndex < filterLevelIndex) {
+                return false;
+            }
+        }
+        return true;
+    });
+    // Handle keyboard input for filtering and scrolling
+    useInput((input, key) => {
+        // '/' to enter search mode
+        if (input === "/" && !searchMode) {
+            setSearchMode(true);
+            return;
+        }
+        // Escape to exit search mode or jump to bottom
+        if (key.escape) {
+            if (searchMode) {
+                setSearchMode(false);
+                setSearchQuery("");
+            }
+            else {
+                setScrollOffset(0);
+            }
+            return;
+        }
+        // Don't handle other inputs in search mode (let TextInput handle them)
+        if (searchMode) {
+            return;
+        }
+        // Up arrow to scroll up
+        if (key.upArrow) {
+            setScrollOffset((prev) => Math.min(prev + 1, Math.max(0, filteredLogs.length - 25)));
+            return;
+        }
+        // Down arrow to scroll down
+        if (key.downArrow) {
+            setScrollOffset((prev) => Math.max(prev - 1, 0));
+            return;
+        }
+        // 's' to cycle through service filters
+        if (input === "s") {
+            if (serviceFilter === null) {
+                setServiceFilter(availableServices[0] ?? null);
+            }
+            else {
+                const currentIndex = availableServices.indexOf(serviceFilter);
+                const nextIndex = (currentIndex + 1) % (availableServices.length + 1);
+                setServiceFilter(nextIndex === availableServices.length
+                    ? null
+                    : (availableServices[nextIndex] ?? null));
+            }
+        }
+        // 'l' to cycle through level filters
+        if (input === "l") {
+            const levels = [
+                null,
+                "debug",
+                "info",
+                "warn",
+                "error",
+                "fatal",
+            ];
+            const currentIndex = levelFilter === null ? 0 : levels.indexOf(levelFilter);
+            const nextIndex = (currentIndex + 1) % levels.length;
+            const nextLevel = levels[nextIndex];
+            setLevelFilter(nextLevel ?? null);
+        }
+        // 'c' to clear all filters, logs, and reset scroll
+        if (input === "c") {
+            setServiceFilter(null);
+            setLevelFilter(null);
+            setLogLines([]); // Clear the log buffer
+            setScrollOffset(0); // Also jump to bottom when clearing
+            return;
+        }
+    });
+    // Apply fuzzy search if active
+    const searchedLogs = searchQuery
+        ? filteredLogs.filter((log) => fuzzyMatch(searchQuery, log.message))
+        : filteredLogs;
+    // Calculate display window (25 lines) based on scroll position
+    const totalLogs = searchedLogs.length;
+    const maxLines = 25;
+    const isAtBottom = scrollOffset === 0;
+    // Calculate which slice of logs to show
+    const displayLogs = isAtBottom
+        ? searchedLogs.slice(-maxLines) // Show last 25 when at bottom
+        : searchedLogs.slice(Math.max(0, totalLogs - maxLines - scrollOffset), totalLogs - scrollOffset);
+    const canScrollUp = totalLogs > maxLines && scrollOffset < totalLogs - maxLines;
+    const canScrollDown = scrollOffset > 0;
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", borderStyle: "round", borderColor: "gray", children: [_jsxs(Box, { borderStyle: "single", borderBottom: true, borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { bold: true, children: ["Logs ", serviceFilter && `[${serviceFilter}]`, " ", levelFilter && `[>=${levelFilter}]`, searchQuery && _jsxs(Text, { color: "cyan", children: [" [SEARCH: ", searchQuery, "]"] }), !isAtBottom && _jsx(Text, { color: "yellow", children: " [SCROLLED]" })] }), _jsx(Text, { dimColor: true, children: "(/)search | (s)ervice | (l)evel | (c)lear | \u2191\u2193 | ESC" })] }), searchMode && (_jsxs(Box, { borderStyle: "single", borderBottom: true, borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { color: "cyan", children: "Search: " }), _jsx(TextInput, { value: searchQuery, onChange: setSearchQuery, placeholder: "Type to search..." }), _jsx(Text, { dimColor: true, children: " (ESC to exit)" })] })), _jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, flexGrow: 1, children: displayLogs.length === 0 ? (_jsx(Text, { dimColor: true, children: "No logs match the current filters. Press 'c' to clear filters." })) : (displayLogs.map((log, idx) => {
+                    const serviceColor = SERVICE_COLORS[availableServices.indexOf(log.service) % SERVICE_COLORS.length] || "white";
+                    const levelColor = LOG_COLORS[log.level] || "white";
+                    const time = new Date(log.timestamp).toLocaleTimeString();
+                    const keyStr = `${log.timestamp}-${idx}`;
+                    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: ["[", time, "]"] }), _jsxs(Text, { color: serviceColor, children: [" [", log.service, "]"] }), _jsxs(Text, { color: levelColor, children: [" [", log.level.toUpperCase(), "]"] }), _jsxs(Text, { children: [" ", log.message] })] }, keyStr));
+                })) }), totalLogs > 0 && (_jsxs(Box, { borderStyle: "single", borderTop: true, borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { dimColor: true, children: ["Showing ", displayLogs.length, " of ", totalLogs, " logs", searchQuery && ` (${totalLogs} matches)`, scrollOffset > 0 && ` (${scrollOffset} from bottom)`] }), totalLogs > maxLines && (_jsxs(Text, { dimColor: true, children: [canScrollUp && "↑ ", canScrollDown && "↓"] }))] }))] }));
+}

package/dist/components/MergedLogsPane.d.ts

@@ -0,0 +1,11 @@
+export interface ServiceOutput {
+    service: string;
+    output: string[];
+    port: number | undefined;
+    status: "starting" | "running" | "stopped" | "error";
+}
+export interface MergedLogsPaneProps {
+    services: ServiceOutput[];
+    onClear?: (serviceIndex: number) => void;
+}
+export declare function MergedLogsPane({ services, onClear }: MergedLogsPaneProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/MergedLogsPane.js

@@ -0,0 +1,201 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useEffect, useMemo, useState } from "react";
+const SERVICE_COLORS = ["cyan", "magenta", "blue", "green", "yellow"];
+const LOG_LEVELS = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+    fatal: 5,
+};
+// Parse log level from a line by looking for [LEVEL] markers
+function parseLogLevel(line) {
+    const match = line.match(/\[(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)\]/i);
+    if (match?.[1]) {
+        return match[1].toLowerCase();
+    }
+    return null;
+}
+// Fuzzy search: checks if query characters appear in order in the target string
+function fuzzyMatch(query, target) {
+    if (!query)
+        return true;
+    const lowerQuery = query.toLowerCase();
+    const lowerTarget = target.toLowerCase();
+    let queryIndex = 0;
+    for (let i = 0; i < lowerTarget.length && queryIndex < lowerQuery.length; i++) {
+        if (lowerTarget[i] === lowerQuery[queryIndex]) {
+            queryIndex++;
+        }
+    }
+    return queryIndex === lowerQuery.length;
+}
+export function MergedLogsPane({ services, onClear }) {
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [searchMode, setSearchMode] = useState(false);
+    const [searchQuery, setSearchQuery] = useState("");
+    const [serviceFilter, setServiceFilter] = useState(null);
+    const [levelFilter, setLevelFilter] = useState(null);
+    const maxLines = 25;
+    // Only include services that actually have output
+    const availableServices = useMemo(() => services.filter((s) => s.output.length > 0).map((s) => s.service), [services]);
+    // Clear service filter if the selected service is no longer available
+    useEffect(() => {
+        if (serviceFilter && !availableServices.includes(serviceFilter)) {
+            setServiceFilter(null);
+        }
+    }, [availableServices, serviceFilter]);
+    // Merge all outputs into a single array with service tags and parsed levels
+    const mergedLines = useMemo(() => {
+        const lines = [];
+        for (const [serviceIndex, service] of services.entries()) {
+            for (const [index, line] of service.output.entries()) {
+                lines.push({
+                    service: service.service,
+                    line,
+                    index,
+                    serviceIndex,
+                    level: parseLogLevel(line),
+                });
+            }
+        }
+        return lines;
+    }, [services]);
+    // Handle keyboard input
+    useInput((input, key) => {
+        // '/' to enter search mode
+        if (input === "/" && !searchMode) {
+            setSearchMode(true);
+            return;
+        }
+        // Escape to exit search mode or jump to bottom
+        if (key.escape) {
+            if (searchMode) {
+                setSearchMode(false);
+                setSearchQuery("");
+            }
+            else {
+                setScrollOffset(0);
+            }
+            return;
+        }
+        // Don't handle other inputs in search mode
+        if (searchMode) {
+            return;
+        }
+        // Up arrow to scroll up
+        if (key.upArrow) {
+            setScrollOffset((prev) => Math.min(prev + 1, Math.max(0, mergedLines.length - maxLines)));
+            return;
+        }
+        // Down arrow to scroll down
+        if (key.downArrow) {
+            setScrollOffset((prev) => Math.max(prev - 1, 0));
+            return;
+        }
+        // 's' to cycle through service filters
+        if (input === "s") {
+            if (serviceFilter === null) {
+                setServiceFilter(availableServices[0] ?? null);
+            }
+            else {
+                const currentIndex = availableServices.indexOf(serviceFilter);
+                const nextIndex = (currentIndex + 1) % (availableServices.length + 1);
+                setServiceFilter(nextIndex === availableServices.length
+                    ? null
+                    : (availableServices[nextIndex] ?? null));
+            }
+            return;
+        }
+        // 'l' to cycle through level filters
+        if (input === "l") {
+            const levels = [
+                null,
+                "debug",
+                "info",
+                "warn",
+                "error",
+                "fatal",
+            ];
+            const currentIndex = levelFilter === null ? 0 : levels.indexOf(levelFilter);
+            const nextIndex = (currentIndex + 1) % levels.length;
+            const nextLevel = levels[nextIndex];
+            setLevelFilter(nextLevel ?? null);
+            return;
+        }
+        // 'c' to clear all outputs
+        if (input === "c") {
+            if (onClear) {
+                // Clear all services
+                for (const [index] of services.entries()) {
+                    onClear(index);
+                }
+            }
+            setScrollOffset(0);
+            return;
+        }
+    });
+    // Apply service filter
+    const serviceFilteredLines = useMemo(() => {
+        if (!serviceFilter)
+            return mergedLines;
+        return mergedLines.filter((log) => log.service === serviceFilter);
+    }, [mergedLines, serviceFilter]);
+    // Apply level filter
+    const levelFilteredLines = useMemo(() => {
+        if (!levelFilter)
+            return serviceFilteredLines;
+        return serviceFilteredLines.filter((log) => {
+            if (!log.level)
+                return true; // Show lines without level info
+            const logLevelIndex = LOG_LEVELS[log.level];
+            const filterLevelIndex = LOG_LEVELS[levelFilter];
+            return logLevelIndex >= filterLevelIndex;
+        });
+    }, [serviceFilteredLines, levelFilter]);
+    // Apply fuzzy search
+    const searchedLines = useMemo(() => {
+        if (!searchQuery)
+            return levelFilteredLines;
+        return levelFilteredLines.filter((log) => fuzzyMatch(searchQuery, log.line));
+    }, [levelFilteredLines, searchQuery]);
+    const isAtBottom = scrollOffset === 0;
+    // Calculate which slice to show
+    const displayLines = useMemo(() => {
+        if (isAtBottom) {
+            return searchedLines.slice(-maxLines);
+        }
+        return searchedLines.slice(Math.max(0, searchedLines.length - maxLines - scrollOffset), searchedLines.length - scrollOffset);
+    }, [searchedLines, scrollOffset, isAtBottom]);
+    const canScrollUp = searchedLines.length > maxLines &&
+        scrollOffset < searchedLines.length - maxLines;
+    const canScrollDown = scrollOffset > 0;
+    // Get overall status (error if any error, stopped if all stopped, etc.)
+    const overallStatus = useMemo(() => {
+        if (services.some((s) => s.status === "error"))
+            return "error";
+        if (services.every((s) => s.status === "stopped"))
+            return "stopped";
+        if (services.some((s) => s.status === "running"))
+            return "running";
+        return "starting";
+    }, [services]);
+    const statusColor = overallStatus === "running"
+        ? "green"
+        : overallStatus === "error"
+            ? "red"
+            : overallStatus === "starting"
+                ? "yellow"
+                : "gray";
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsxs(Box, { borderStyle: "single", paddingX: 1, marginBottom: 1, flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: ["Logs ", serviceFilter && `[${serviceFilter}]`, levelFilter && ` [>=${levelFilter}]`, searchQuery && _jsxs(Text, { color: "cyan", children: [" [SEARCH: ", searchQuery, "]"] }), !isAtBottom && _jsx(Text, { color: "yellow", children: " [SCROLLED]" })] }), _jsx(Text, { children: " " }), _jsx(Text, { color: statusColor, children: "\u25CF" }), _jsxs(Text, { children: [" ", overallStatus] })] }), _jsx(Text, { dimColor: true, children: "(/)search | (s)ervice | (l)evel | \u2191\u2193 | (c)lear | ESC" })] }), searchMode && (_jsxs(Box, { borderStyle: "single", borderBottom: true, borderColor: "cyan", paddingX: 1, marginBottom: 1, flexShrink: 0, children: [_jsx(Text, { color: "cyan", children: "Search: " }), _jsx(TextInput, { value: searchQuery, onChange: setSearchQuery, placeholder: "Type to search..." }), _jsx(Text, { dimColor: true, children: " (ESC to exit)" })] })), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, paddingX: 1, children: displayLines.length === 0 ? (_jsx(Text, { dimColor: true, children: searchQuery || serviceFilter || levelFilter
+                        ? "No logs match the current filters. Press 'c' to clear, 's' for service, or 'l' for level."
+                        : "Waiting for output..." })) : (displayLines.map((logLine, idx) => {
+                    const serviceColor = SERVICE_COLORS[availableServices.indexOf(logLine.service) %
+                        SERVICE_COLORS.length] || "white";
+                    const keyStr = `${logLine.service}-${logLine.serviceIndex}-${logLine.index}-${idx}`;
+                    return (_jsxs(Box, { children: [_jsxs(Text, { color: serviceColor, children: ["[", logLine.service, "]"] }), _jsxs(Text, { children: [" ", logLine.line] })] }, keyStr));
+                })) }), _jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Text, { dimColor: true, children: ["Showing ", displayLines.length, " of ", searchedLines.length, " lines", searchQuery && ` (${searchedLines.length} matches)`, scrollOffset > 0 && ` (${scrollOffset} from bottom)`] }), searchedLines.length > maxLines && (_jsxs(Text, { dimColor: true, children: [canScrollUp && "↑ ", canScrollDown && "↓"] }))] })] }));
+}

package/dist/components/ProcessPane.d.ts

@@ -3,5 +3,6 @@ export interface ProcessPaneProps {
     output: string[];
     port: number | undefined;
     status: "starting" | "running" | "stopped" | "error";
+    onClear?: () => void;
 }
-export declare function ProcessPane({ title, output, port, status }: ProcessPaneProps): import("react/jsx-runtime").JSX.Element;
+export declare function ProcessPane({ title, output, port, status, onClear, }: ProcessPaneProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ProcessPane.js

@@ -1,11 +1,85 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { useMemo } from "react";
-export function ProcessPane({ title, output, port, status }) {
-    // Keep only last 50 lines to prevent memory issues
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useMemo, useState } from "react";
+// Fuzzy search: checks if query characters appear in order in the target string
+function fuzzyMatch(query, target) {
+    if (!query)
+        return true;
+    const lowerQuery = query.toLowerCase();
+    const lowerTarget = target.toLowerCase();
+    let queryIndex = 0;
+    for (let i = 0; i < lowerTarget.length && queryIndex < lowerQuery.length; i++) {
+        if (lowerTarget[i] === lowerQuery[queryIndex]) {
+            queryIndex++;
+        }
+    }
+    return queryIndex === lowerQuery.length;
+}
+export function ProcessPane({ title, output, port, status, onClear, }) {
+    const [scrollOffset, setScrollOffset] = useState(0); // 0 = at bottom, positive = scrolled up
+    const [searchMode, setSearchMode] = useState(false);
+    const [searchQuery, setSearchQuery] = useState("");
+    const maxLines = 25;
+    // Handle keyboard input for scrolling, clearing, and search
+    useInput((input, key) => {
+        // '/' to enter search mode
+        if (input === "/" && !searchMode) {
+            setSearchMode(true);
+            return;
+        }
+        // Escape to exit search mode or jump to bottom
+        if (key.escape) {
+            if (searchMode) {
+                setSearchMode(false);
+                setSearchQuery("");
+            }
+            else {
+                setScrollOffset(0);
+            }
+            return;
+        }
+        // Don't handle other inputs in search mode (let TextInput handle them)
+        if (searchMode) {
+            return;
+        }
+        // Up arrow to scroll up
+        if (key.upArrow) {
+            setScrollOffset((prev) => Math.min(prev + 1, Math.max(0, output.length - maxLines)));
+            return;
+        }
+        // Down arrow to scroll down
+        if (key.downArrow) {
+            setScrollOffset((prev) => Math.max(prev - 1, 0));
+            return;
+        }
+        // 'c' to clear output
+        if (input === "c") {
+            if (onClear) {
+                onClear();
+            }
+            setScrollOffset(0);
+            return;
+        }
+    });
+    const isAtBottom = scrollOffset === 0;
+    // Apply fuzzy search if active
+    const searchedOutput = useMemo(() => {
+        if (!searchQuery)
+            return output;
+        return output.filter((line) => fuzzyMatch(searchQuery, line));
+    }, [output, searchQuery]);
+    // Calculate which slice of output to show
     const displayOutput = useMemo(() => {
-        return output.slice(-50);
-    }, [output]);
+        const source = searchedOutput;
+        if (isAtBottom) {
+            return source.slice(-maxLines); // Show last 25 when at bottom
+        }
+        return source.slice(Math.max(0, source.length - maxLines - scrollOffset), source.length - scrollOffset);
+    }, [searchedOutput, scrollOffset, isAtBottom]);
+    const canScrollUp = searchedOutput.length > maxLines &&
+        scrollOffset < searchedOutput.length - maxLines;
+    const canScrollDown = scrollOffset > 0;
     const statusColor = status === "running"
         ? "green"
         : status === "error"
@@ -13,5 +87,5 @@ export function ProcessPane({ title, output, port, status }) {
             : status === "starting"
                 ? "yellow"
                 : "gray";
-    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsxs(Box, { borderStyle: "single", paddingX: 1, marginBottom: 1, flexShrink: 0, children: [_jsx(Text, { color: "cyan", bold: true, children: title }), port && _jsxs(Text, { color: "gray", children: [" - http://localhost:", port] }), _jsx(Text, { children: " " }), _jsx(Text, { color: statusColor, children: "\u25CF" }), _jsxs(Text, { children: [" ", status] })] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, paddingX: 1, children: displayOutput.length === 0 ? (_jsx(Text, { color: "gray", children: "Waiting for output..." })) : (displayOutput.map((line, idx) => (_jsx(Text, { children: line }, `${idx}-${line.slice(0, 20)}`)))) }), _jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexShrink: 0, children: _jsxs(Text, { color: "gray", children: ["Lines: ", output.length, " | Displaying last ", displayOutput.length] }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsxs(Box, { borderStyle: "single", paddingX: 1, marginBottom: 1, flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: title }), port && _jsxs(Text, { color: "gray", children: [" - http://localhost:", port] }), _jsx(Text, { children: " " }), _jsx(Text, { color: statusColor, children: "\u25CF" }), _jsxs(Text, { children: [" ", status] }), searchQuery && _jsxs(Text, { color: "cyan", children: [" [SEARCH: ", searchQuery, "]"] }), !isAtBottom && _jsx(Text, { color: "yellow", children: " [SCROLLED]" })] }), _jsx(Text, { color: "gray", children: "(/)search | \u2191\u2193 | (c)lear | ESC" })] }), searchMode && (_jsxs(Box, { borderStyle: "single", borderBottom: true, borderColor: "cyan", paddingX: 1, marginBottom: 1, flexShrink: 0, children: [_jsx(Text, { color: "cyan", children: "Search: " }), _jsx(TextInput, { value: searchQuery, onChange: setSearchQuery, placeholder: "Type to search..." }), _jsx(Text, { dimColor: true, children: " (ESC to exit)" })] })), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, paddingX: 1, children: displayOutput.length === 0 ? (_jsx(Text, { color: "gray", children: "Waiting for output..." })) : (displayOutput.map((line, idx) => (_jsx(Text, { children: line }, `${idx}-${line.slice(0, 20)}`)))) }), _jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Text, { color: "gray", children: ["Showing ", displayOutput.length, " of ", searchedOutput.length, " lines", searchQuery && ` (${searchedOutput.length} matches)`, scrollOffset > 0 && ` (${scrollOffset} from bottom)`] }), searchedOutput.length > maxLines && (_jsxs(Text, { color: "gray", children: [canScrollUp && "↑ ", canScrollDown && "↓"] }))] })] }));
 }

package/dist/components/StatusLine.js

@@ -1,5 +1,5 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 export function StatusLine({ activeTab, tabs }) {
-    return (_jsxs(Box, { borderStyle: "single", borderColor: "blue", paddingX: 1, children: [tabs.map((tab, idx) => (_jsxs(Text, { children: [_jsxs(Text, { color: activeTab === idx ? "green" : "gray", children: [idx + 1, ". ", tab] }), idx < tabs.length - 1 && _jsx(Text, { color: "gray", children: " | " })] }, tab))), _jsx(Text, { color: "gray", children: " | " }), _jsx(Text, { color: "yellow", children: "tab" }), _jsx(Text, { color: "gray", children: ", " }), _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), _jsx(Text, { color: "gray", children: " or " }), _jsxs(Text, { color: "yellow", children: ["1-", tabs.length] }), _jsx(Text, { color: "gray", children: " to switch" })] }));
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "blue", paddingX: 1, children: [tabs.map((tab, idx) => (_jsxs(Text, { children: [_jsx(Text, { color: activeTab === idx ? "green" : "gray", children: tab }), idx < tabs.length - 1 && _jsx(Text, { color: "gray", children: " | " })] }, tab))), _jsx(Text, { color: "gray", children: " | " }), _jsx(Text, { color: "yellow", children: "tab" }), _jsx(Text, { color: "gray", children: " or " }), _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), _jsx(Text, { color: "gray", children: " to switch" })] }));
 }

package/dist/components/TabbedOutput.d.ts

@@ -1,12 +1,21 @@
 import type { ChildProcess } from "node:child_process";
+import type React from "react";
 export interface ProcessInfo {
     name: string;
     process: ChildProcess;
     port?: number;
 }
+export interface CustomTabInfo {
+    name: string;
+    type: "custom";
+    render: () => React.ReactNode;
+}
+export type TabInfo = ProcessInfo | CustomTabInfo;
 export interface TabbedOutputProps {
     processes: ProcessInfo[];
+    customTabs?: CustomTabInfo[];
+    logsDir?: string;
     onExit: () => void;
     onPortDetected?: (processIndex: number, port: number) => void;
 }
-export declare function TabbedOutput({ processes, onExit, onPortDetected, }: TabbedOutputProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function TabbedOutput({ processes, customTabs, logsDir, onExit, onPortDetected, }: TabbedOutputProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/TabbedOutput.js

@@ -1,15 +1,36 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
 import { Box, useApp, useInput } from "ink";
 import { useEffect, useRef, useState } from "react";
+import { MergedLogsPane } from "./MergedLogsPane.js";
 import { ProcessPane } from "./ProcessPane.js";
 import { StatusLine } from "./StatusLine.js";
-export function TabbedOutput({ processes, onExit, onPortDetected, }) {
+function isProcessTab(tab) {
+    return "process" in tab;
+}
+function isCustomTab(tab) {
+    return "type" in tab && tab.type === "custom";
+}
+export function TabbedOutput({ processes, customTabs = [], logsDir, onExit, onPortDetected, }) {
     const { exit } = useApp();
+    const allTabs = [...processes, ...customTabs];
     const [activeTab, setActiveTab] = useState(0);
     const [outputs, setOutputs] = useState(processes.map(() => []));
     const [statuses, setStatuses] = useState(processes.map(() => "starting"));
     const [ports, setPorts] = useState(processes.map((p) => p.port));
     const portDetectedRef = useRef(new Set());
+    // Ensure logs directory exists if provided
+    useEffect(() => {
+        if (logsDir && !existsSync(logsDir)) {
+            try {
+                mkdirSync(logsDir, { recursive: true });
+            }
+            catch (error) {
+                console.error("Failed to create logs directory:", error);
+            }
+        }
+    }, [logsDir]);
     // Handle keyboard input
     useInput((input, key) => {
         if (key.ctrl && input === "c") {
@@ -20,20 +41,15 @@ export function TabbedOutput({ processes, onExit, onPortDetected, }) {
         }
         // Tab key to toggle between tabs
         if (key.tab) {
-            setActiveTab((activeTab + 1) % processes.length);
+            setActiveTab((activeTab + 1) % allTabs.length);
             return;
         }
         if (key.leftArrow && activeTab > 0) {
             setActiveTab(activeTab - 1);
         }
-        else if (key.rightArrow && activeTab < processes.length - 1) {
+        else if (key.rightArrow && activeTab < allTabs.length - 1) {
             setActiveTab(activeTab + 1);
         }
-        // Number keys to jump to tabs
-        const num = Number.parseInt(input, 10);
-        if (!Number.isNaN(num) && num >= 1 && num <= processes.length) {
-            setActiveTab(num - 1);
-        }
     });
     // Set up process output listeners
     useEffect(() => {
@@ -59,6 +75,23 @@ export function TabbedOutput({ processes, onExit, onPortDetected, }) {
                     return newOutputs;
                 });
                 markAsRunning();
+                // Write to log file if logsDir is provided
+                if (logsDir) {
+                    const logFile = join(logsDir, `${processInfo.name.toLowerCase()}.log`);
+                    try {
+                        const timestamp = new Date().toISOString();
+                        const logEntry = JSON.stringify({
+                            timestamp,
+                            level: "info",
+                            service: processInfo.name.toLowerCase(),
+                            message: output.trim(),
+                        });
+                        appendFileSync(logFile, `${logEntry}\n`, "utf-8");
+                    }
+                    catch (error) {
+                        console.error("Failed to write to log file:", error);
+                    }
+                }
                 // Check for Vite port in output and notify if callback provided
                 if (onPortDetected && !portDetectedRef.current.has(idx)) {
                     const portMatch = output.match(/Local:\s+http:\/\/localhost:(\d+)/);
@@ -86,6 +119,23 @@ export function TabbedOutput({ processes, onExit, onPortDetected, }) {
                     return newOutputs;
                 });
                 markAsRunning();
+                // Write to log file if logsDir is provided
+                if (logsDir) {
+                    const logFile = join(logsDir, `${processInfo.name.toLowerCase()}.log`);
+                    try {
+                        const timestamp = new Date().toISOString();
+                        const logEntry = JSON.stringify({
+                            timestamp,
+                            level: "error",
+                            service: processInfo.name.toLowerCase(),
+                            message: text.trim(),
+                        });
+                        appendFileSync(logFile, `${logEntry}\n`, "utf-8");
+                    }
+                    catch (error) {
+                        console.error("Failed to write to log file:", error);
+                    }
+                }
             });
             // Handle process exit
             process.on("close", (code) => {
@@ -127,10 +177,36 @@ export function TabbedOutput({ processes, onExit, onPortDetected, }) {
                 process.kill();
             });
         };
-    }, [processes, onPortDetected]);
-    const currentProcess = processes[activeTab];
-    if (!currentProcess) {
+    }, [processes, onPortDetected, logsDir]);
+    const currentTab = allTabs[activeTab];
+    if (!currentTab) {
         return null;
     }
-    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(StatusLine, { activeTab: activeTab, tabs: processes.map((p) => p.name) }), _jsx(ProcessPane, { title: currentProcess.name, output: outputs[activeTab] || [], port: ports[activeTab], status: statuses[activeTab] || "starting" })] }));
+    const handleClearOutput = () => {
+        setOutputs((prev) => {
+            const newOutputs = [...prev];
+            newOutputs[activeTab] = [];
+            return newOutputs;
+        });
+    };
+    const handleClearMergedOutput = (serviceIndex) => {
+        setOutputs((prev) => {
+            const newOutputs = [...prev];
+            newOutputs[serviceIndex] = [];
+            return newOutputs;
+        });
+    };
+    // GUI mode: only process tabs, no custom tabs - use merged logs view
+    const isGuiMode = customTabs.length === 0 && processes.length > 0;
+    if (isGuiMode) {
+        const serviceOutputs = processes.map((proc, idx) => ({
+            service: proc.name,
+            output: outputs[idx] || [],
+            port: ports[idx],
+            status: statuses[idx] || "starting",
+        }));
+        return (_jsx(Box, { flexDirection: "column", height: "100%", children: _jsx(MergedLogsPane, { services: serviceOutputs, onClear: handleClearMergedOutput }) }));
+    }
+    // TUI mode: has custom tabs - use tabbed interface
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(StatusLine, { activeTab: activeTab, tabs: allTabs.map((t) => t.name) }), isProcessTab(currentTab) ? (_jsx(ProcessPane, { title: currentTab.name, output: outputs[activeTab] || [], port: ports[activeTab], status: statuses[activeTab] || "starting", onClear: handleClearOutput })) : isCustomTab(currentTab) ? (currentTab.render()) : null] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -18,16 +18,16 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.11",
+    "@townco/tsconfig": "0.1.13",
     "@types/bun": "^1.3.1",
     "@types/react": "^19.2.2"
   },
   "dependencies": {
     "@optique/core": "^0.6.2",
     "@optique/run": "^0.6.2",
-    "@townco/agent": "0.1.19",
-    "@townco/secret": "0.1.14",
-    "@townco/ui": "0.1.14",
+    "@townco/agent": "0.1.21",
+    "@townco/secret": "0.1.16",
+    "@townco/ui": "0.1.16",
     "@types/inquirer": "^9.0.9",
     "ink": "^6.4.0",
     "ink-text-input": "^6.0.0",