@townco/cli 0.1.108 → 0.1.110

package/dist/commands/run.js

@@ -144,7 +144,7 @@ async function loadEnvVars(projectRoot, logger) {
 }
 // CLI mode runner - outputs directly to stdout without React UI
 async function runCliMode(options) {
-    const { binPath, workingDir, prompt, configEnvVars, noSession, waitForDebugger = false, } = options;
+    const { binPath, workingDir, prompt, configEnvVars, noSession, waitForDebugger = false, logger, } = options;
     // Wait for debugger to be ready BEFORE starting agent
     if (waitForDebugger) {
         let debuggerReady = false;
@@ -174,7 +174,14 @@ async function runCliMode(options) {
     // Ensure port is available
     const { ensurePortAvailable } = await import("../lib/port-utils.js");
     const agentPort = 3100;
-    await ensurePortAvailable(agentPort, "agent HTTP server");
+    try {
+        await ensurePortAvailable(agentPort, "agent HTTP server");
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error("Port check failed", { error: errorMessage });
+        throw error;
+    }
     // Spawn agent process with HTTP mode
     const agentProcess = spawn("bun", [binPath, "http"], {
         cwd: workingDir,
@@ -377,6 +384,10 @@ export async function runCommand(options) {
             "to create a project.");
         process.exit(1);
     }
+    // Configure logs directory and create logger early so all errors can be logged
+    const logsDir = join(projectRoot, "agents", name, ".logs");
+    configureLogsDir(logsDir);
+    const logger = createLogger("cli", "debug");
     // Load environment variables from project .env
     const configEnvVars = await loadEnvVars(projectRoot);
     // Resolve agent path to load agent definition
@@ -409,17 +420,42 @@ export async function runCommand(options) {
     // Check debugger ports are available before starting
     const debuggerUiPort = 4000;
     const debuggerOtlpPort = 4318;
-    await ensurePortAvailable(debuggerUiPort, "debugger UI");
-    await ensurePortAvailable(debuggerOtlpPort, "OTLP collector");
+    try {
+        await ensurePortAvailable(debuggerUiPort, "debugger UI");
+        await ensurePortAvailable(debuggerOtlpPort, "OTLP collector");
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error("Port check failed", { error: errorMessage });
+        throw error;
+    }
     debuggerProcess = spawn("bun", ["src/index.ts"], {
         cwd: debuggerDir,
-        stdio: cli ? "ignore" : "inherit", // Silent in CLI mode
+        stdio: cli ? ["ignore", "ignore", "pipe"] : "inherit", // Pipe stderr in CLI mode to capture errors
         env: {
             ...process.env,
             DB_PATH: join(projectRoot, "agents", name, ".traces.db"),
             AGENT_NAME: agentDisplayName,
         },
     });
+    // Log debugger stderr to capture any startup errors (e.g., port binding failures)
+    if (cli && debuggerProcess.stderr) {
+        debuggerProcess.stderr.on("data", (data) => {
+            const text = data.toString().trim();
+            if (text) {
+                logger.error("Debugger error", { stderr: text });
+            }
+        });
+    }
+    // Handle debugger process errors
+    debuggerProcess.on("error", (error) => {
+        logger.error("Debugger process error", { error: error.message });
+    });
+    debuggerProcess.on("exit", (code, signal) => {
+        if (code !== null && code !== 0) {
+            logger.error("Debugger process exited with error", { code, signal });
+        }
+    });
     if (!cli) {
         console.log(`Debugger UI: http://localhost:${debuggerUiPort}`);
     }
@@ -454,8 +490,6 @@ export async function runCommand(options) {
         process.exit(1);
     }
     const binPath = join(agentPath, "bin.ts");
-    // Create logger with agent directory as logs location
-    const logger = createLogger("cli", "debug");
     logger.info("Starting agent", {
         name,
         mode: gui ? "gui" : http ? "http" : cli ? "cli" : "tui",
@@ -478,8 +512,15 @@ export async function runCommand(options) {
         }
         // Ensure agent and GUI ports are available (debugger ports already checked above)
         const guiPort = 5173;
-        await ensurePortAvailable(port, "agent HTTP server");
-        await ensurePortAvailable(guiPort, "GUI dev server");
+        try {
+            await ensurePortAvailable(port, "agent HTTP server");
+            await ensurePortAvailable(guiPort, "GUI dev server");
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error("Port check failed", { error: errorMessage });
+            throw error;
+        }
         logger.info("Starting GUI mode", {
             agentPort: port,
             guiPort,
@@ -545,6 +586,16 @@ export async function runCommand(options) {
             catch (_e) {
                 // Process may already be dead
             }
+            // Kill any remaining process on port 5173 (Vite server)
+            try {
+                const { spawnSync } = require("node:child_process");
+                spawnSync("sh", ["-c", "lsof -ti:5173 | xargs kill -9 2>/dev/null || true"], {
+                    stdio: "ignore",
+                });
+            }
+            catch (_e) {
+                // Ignore errors
+            }
             // Also cleanup debugger
             cleanupDebugger?.();
         };
@@ -572,7 +623,14 @@ export async function runCommand(options) {
     }
     else if (http) {
         // Ensure agent port is available (debugger ports already checked above)
-        await ensurePortAvailable(port, "agent HTTP server");
+        try {
+            await ensurePortAvailable(port, "agent HTTP server");
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error("Port check failed", { error: errorMessage });
+            throw error;
+        }
         logger.info("Starting HTTP mode", { port });
         console.log(`Starting agent "${name}" in HTTP mode on port ${port}...`);
         console.log(`\nEndpoints:`);
@@ -648,6 +706,7 @@ export async function runCommand(options) {
             configEnvVars,
             noSession,
             waitForDebugger: true, // Wait for debugger to be ready before starting agent
+            logger,
         });
         // Agent has exited cleanly, now cleanup debugger
         if (cleanupDebugger) {

package/dist/components/LogsPane.js

@@ -1,21 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { LOG_FILE_NAME } from "@townco/core";
-import { Box, Text, useInput } from "ink";
-import TextInput from "ink-text-input";
+import { Box, Static, Text, useInput } from "ink";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-const LOG_LEVELS = [
-    "all",
-    "debug",
-    "info",
-    "warn",
-    "error",
-    "fatal",
-];
-// Max lines to keep in buffer
-const MAX_LINES = 1000;
+const LOG_LEVELS = ["all", "info", "warn", "error"];
 function buildCommand(logsDir, pretty, level, sessionStartTime) {
     const logFile = join(logsDir, LOG_FILE_NAME);
     const tailCmd = `tail -n +1 -f "${logFile}"`;
@@ -23,13 +13,8 @@ function buildCommand(logsDir, pretty, level, sessionStartTime) {
     const conditions = [];
     conditions.push(`.timestamp >= "${sessionStartTime}"`);
     if (level !== "all") {
-        const levelOrder = ["debug", "info", "warn", "error", "fatal"];
-        const levelIndex = levelOrder.indexOf(level);
-        const allowedLevels = levelOrder.slice(levelIndex);
-        const levelCondition = allowedLevels
-            .map((l) => `.level == "${l}"`)
-            .join(" or ");
-        conditions.push(`(${levelCondition})`);
+        // Filter to exact level only
+        conditions.push(`.level == "${level}"`);
     }
     const jqFilter = `select(${conditions.join(" and ")})`;
     const jqFlags = pretty ? "-C --unbuffered" : "-c --unbuffered";
@@ -37,41 +22,36 @@ function buildCommand(logsDir, pretty, level, sessionStartTime) {
 }
 export function LogsPane({ logsDir: customLogsDir } = {}) {
     const logsDir = useMemo(() => customLogsDir ?? join(process.cwd(), ".logs"), [customLogsDir]);
-    const sessionStartTime = useMemo(() => new Date().toISOString(), []);
+    const [sessionStartTime, setSessionStartTime] = useState(() => new Date().toISOString());
     const [pretty, setPretty] = useState(true);
     const [level, setLevel] = useState("all");
-    const [editMode, setEditMode] = useState(false);
-    const [customCommand, setCustomCommand] = useState("");
     const [outputLines, setOutputLines] = useState([]);
     const [error, setError] = useState(null);
-    const [terminalHeight, setTerminalHeight] = useState(process.stdout.rows ?? 30);
     const processRef = useRef(null);
     const commandRunIdRef = useRef(0);
-    const activeCommand = useMemo(() => editMode
-        ? customCommand
-        : buildCommand(logsDir, pretty, level, sessionStartTime), [editMode, customCommand, logsDir, pretty, level, sessionStartTime]);
-    // Track terminal resize
-    useEffect(() => {
-        const handleResize = () => setTerminalHeight(process.stdout.rows ?? 30);
-        process.stdout.on("resize", handleResize);
-        return () => {
-            process.stdout.off("resize", handleResize);
-        };
-    }, []);
+    const lineIdRef = useRef(0);
+    const activeCommand = useMemo(() => buildCommand(logsDir, pretty, level, sessionStartTime), [logsDir, pretty, level, sessionStartTime]);
     // Spawn tail process
     useEffect(() => {
+        // Create logs directory if it doesn't exist
         if (!existsSync(logsDir)) {
-            setError(`Logs directory not found: ${logsDir}`);
-            return;
+            try {
+                mkdirSync(logsDir, { recursive: true });
+            }
+            catch (_error) {
+                setError(`Failed to create logs directory: ${logsDir}`);
+                return;
+            }
         }
         if (processRef.current) {
             processRef.current.kill();
             processRef.current = null;
         }
-        // Clear output when command changes
+        // Clear output and reset line counter when command changes
         setOutputLines([]);
+        lineIdRef.current = 0;
         const runId = ++commandRunIdRef.current;
-        const timeoutId = setTimeout(() => {
+        const commandTimeoutId = setTimeout(() => {
             if (runId !== commandRunIdRef.current)
                 return;
             const proc = spawn("sh", ["-c", activeCommand], {
@@ -83,14 +63,21 @@ export function LogsPane({ logsDir: customLogsDir } = {}) {
                 if (runId !== commandRunIdRef.current)
                     return;
                 const lines = data.toString().split("\n").filter(Boolean);
-                setOutputLines((prev) => [...prev, ...lines].slice(-MAX_LINES));
+                const newLines = lines.map((text) => ({
+                    id: ++lineIdRef.current,
+                    text,
+                }));
+                setOutputLines((prev) => [...prev, ...newLines]);
             });
             proc.stderr?.on("data", (data) => {
                 if (runId !== commandRunIdRef.current)
                     return;
                 const text = data.toString().trim();
                 if (text && !text.includes("parse error")) {
-                    setOutputLines((prev) => [...prev, `[stderr] ${text}`].slice(-MAX_LINES));
+                    setOutputLines((prev) => [
+                        ...prev,
+                        { id: ++lineIdRef.current, text: `[stderr] ${text}` },
+                    ]);
                 }
             });
             proc.on("error", (err) => {
@@ -100,7 +87,7 @@ export function LogsPane({ logsDir: customLogsDir } = {}) {
             });
         }, 50);
         return () => {
-            clearTimeout(timeoutId);
+            clearTimeout(commandTimeoutId);
             if (processRef.current) {
                 processRef.current.kill();
                 processRef.current = null;
@@ -110,27 +97,17 @@ export function LogsPane({ logsDir: customLogsDir } = {}) {
     const handleInput = useCallback((input, key) => {
         if (key.ctrl && input === "c")
             return;
-        if (editMode) {
-            if (key.escape) {
-                setEditMode(false);
-                return;
-            }
-            if (key.return) {
-                setEditMode(false);
-                return;
-            }
-            return;
-        }
-        if (input === "e") {
-            setCustomCommand(activeCommand);
-            setEditMode(true);
-            return;
-        }
+        // Helper to clear terminal before state changes
+        const clearTerminal = () => {
+            process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+        };
         if (input === "f") {
+            clearTerminal();
             setPretty((prev) => !prev);
             return;
         }
         if (input === "l") {
+            clearTerminal();
             setLevel((prev) => {
                 const currentIndex = LOG_LEVELS.indexOf(prev);
                 const nextIndex = (currentIndex + 1) % LOG_LEVELS.length;
@@ -139,27 +116,24 @@ export function LogsPane({ logsDir: customLogsDir } = {}) {
             return;
         }
         if (input === "c" && !key.ctrl) {
-            setOutputLines([]);
+            // Clear terminal and update timestamp to only show new logs
+            clearTerminal();
+            setSessionStartTime(new Date().toISOString());
             return;
         }
-    }, [editMode, activeCommand]);
+    }, []);
     useInput(handleInput);
     if (error) {
         return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsx(Text, { color: "red", children: error }) }));
     }
-    // Calculate visible lines based on terminal height
-    // Reserve: footer (4 lines) + status bar (3 lines) + padding
-    const visibleLines = Math.max(5, terminalHeight - 10);
-    const displayLines = outputLines.slice(-visibleLines);
-    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [
-            _jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: displayLines.length === 0 ? (_jsx(Text, { dimColor: true, children: "Waiting for logs..." })) : (displayLines.map((line, idx) => (_jsx(Text, { children: line }, `${idx}-${line.slice(0, 20)}`)))) }), _jsxs(Box, { borderStyle: "single", borderTop: true, borderColor: "gray", paddingX: 1, flexDirection: "column", flexShrink: 0, children: [editMode ? (_jsxs(Box, { children: [
-                            _jsx(Text, { color: "cyan", children: "$ " }), _jsx(TextInput, { value: customCommand, onChange: setCustomCommand, placeholder: "Enter command..." }), _jsx(Text, { dimColor: true, children: " (Enter to apply, Esc to cancel)" })
-                        ] })) : (_jsxs(Box, { children: [
+    return (_jsxs(Box, { flexDirection: "column", children: [
+            _jsx(Static, { items: outputLines, children: (line) => _jsx(Text, { children: line.text }, line.id) }), outputLines.length === 0 && _jsx(Text, { dimColor: true, children: "Waiting for logs..." }), _jsxs(Box, { borderStyle: "single", borderTop: true, borderColor: "gray", paddingX: 1, flexDirection: "column", flexShrink: 0, children: [
+                    _jsxs(Box, { children: [
                             _jsx(Text, { dimColor: true, children: "$ " }), _jsx(Text, { children: activeCommand })
-                        ] })), _jsxs(Box, { justifyContent: "space-between", children: [
+                        ] }), _jsxs(Box, { justifyContent: "space-between", children: [
                             _jsxs(Box, { children: [
                                     _jsxs(Text, { ...(pretty && { color: "green" }), children: ["[", pretty ? "formatted" : "raw", "]"] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: "cyan", children: ["[level: ", level, "]"] }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: [outputLines.length, " lines"] })
-                                ] }), _jsx(Text, { dimColor: true, children: "(e)dit | (f)ormat | (l)evel | (c)lear" })
+                                ] }), _jsx(Text, { dimColor: true, children: "(f)ormat | (l)evel | (c)lear" })
                         ] })
                 ] })
         ] }));

package/dist/components/TabbedOutput.js

@@ -74,14 +74,31 @@ export function TabbedOutput({ processes, customTabs = [], logsDir, onExit, onPo
                 if (logsDir) {
                     const logFile = join(logsDir, LOG_FILE_NAME);
                     try {
+                        const trimmedOutput = output.trim();
+                        // Check if stdout output is already a valid JSON log entry
+                        try {
+                            const parsed = JSON.parse(trimmedOutput);
+                            if (parsed &&
+                                typeof parsed === "object" &&
+                                "timestamp" in parsed &&
+                                "level" in parsed &&
+                                "message" in parsed) {
+                                // Already a valid log entry, write as-is
+                                appendFileSync(logFile, `${trimmedOutput}\n`, "utf-8");
+                                return;
+                            }
+                        }
+                        catch {
+                            // Not valid JSON, continue to wrap it
+                        }
+                        // Wrap non-JSON stdout output as a log entry
                         const timestamp = new Date().toISOString();
-                        const logEntry = JSON.stringify({
+                        appendFileSync(logFile, `${JSON.stringify({
                             timestamp,
                             level: "info",
                             service: processInfo.name.toLowerCase(),
-                            message: output.trim(),
-                        });
-                        appendFileSync(logFile, `${logEntry}\n`, "utf-8");
+                            message: trimmedOutput,
+                        })}\n`, "utf-8");
                     }
                     catch (error) {
                         console.error("Failed to write to log file:", error);
@@ -118,14 +135,31 @@ export function TabbedOutput({ processes, customTabs = [], logsDir, onExit, onPo
                 if (logsDir) {
                     const logFile = join(logsDir, LOG_FILE_NAME);
                     try {
+                        const trimmedText = text.trim();
+                        // Check if stderr output is already a valid JSON log entry
+                        try {
+                            const parsed = JSON.parse(trimmedText);
+                            if (parsed &&
+                                typeof parsed === "object" &&
+                                "timestamp" in parsed &&
+                                "level" in parsed &&
+                                "message" in parsed) {
+                                // Already a valid log entry, write as-is
+                                appendFileSync(logFile, `${trimmedText}\n`, "utf-8");
+                                return;
+                            }
+                        }
+                        catch {
+                            // Not valid JSON, continue to wrap it
+                        }
+                        // Wrap non-JSON stderr output as a log entry
                         const timestamp = new Date().toISOString();
-                        const logEntry = JSON.stringify({
+                        appendFileSync(logFile, `${JSON.stringify({
                             timestamp,
                             level: "error",
                             service: processInfo.name.toLowerCase(),
-                            message: text.trim(),
-                        });
-                        appendFileSync(logFile, `${logEntry}\n`, "utf-8");
+                            message: trimmedText,
+                        })}\n`, "utf-8");
                     }
                     catch (error) {
                         console.error("Failed to write to log file:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.108",
+  "version": "0.1.110",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -15,7 +15,7 @@
     "build": "tsgo"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.100",
+    "@townco/tsconfig": "0.1.102",
     "@types/archiver": "^7.0.0",
     "@types/bun": "^1.3.1",
     "@types/ignore-walk": "^4.0.3",
@@ -24,13 +24,13 @@
   "dependencies": {
     "@optique/core": "^0.6.2",
     "@optique/run": "^0.6.2",
-    "@townco/agent": "0.1.111",
-    "@townco/apiclient": "0.0.23",
-    "@townco/core": "0.0.81",
-    "@townco/debugger": "0.1.59",
-    "@townco/env": "0.1.53",
-    "@townco/secret": "0.1.103",
-    "@townco/ui": "0.1.103",
+    "@townco/agent": "0.1.113",
+    "@townco/apiclient": "0.0.25",
+    "@townco/core": "0.0.83",
+    "@townco/debugger": "0.1.61",
+    "@townco/env": "0.1.55",
+    "@townco/secret": "0.1.105",
+    "@townco/ui": "0.1.105",
     "@trpc/client": "^11.7.2",
     "archiver": "^7.0.1",
     "eventsource": "^4.1.0",