@townco/cli 0.1.12 → 0.1.14

package/dist/commands/tool-add.js

@@ -1,5 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { spawn } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -8,6 +7,7 @@ import { MultiSelect } from "@townco/ui/tui";
 import { Box, render, Text, useApp, useInput } from "ink";
 import TextInput from "ink-text-input";
 import { useEffect, useState } from "react";
+import { openInEditor } from "../lib/editor-utils";
 import { ensureToolsDir, getToolsDir, saveToolConfig, toolConfigExists, } from "../lib/tool-storage";
 // ============================================================================
 // Helper Functions
@@ -65,33 +65,6 @@ export default function ${camelCaseName}(_input: unknown) {
 }
 `;
 }
-/**
- * Open a file in the user's editor and wait for it to close
- */
-async function openInEditor(filePath) {
-    return new Promise((resolve, reject) => {
-        // Get editor from environment, fallback to vi
-        const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-        // Parse editor command (might include args like "code --wait")
-        const editorParts = editor.split(" ");
-        const editorCommand = editorParts[0] || "vi";
-        const editorArgs = [...editorParts.slice(1), filePath];
-        const child = spawn(editorCommand, editorArgs, {
-            stdio: "inherit",
-        });
-        child.on("exit", (code) => {
-            if (code === 0 || code === null) {
-                resolve();
-            }
-            else {
-                reject(new Error(`Editor exited with code ${code}`));
-            }
-        });
-        child.on("error", (error) => {
-            reject(error);
-        });
-    });
-}
 function TextInputStage({ title, value, onChange, onSubmit, onCancel, placeholder, }) {
     useInput((_input, key) => {
         if (key.escape) {
@@ -211,7 +184,7 @@ function ToolAddApp({ name: initialName }) {
                 const stubContent = generateStubTemplate(initialName);
                 writeFileSync(tempFile, stubContent, "utf-8");
                 // Open in editor
-                await openInEditor(tempFile);
+                await openInEditor({ filePath: tempFile });
                 // After editor closes, move to name input stage
                 setEditorOpened(true);
             }

package/dist/components/ProcessPane.d.ts

@@ -0,0 +1,7 @@
+export interface ProcessPaneProps {
+    title: string;
+    output: string[];
+    port: number | undefined;
+    status: "starting" | "running" | "stopped" | "error";
+}
+export declare function ProcessPane({ title, output, port, status }: ProcessPaneProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ProcessPane.js

@@ -0,0 +1,17 @@
+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
+    const displayOutput = useMemo(() => {
+        return output.slice(-50);
+    }, [output]);
+    const statusColor = status === "running"
+        ? "green"
+        : status === "error"
+            ? "red"
+            : 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] }) })] }));
+}

package/dist/components/StatusLine.d.ts

@@ -0,0 +1,5 @@
+export interface StatusLineProps {
+    activeTab: number;
+    tabs: string[];
+}
+export declare function StatusLine({ activeTab, tabs }: StatusLineProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/StatusLine.js

@@ -0,0 +1,5 @@
+import { jsxs as _jsxs, jsx as _jsx } 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" })] }));
+}

package/dist/components/TabbedOutput.d.ts

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

package/dist/components/TabbedOutput.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, useApp, useInput } from "ink";
+import { useEffect, useRef, useState } from "react";
+import { ProcessPane } from "./ProcessPane.js";
+import { StatusLine } from "./StatusLine.js";
+export function TabbedOutput({ processes, onExit, onPortDetected, }) {
+    const { exit } = useApp();
+    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());
+    // Handle keyboard input
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            // Cleanup and exit
+            onExit();
+            exit();
+            return;
+        }
+        // Tab key to toggle between tabs
+        if (key.tab) {
+            setActiveTab((activeTab + 1) % processes.length);
+            return;
+        }
+        if (key.leftArrow && activeTab > 0) {
+            setActiveTab(activeTab - 1);
+        }
+        else if (key.rightArrow && activeTab < processes.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(() => {
+        processes.forEach((processInfo, idx) => {
+            const { process } = processInfo;
+            // Mark as running when we see first output
+            const markAsRunning = () => {
+                setStatuses((prev) => {
+                    const newStatuses = [...prev];
+                    if (newStatuses[idx] === "starting") {
+                        newStatuses[idx] = "running";
+                    }
+                    return newStatuses;
+                });
+            };
+            // Capture stdout
+            process.stdout?.on("data", (data) => {
+                const output = data.toString();
+                const lines = output.split("\n").filter(Boolean);
+                setOutputs((prev) => {
+                    const newOutputs = [...prev];
+                    newOutputs[idx] = [...(newOutputs[idx] || []), ...lines];
+                    return newOutputs;
+                });
+                markAsRunning();
+                // 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+)/);
+                    if (portMatch?.[1]) {
+                        const detectedPort = Number.parseInt(portMatch[1], 10);
+                        portDetectedRef.current.add(idx);
+                        // Update our internal ports state
+                        setPorts((prev) => {
+                            const newPorts = [...prev];
+                            newPorts[idx] = detectedPort;
+                            return newPorts;
+                        });
+                        onPortDetected(idx, detectedPort);
+                    }
+                }
+            });
+            // Capture stderr
+            process.stderr?.on("data", (data) => {
+                const text = data.toString();
+                const lines = text.split("\n").filter(Boolean);
+                const errorLines = lines.map((line) => `[ERROR] ${line}`);
+                setOutputs((prev) => {
+                    const newOutputs = [...prev];
+                    newOutputs[idx] = [...(newOutputs[idx] || []), ...errorLines];
+                    return newOutputs;
+                });
+                markAsRunning();
+            });
+            // Handle process exit
+            process.on("close", (code) => {
+                setStatuses((prev) => {
+                    const newStatuses = [...prev];
+                    newStatuses[idx] = code === 0 ? "stopped" : "error";
+                    return newStatuses;
+                });
+                if (code !== 0 && code !== null) {
+                    setOutputs((prev) => {
+                        const newOutputs = [...prev];
+                        newOutputs[idx] = [
+                            ...(newOutputs[idx] || []),
+                            `\n[Process exited with code ${code}]`,
+                        ];
+                        return newOutputs;
+                    });
+                }
+            });
+            process.on("error", (error) => {
+                setStatuses((prev) => {
+                    const newStatuses = [...prev];
+                    newStatuses[idx] = "error";
+                    return newStatuses;
+                });
+                setOutputs((prev) => {
+                    const newOutputs = [...prev];
+                    newOutputs[idx] = [
+                        ...(newOutputs[idx] || []),
+                        `\n[Process error: ${error.message}]`,
+                    ];
+                    return newOutputs;
+                });
+            });
+        });
+        // Cleanup function
+        return () => {
+            processes.forEach(({ process }) => {
+                process.kill();
+            });
+        };
+    }, [processes, onPortDetected]);
+    const currentProcess = processes[activeTab];
+    if (!currentProcess) {
+        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" })] }));
+}

package/dist/lib/editor-utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Unified editor opening function that handles both content and file modes
+ *
+ * @example Content mode
+ * const edited = await openInEditor("Hello world", { extension: '.txt' });
+ * if (edited) console.log("User edited:", edited);
+ *
+ * @example File mode
+ * await openInEditor({ filePath: '/path/to/file.ts' });
+ */
+export declare function openInEditor(contentOrOptions: string | {
+    filePath: string;
+}, options?: {
+    extension?: string;
+}): Promise<string | null>;

package/dist/lib/editor-utils.js

@@ -0,0 +1,112 @@
+import { spawn } from "node:child_process";
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/**
+ * Standardized editor fallback chain
+ */
+const EDITOR_FALLBACKS = [
+    () => process.env.EDITOR,
+    () => process.env.VISUAL,
+    () => "code",
+    () => "vi",
+];
+/**
+ * Parse an editor command that might include arguments
+ * e.g., "code --wait" -> ["code", "--wait"]
+ */
+function parseEditorCommand(editor) {
+    const parts = editor.trim().split(/\s+/);
+    const command = parts[0] || "vi";
+    const args = parts.slice(1);
+    return [command, args];
+}
+/**
+ * Attempt to spawn an editor and wait for it to close
+ */
+async function spawnEditor(editor, filePath, additionalArgs = []) {
+    return new Promise((resolve) => {
+        const [command, editorArgs] = parseEditorCommand(editor);
+        // Special handling for 'code' - add --wait if not present
+        const args = command === "code" && !editorArgs.includes("--wait")
+            ? ["--wait", ...editorArgs, ...additionalArgs, filePath]
+            : [...editorArgs, ...additionalArgs, filePath];
+        const child = spawn(command, args, {
+            stdio: "inherit",
+        });
+        child.on("close", (code) => {
+            resolve(code === 0 || code === null);
+        });
+        child.on("error", () => {
+            resolve(false);
+        });
+    });
+}
+/**
+ * Try editors in the fallback chain until one succeeds
+ */
+async function tryEditorsInOrder(filePath) {
+    for (const getEditor of EDITOR_FALLBACKS) {
+        const editor = getEditor();
+        if (editor) {
+            const success = await spawnEditor(editor, filePath);
+            if (success) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Unified editor opening function that handles both content and file modes
+ *
+ * @example Content mode
+ * const edited = await openInEditor("Hello world", { extension: '.txt' });
+ * if (edited) console.log("User edited:", edited);
+ *
+ * @example File mode
+ * await openInEditor({ filePath: '/path/to/file.ts' });
+ */
+export async function openInEditor(contentOrOptions, options) {
+    const isContentMode = typeof contentOrOptions === "string";
+    if (isContentMode) {
+        // Content mode: create temp file, edit, return content
+        const content = contentOrOptions;
+        const extension = options?.extension || ".txt";
+        const tempFile = join(tmpdir(), `editor-${Date.now()}${extension}`);
+        try {
+            // Write initial content
+            writeFileSync(tempFile, content, "utf-8");
+            // Try editors in fallback order
+            const success = await tryEditorsInOrder(tempFile);
+            if (success) {
+                // Read edited content
+                const editedContent = readFileSync(tempFile, "utf-8");
+                unlinkSync(tempFile);
+                return editedContent;
+            }
+            // All editors failed
+            unlinkSync(tempFile);
+            return null;
+        }
+        catch (_error) {
+            // Clean up temp file if it exists
+            try {
+                unlinkSync(tempFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            return null;
+        }
+    }
+    else {
+        // File mode: edit existing file, return void
+        const { filePath } = contentOrOptions;
+        const success = await tryEditorsInOrder(filePath);
+        if (!success) {
+            throw new Error("Failed to open editor");
+        }
+        return null;
+    }
+}

package/dist/lib/mcp-storage.d.ts

@@ -1,9 +1,9 @@
 export type MCPConfig = {
-    name: string;
-    transport: "stdio" | "http";
-    command?: string;
-    args?: string[];
-    url?: string;
+	name: string;
+	transport: "stdio" | "http";
+	command?: string;
+	args?: string[];
+	url?: string;
 };
 /**
  * Save an MCP config to the store

package/dist/lib/mcp-storage.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+
 // ============================================================================
 // Constants
 // ============================================================================
@@ -13,38 +14,40 @@ const MCPS_FILE = join(TOWN_CONFIG_DIR, "mcps.json");
  * Ensure the config directory exists
  */
 function ensureConfigDir() {
-    if (!existsSync(TOWN_CONFIG_DIR)) {
-        mkdirSync(TOWN_CONFIG_DIR, { recursive: true });
-    }
+	if (!existsSync(TOWN_CONFIG_DIR)) {
+		mkdirSync(TOWN_CONFIG_DIR, { recursive: true });
+	}
 }
 /**
  * Load all MCP configs from the JSON file
  */
 function loadStore() {
-    ensureConfigDir();
-    if (!existsSync(MCPS_FILE)) {
-        return {};
-    }
-    try {
-        const content = readFileSync(MCPS_FILE, "utf-8");
-        return JSON.parse(content);
-    }
-    catch (error) {
-        throw new Error(`Failed to load MCP configs: ${error instanceof Error ? error.message : String(error)}`);
-    }
+	ensureConfigDir();
+	if (!existsSync(MCPS_FILE)) {
+		return {};
+	}
+	try {
+		const content = readFileSync(MCPS_FILE, "utf-8");
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error(
+			`Failed to load MCP configs: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
 }
 /**
  * Save all MCP configs to the JSON file
  */
 function saveStore(store) {
-    ensureConfigDir();
-    try {
-        const content = JSON.stringify(store, null, 2);
-        writeFileSync(MCPS_FILE, content, "utf-8");
-    }
-    catch (error) {
-        throw new Error(`Failed to save MCP configs: ${error instanceof Error ? error.message : String(error)}`);
-    }
+	ensureConfigDir();
+	try {
+		const content = JSON.stringify(store, null, 2);
+		writeFileSync(MCPS_FILE, content, "utf-8");
+	} catch (error) {
+		throw new Error(
+			`Failed to save MCP configs: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
 }
 // ============================================================================
 // Public API
@@ -53,55 +56,54 @@ function saveStore(store) {
  * Save an MCP config to the store
  */
 export function saveMCPConfig(config) {
-    const store = loadStore();
-    store[config.name] = config;
-    saveStore(store);
+	const store = loadStore();
+	store[config.name] = config;
+	saveStore(store);
 }
 /**
  * Load an MCP config by name
  */
 export function loadMCPConfig(name) {
-    const store = loadStore();
-    return store[name] || null;
+	const store = loadStore();
+	return store[name] || null;
 }
 /**
  * Delete an MCP config by name
  */
 export function deleteMCPConfig(name) {
-    const store = loadStore();
-    if (store[name]) {
-        delete store[name];
-        saveStore(store);
-        return true;
-    }
-    return false;
+	const store = loadStore();
+	if (store[name]) {
+		delete store[name];
+		saveStore(store);
+		return true;
+	}
+	return false;
 }
 /**
  * List all MCP configs
  */
 export function listMCPConfigs() {
-    const store = loadStore();
-    return Object.values(store).sort((a, b) => a.name.localeCompare(b.name));
+	const store = loadStore();
+	return Object.values(store).sort((a, b) => a.name.localeCompare(b.name));
 }
 /**
  * Check if an MCP config exists
  */
 export function mcpConfigExists(name) {
-    const store = loadStore();
-    return name in store;
+	const store = loadStore();
+	return name in store;
 }
 /**
  * Get a summary of an MCP config for display
  */
 export function getMCPSummary(config) {
-    if (config.transport === "http") {
-        return `HTTP: ${config.url}`;
-    }
-    else {
-        const parts = [`Stdio: ${config.command}`];
-        if (config.args && config.args.length > 0) {
-            parts.push(`[${config.args.join(" ")}]`);
-        }
-        return parts.join(" ");
-    }
+	if (config.transport === "http") {
+		return `HTTP: ${config.url}`;
+	} else {
+		const parts = [`Stdio: ${config.command}`];
+		if (config.args && config.args.length > 0) {
+			parts.push(`[${config.args.join(" ")}]`);
+		}
+		return parts.join(" ");
+	}
 }

package/dist/lib/port-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if a port is available
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * Find the next available port starting from the given port
+ */
+export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;

package/dist/lib/port-utils.js

@@ -0,0 +1,35 @@
+import { createServer } from "node:net";
+/**
+ * Check if a port is available
+ */
+export async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once("listening", () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port);
+    });
+}
+/**
+ * Find the next available port starting from the given port
+ */
+export async function findAvailablePort(startPort, maxAttempts = 10) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        const available = await isPortAvailable(port);
+        if (available) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find an available port between ${startPort} and ${startPort + maxAttempts - 1}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -19,16 +19,16 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.4",
+    "@townco/tsconfig": "0.1.6",
     "@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.12",
-    "@townco/secret": "0.1.7",
-    "@townco/ui": "0.1.7",
+    "@townco/agent": "0.1.14",
+    "@townco/secret": "0.1.9",
+    "@townco/ui": "0.1.9",
     "@types/inquirer": "^9.0.9",
     "ink": "^6.4.0",
     "ink-text-input": "^6.0.0",

package/dist/commands/tool-stub.d.ts

@@ -1,6 +0,0 @@
-interface ToolStubProps {
-    name?: string;
-}
-declare function ToolStubApp({ name: initialName }: ToolStubProps): import("react/jsx-runtime").JSX.Element | null;
-export default ToolStubApp;
-export declare function runToolStub(props?: ToolStubProps): Promise<void>;