@townco/cli 0.1.31 → 0.1.32

package/dist/commands/mcp-add.d.ts

@@ -0,0 +1,14 @@
+interface MCPAddProps {
+	name?: string;
+	url?: string;
+	command?: string;
+	args?: readonly string[];
+}
+declare function MCPAddApp({
+	name: initialName,
+	url: initialUrl,
+	command: initialCommand,
+	args: initialArgs,
+}: MCPAddProps): import("react/jsx-runtime").JSX.Element | null;
+export default MCPAddApp;
+export declare function runMCPAdd(props?: MCPAddProps): Promise<void>;

package/dist/commands/mcp-add.js

@@ -0,0 +1,494 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentPath, listAgents } from "@townco/agent/storage";
+import { MultiSelect, SingleSelect } from "@townco/ui/tui";
+import { Box, render, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useEffect, useState } from "react";
+import { mcpConfigExists, saveMCPConfig } from "../lib/mcp-storage";
+function TextInputStage({ title, value, onChange, onSubmit, onCancel, placeholder, }) {
+    useInput((_input, key) => {
+        if (key.escape) {
+            onCancel();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: title }) }), _jsxs(Box, { children: [_jsxs(Text, { children: [">", " "] }), _jsx(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit, ...(placeholder && { placeholder }) })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue \u2022 Esc: Back" }) })] }));
+}
+function TransportSelectStage({ selected, onChange, onNext, onCancel, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Select transport type:" }) }), _jsx(SingleSelect, { options: [
+                    {
+                        label: "stdio",
+                        value: "stdio",
+                        description: "Run MCP server as a local process",
+                    },
+                    {
+                        label: "HTTP",
+                        value: "http",
+                        description: "Connect to MCP server over HTTP",
+                    },
+                ], selected: selected, onChange: (transport) => onChange(transport), onSubmit: (transport) => onNext(transport), onCancel: onCancel })] }));
+}
+function NameInputStage({ value, onChange, onNext, onBack, onError, }) {
+    const handleSubmit = () => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return;
+        }
+        // Check for duplicate
+        if (mcpConfigExists(trimmed)) {
+            onError(`MCP server "${trimmed}" already exists`);
+            return;
+        }
+        onNext(trimmed);
+    };
+    return (_jsx(TextInputStage, { title: "Enter MCP server name:", value: value, onChange: onChange, onSubmit: handleSubmit, onCancel: onBack, placeholder: "my-mcp-server" }));
+}
+function StdioCommandStage({ serverName, value, onChange, onNext, onBack, }) {
+    const handleSubmit = () => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return;
+        }
+        onNext(trimmed);
+    };
+    return (_jsx(TextInputStage, { title: `Enter command to run MCP server: ${serverName}`, value: value, onChange: onChange, onSubmit: handleSubmit, onCancel: onBack, placeholder: "npx @modelcontextprotocol/server-filesystem" }));
+}
+function StdioArgsStage({ serverName, args, onAddArg, onRemoveLastArg, onNext, onBack, }) {
+    const [argInput, setArgInput] = useState("");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Add arguments for: ", serverName, " (", args.length, " added)"] }) }), args.length > 0 && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Current arguments:" }), args.map((arg, index) => (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { children: [index + 1, ". ", arg] }) }, arg)))] })), _jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { children: [">", " "] }), _jsx(TextInput, { value: argInput, onChange: setArgInput, onSubmit: () => {
+                            const trimmed = argInput.trim();
+                            if (trimmed) {
+                                onAddArg(trimmed);
+                                setArgInput("");
+                            }
+                        }, placeholder: "Enter argument (or leave empty and press Enter to continue)" })] }), _jsx(SingleSelect, { options: [
+                    {
+                        label: "Done adding arguments",
+                        value: "done",
+                        description: "Continue to review",
+                    },
+                    {
+                        label: "Remove last argument",
+                        value: "remove",
+                        description: args.length > 0
+                            ? `Remove: ${args[args.length - 1]}`
+                            : "No arguments to remove",
+                    },
+                ], selected: null, onChange: () => { }, onSubmit: (value) => {
+                    if (value === "done") {
+                        onNext();
+                    }
+                    else if (value === "remove" && args.length > 0) {
+                        onRemoveLastArg();
+                    }
+                }, onCancel: onBack })] }));
+}
+function HttpUrlStage({ serverName, value, onChange, onNext, onBack, onError, }) {
+    const handleSubmit = () => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return;
+        }
+        // Basic URL validation
+        try {
+            new URL(trimmed);
+        }
+        catch {
+            onError("Invalid URL format");
+            return;
+        }
+        onNext(trimmed);
+    };
+    return (_jsx(TextInputStage, { title: `Enter HTTP URL for MCP server: ${serverName}`, value: value, onChange: onChange, onSubmit: handleSubmit, onCancel: onBack, placeholder: "http://localhost:3000/mcp" }));
+}
+function HttpHeadersStage({ serverName, headers, onAddHeader, onNext, onBack, }) {
+    const [headerKeyInput, setHeaderKeyInput] = useState("");
+    const [headerValueInput, setHeaderValueInput] = useState("");
+    const [inputStage, setInputStage] = useState("key");
+    const headerEntries = Object.entries(headers);
+    useInput((_input, key) => {
+        if (key.escape && inputStage === "key") {
+            onBack();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Add HTTP headers for: ", serverName, " (", headerEntries.length, " added)"] }) }), headerEntries.length > 0 && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Current headers:" }), headerEntries.map(([key, value], index) => (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { children: [index + 1, ". ", key, ": ", value] }) }, key)))] })), inputStage === "key" && (_jsxs(_Fragment, { children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { children: [">", " Header name: "] }), _jsx(TextInput, { value: headerKeyInput, onChange: setHeaderKeyInput, onSubmit: () => {
+                                    const trimmed = headerKeyInput.trim();
+                                    if (trimmed) {
+                                        setInputStage("value");
+                                    }
+                                    else {
+                                        onNext();
+                                    }
+                                }, placeholder: "Enter header name (or leave empty to continue)" })] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Submit header name or continue \u2022 Esc: Back" }) })] })), inputStage === "value" && (_jsxs(_Fragment, { children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { children: [">", " Value for ", headerKeyInput, ":", " "] }), _jsx(TextInput, { value: headerValueInput, onChange: setHeaderValueInput, onSubmit: () => {
+                                    const trimmedValue = headerValueInput.trim();
+                                    if (trimmedValue) {
+                                        onAddHeader(headerKeyInput, trimmedValue);
+                                        setHeaderKeyInput("");
+                                        setHeaderValueInput("");
+                                        setInputStage("key");
+                                    }
+                                }, placeholder: "Header value" })] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Add header" }) })] }))] }));
+}
+function ReviewStage({ config, onEdit, onSave, onBack }) {
+    const [reviewSelection, setReviewSelection] = useState(null);
+    const reviewOptions = [
+        {
+            label: "Save configuration",
+            value: "continue",
+            description: "Save and finish",
+        },
+        {
+            label: "Edit name",
+            value: "name",
+            description: "Change the MCP server name",
+        },
+        {
+            label: "Edit transport",
+            value: "transport",
+            description: "Change the transport type",
+        },
+    ];
+    if (config.transport === "stdio") {
+        reviewOptions.push({
+            label: "Edit command",
+            value: "stdioCommand",
+            description: "Change the command",
+        }, {
+            label: "Edit arguments",
+            value: "stdioArgs",
+            description: "Change the arguments",
+        });
+    }
+    else {
+        reviewOptions.push({
+            label: "Edit URL",
+            value: "httpUrl",
+            description: "Change the HTTP URL",
+        }, {
+            label: "Edit headers",
+            value: "httpHeaders",
+            description: "Change the HTTP headers",
+        });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Review MCP Server Configuration:" }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Name: " }), config.name] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Transport: " }), config.transport] }), config.transport === "stdio" && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Command: " }), config.command] }), config.args && config.args.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Arguments:" }), config.args.map((arg, index) => (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: [index + 1, ". ", arg] }) }, arg)))] }))] })), config.transport === "http" && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "URL: " }), config.url] }), config.headers && Object.keys(config.headers).length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Headers:" }), Object.entries(config.headers).map(([key, value], index) => (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: [index + 1, ". ", key, ": ", value] }) }, key)))] }))] }))] }), _jsx(SingleSelect, { options: reviewOptions, selected: reviewSelection, onChange: setReviewSelection, onSubmit: (value) => {
+                    setReviewSelection(value);
+                    if (value === "continue") {
+                        onSave();
+                    }
+                    else if (value === "name" ||
+                        value === "transport" ||
+                        value === "stdioCommand" ||
+                        value === "stdioArgs" ||
+                        value === "httpUrl" ||
+                        value === "httpHeaders") {
+                        onEdit(value);
+                    }
+                }, onCancel: onBack })] }));
+}
+function NoAgentsMessage({ onNext }) {
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            onNext();
+        }, 1000);
+        return () => clearTimeout(timer);
+    }, [onNext]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "No agents found. MCP server will be saved globally." }), _jsx(Text, { dimColor: true, children: "You can attach it to agents later." })] }));
+}
+function AgentSelectionStage({ selectedAgents, onSelectedAgentsChange, onNext, onBack, }) {
+    const [availableAgents, setAvailableAgents] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    useEffect(() => {
+        // Fetch available agents
+        const fetchAgents = async () => {
+            try {
+                const agents = await listAgents();
+                setAvailableAgents(agents);
+            }
+            catch (error) {
+                console.error("Error fetching agents:", error);
+                setAvailableAgents([]);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        fetchAgents();
+    }, []);
+    // If still loading, show loading message
+    if (isLoading) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "Loading agents..." }) }));
+    }
+    // If no agents available, show info message and auto-proceed
+    if (availableAgents.length === 0) {
+        return _jsx(NoAgentsMessage, { onNext: onNext });
+    }
+    // Show agent selection UI
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Attach MCP server to agents (optional):" }) }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Select which agents should have access to this MCP server." }), _jsx(Text, { dimColor: true, children: "You can skip this step and attach agents later." })] }), _jsx(MultiSelect, { options: availableAgents.map((agent) => ({
+                    label: agent,
+                    value: agent,
+                })), selected: selectedAgents, onChange: onSelectedAgentsChange, onSubmit: onNext, onCancel: onBack })] }));
+}
+function DoneStage({ config, status, error, attachedAgents }) {
+    const { exit } = useApp();
+    useEffect(() => {
+        if (status === "done") {
+            setImmediate(() => {
+                exit();
+            });
+        }
+    }, [status, exit]);
+    if (status === "saving") {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "\u23F3 Saving MCP server configuration..." }) }));
+    }
+    if (status === "error") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u274C Error saving MCP server" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: error }) })] }));
+    }
+    if (status === "done") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", children: "\u2705 MCP server saved successfully!" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Name: ", config.name] }) }), attachedAgents.length > 0 && (_jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Text, { dimColor: true, children: ["Attached to agents: ", attachedAgents.join(", ")] }) }))] }));
+    }
+    return null;
+}
+// ============================================================================
+// Main Component
+// ============================================================================
+function MCPAddApp({ name: initialName, url: initialUrl, command: initialCommand, args: initialArgs, }) {
+    // Determine the starting stage based on what's provided
+    const determineInitialStage = () => {
+        // If command provided, transport is stdio
+        if (initialCommand) {
+            return initialName ? "stdioArgs" : "name";
+        }
+        // If URL provided, transport is http
+        if (initialUrl) {
+            return initialName ? "httpHeaders" : "name";
+        }
+        return "transport";
+    };
+    const { exit } = useApp();
+    const [stage, setStage] = useState(determineInitialStage());
+    const [config, setConfig] = useState({
+        ...(initialName && { name: initialName }),
+        ...(initialCommand && { transport: "stdio" }),
+        ...(initialUrl && !initialCommand && { transport: "http" }),
+        ...(initialCommand && { command: initialCommand }),
+        ...(initialArgs && initialArgs.length > 0 && { args: [...initialArgs] }),
+        ...(initialUrl && { url: initialUrl }),
+    });
+    const [nameInput, setNameInput] = useState(initialName || "");
+    const [commandInput, setCommandInput] = useState(initialCommand || "");
+    const [urlInput, setUrlInput] = useState(initialUrl || "");
+    const [isEditingFromReview, setIsEditingFromReview] = useState(false);
+    const [saveStatus, setSaveStatus] = useState("pending");
+    const [saveError, setSaveError] = useState(null);
+    const [selectedAgents, setSelectedAgents] = useState([]);
+    const handleSave = (agentsToAttach) => {
+        setSaveStatus("saving");
+        // Save the config
+        try {
+            if (!config.name || !config.transport) {
+                setSaveStatus("error");
+                setSaveError("Missing required fields");
+                return;
+            }
+            if (config.transport === "stdio" &&
+                (!config.command || !config.command.trim())) {
+                setSaveStatus("error");
+                setSaveError("Command is required for stdio transport");
+                return;
+            }
+            if (config.transport === "http" && (!config.url || !config.url.trim())) {
+                setSaveStatus("error");
+                setSaveError("URL is required for http transport");
+                return;
+            }
+            const mcpConfig = {
+                name: config.name,
+                transport: config.transport,
+                ...(config.transport === "stdio" && {
+                    command: config.command,
+                    args: config.args,
+                }),
+                ...(config.transport === "http" && {
+                    url: config.url,
+                    ...(config.headers && { headers: config.headers }),
+                }),
+            };
+            // Save to global MCP storage
+            saveMCPConfig(mcpConfig);
+            // Update selected agents
+            for (const agentName of agentsToAttach) {
+                try {
+                    const agentPath = getAgentPath(agentName);
+                    const agentJsonPath = join(agentPath, "agent.json");
+                    // Read existing agent.json
+                    const agentJsonContent = readFileSync(agentJsonPath, "utf-8");
+                    const agentDef = JSON.parse(agentJsonContent);
+                    // Add MCP config to mcps array (create array if doesn't exist)
+                    if (!agentDef.mcps) {
+                        agentDef.mcps = [];
+                    }
+                    // Check if this MCP server is already in the agent's config
+                    const existingIndex = agentDef.mcps.findIndex((mcp) => mcp.name === mcpConfig.name);
+                    if (existingIndex >= 0) {
+                        // Update existing config
+                        agentDef.mcps[existingIndex] = mcpConfig;
+                    }
+                    else {
+                        // Add new config
+                        agentDef.mcps.push(mcpConfig);
+                    }
+                    // Write back to agent.json
+                    writeFileSync(agentJsonPath, JSON.stringify(agentDef, null, 2));
+                }
+                catch (error) {
+                    console.error(`Error updating agent ${agentName}:`, error);
+                    // Continue with other agents even if one fails
+                }
+            }
+            setSaveStatus("done");
+        }
+        catch (error) {
+            setSaveStatus("error");
+            setSaveError(error instanceof Error ? error.message : "Unknown error occurred");
+        }
+    };
+    // Transport selection stage
+    if (stage === "transport") {
+        return (_jsx(TransportSelectStage, { selected: config.transport || null, onChange: (transport) => setConfig({ ...config, transport }), onNext: (transport) => {
+                setConfig({ ...config, transport });
+                if (isEditingFromReview) {
+                    setIsEditingFromReview(false);
+                    setStage("review");
+                }
+                else {
+                    setStage("name");
+                }
+            }, onCancel: () => exit() }));
+    }
+    // Name input stage
+    if (stage === "name") {
+        return (_jsx(NameInputStage, { value: nameInput, onChange: setNameInput, onNext: (name) => {
+                setConfig({ ...config, name });
+                if (isEditingFromReview) {
+                    setIsEditingFromReview(false);
+                    setStage("review");
+                }
+                else if (config.transport === "stdio") {
+                    setStage("stdioCommand");
+                }
+                else {
+                    setStage("httpUrl");
+                }
+            }, onBack: () => {
+                if (initialCommand || initialUrl) {
+                    exit();
+                }
+                else {
+                    setStage("transport");
+                }
+            }, onError: setSaveError }));
+    }
+    // Stdio command input stage
+    if (stage === "stdioCommand") {
+        return (_jsx(StdioCommandStage, { serverName: config.name || "", value: commandInput, onChange: setCommandInput, onNext: (command) => {
+                setConfig({ ...config, command });
+                if (isEditingFromReview) {
+                    setIsEditingFromReview(false);
+                    setStage("review");
+                }
+                else {
+                    setStage("stdioArgs");
+                }
+            }, onBack: () => {
+                if (initialCommand) {
+                    exit();
+                }
+                else {
+                    setStage("name");
+                }
+            } }));
+    }
+    // Stdio args input stage
+    if (stage === "stdioArgs") {
+        return (_jsx(StdioArgsStage, { serverName: config.name || "", args: config.args || [], onAddArg: (arg) => setConfig({ ...config, args: [...(config.args || []), arg] }), onRemoveLastArg: () => setConfig({ ...config, args: (config.args || []).slice(0, -1) }), onNext: () => {
+                if (isEditingFromReview) {
+                    setIsEditingFromReview(false);
+                }
+                setStage("review");
+            }, onBack: () => setStage("stdioCommand") }));
+    }
+    // HTTP URL input stage
+    if (stage === "httpUrl") {
+        return (_jsx(HttpUrlStage, { serverName: config.name || "", value: urlInput, onChange: setUrlInput, onNext: (url) => {
+                setConfig({ ...config, url });
+                if (isEditingFromReview) {
+                    setIsEditingFromReview(false);
+                    setStage("review");
+                }
+                else {
+                    setStage("httpHeaders");
+                }
+            }, onBack: () => {
+                if (initialUrl) {
+                    exit();
+                }
+                else {
+                    setStage("name");
+                }
+            }, onError: setSaveError }));
+    }
+    // HTTP Headers input stage
+    if (stage === "httpHeaders") {
+        return (_jsx(HttpHeadersStage, { serverName: config.name || "", headers: config.headers || {}, onAddHeader: (key, value) => setConfig({
+                ...config,
+                headers: { ...(config.headers || {}), [key]: value },
+            }), onNext: () => {
+                if (isEditingFromReview) {
+                    setIsEditingFromReview(false);
+                }
+                setStage("review");
+            }, onBack: () => setStage("httpUrl") }));
+    }
+    // Review stage
+    if (stage === "review") {
+        return (_jsx(ReviewStage, { config: config, onEdit: (editStage) => {
+                setIsEditingFromReview(true);
+                setStage(editStage);
+            }, onSave: () => {
+                setStage("agentSelection");
+            }, onBack: () => {
+                if (config.transport === "stdio") {
+                    setStage("stdioArgs");
+                }
+                else {
+                    setStage("httpHeaders");
+                }
+            } }));
+    }
+    // Agent selection stage
+    if (stage === "agentSelection") {
+        return (_jsx(AgentSelectionStage, { selectedAgents: selectedAgents, onSelectedAgentsChange: setSelectedAgents, onNext: () => {
+                handleSave(selectedAgents);
+                setStage("done");
+            }, onBack: () => setStage("review") }));
+    }
+    // Done stage
+    if (stage === "done") {
+        return (_jsx(DoneStage, { config: config, status: saveStatus, error: saveError, attachedAgents: selectedAgents }));
+    }
+    return null;
+}
+// ============================================================================
+// Export and Runner
+// ============================================================================
+export default MCPAddApp;
+export async function runMCPAdd(props = {}) {
+    // Set stdin to raw mode to capture input
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    const { waitUntilExit } = render(_jsx(MCPAddApp, { ...props }));
+    // Wait for the app to exit before returning
+    await waitUntilExit();
+}

package/dist/commands/mcp-list.d.ts

@@ -0,0 +1,3 @@
+declare function MCPListApp(): import("react/jsx-runtime").JSX.Element;
+export default MCPListApp;
+export declare function runMCPList(): Promise<void>;

package/dist/commands/mcp-list.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, render, Text, useApp, useInput } from "ink";
+import { useEffect, useState } from "react";
+import { listMCPConfigs } from "../lib/mcp-storage";
+// ============================================================================
+// Main Component
+// ============================================================================
+function MCPListApp() {
+    const [result, setResult] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const { exit } = useApp();
+    useEffect(() => {
+        function loadConfigs() {
+            try {
+                const configs = listMCPConfigs();
+                setResult({ configs });
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                setResult({ configs: [], error: errorMsg });
+            }
+            finally {
+                setLoading(false);
+            }
+        }
+        loadConfigs();
+    }, []);
+    // Exit on any key press when not loading
+    useInput((_input, key) => {
+        if (!loading) {
+            if (key.return || key.escape || _input === "q") {
+                exit();
+            }
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "Loading MCP servers..." }) }));
+    }
+    if (result?.error) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "red", children: "\u274C Error loading MCP servers" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: result.error }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Press Enter or Q to exit" }) })] }));
+    }
+    if (!result || result.configs.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "No MCP servers configured" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Add one with: town mcp add" }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Press Enter or Q to exit" }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Configured MCP Servers (", result.configs.length, ")"] }) }), result.configs.map((config, index) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { bold: true, color: "cyan", children: [index + 1, ". ", config.name] }) }), _jsx(Box, { paddingLeft: 3, children: config.transport === "http" ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Transport: ", _jsx(Text, { color: "green", children: "HTTP" })] }), _jsxs(Text, { children: ["URL: ", config.url] }), config.headers && Object.keys(config.headers).length > 0 && (_jsxs(Text, { children: ["Headers:", " ", Object.entries(config.headers)
+                                            .map(([key, value]) => `${key}: ${value}`)
+                                            .join(", ")] }))] })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Transport: ", _jsx(Text, { color: "blue", children: "stdio" })] }), _jsxs(Text, { children: ["Command: ", config.command] }), config.args && config.args.length > 0 && (_jsxs(Text, { children: ["Args: ", config.args.join(" ")] }))] })) })] }, config.name))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Use `town mcp remove` to remove a server or `town mcp add` to add one" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter or Q to exit" }) })] }));
+}
+// ============================================================================
+// Export and Runner
+// ============================================================================
+export default MCPListApp;
+export async function runMCPList() {
+    const { waitUntilExit, clear } = render(_jsx(MCPListApp, {}));
+    try {
+        await waitUntilExit();
+    }
+    finally {
+        clear();
+        // Ensure cursor is visible
+        process.stdout.write("\x1B[?25h");
+    }
+}

package/dist/commands/mcp-remove.d.ts

@@ -0,0 +1,3 @@
+declare function MCPRemoveApp(): import("react/jsx-runtime").JSX.Element;
+export default MCPRemoveApp;
+export declare function runMCPRemove(): Promise<void>;

package/dist/commands/mcp-remove.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { SingleSelect } from "@townco/ui/tui";
+import { Box, render, Text } from "ink";
+import { useEffect, useState } from "react";
+import { deleteMCPConfig, getMCPSummary, listMCPConfigs, } from "../lib/mcp-storage";
+// ============================================================================
+// Main Component
+// ============================================================================
+function MCPRemoveApp() {
+    const [stage, setStage] = useState("loading");
+    const [configs, setConfigs] = useState([]);
+    const [selectedName, setSelectedName] = useState(null);
+    const [selectedConfig, setSelectedConfig] = useState(null);
+    const [errorMessage, setErrorMessage] = useState("");
+    // Load configs on mount
+    useEffect(() => {
+        function loadConfigs() {
+            try {
+                const configList = listMCPConfigs();
+                setConfigs(configList);
+                setStage(configList.length > 0 ? "select" : "error");
+                if (configList.length === 0) {
+                    setErrorMessage("No MCP servers configured");
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                setErrorMessage(errorMsg);
+                setStage("error");
+            }
+        }
+        loadConfigs();
+    }, []);
+    // Handle removal
+    const handleRemove = () => {
+        if (!selectedName)
+            return;
+        setStage("removing");
+        try {
+            const success = deleteMCPConfig(selectedName);
+            if (success) {
+                setStage("done");
+                // Exit immediately
+                process.exit(0);
+            }
+            else {
+                throw new Error("Failed to delete MCP config");
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            setErrorMessage(errorMsg);
+            setStage("error");
+        }
+    };
+    if (stage === "loading") {
+        return (_jsx(Box, { children: _jsx(Text, { children: "Loading MCP servers..." }) }));
+    }
+    if (stage === "error") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "red", children: "\u274C Error" }) }), _jsx(Box, { children: _jsx(Text, { children: errorMessage }) })] }));
+    }
+    if (stage === "select") {
+        const options = configs.map((config) => ({
+            label: config.name,
+            value: config.name,
+            description: getMCPSummary(config),
+        }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Select MCP server to remove" }) }), _jsx(SingleSelect, { options: options, selected: selectedName, onChange: setSelectedName, onSubmit: (name) => {
+                        const found = configs.find((c) => c.name === name);
+                        if (found) {
+                            setSelectedName(name);
+                            setSelectedConfig(found);
+                            setStage("confirm");
+                        }
+                    }, onCancel: () => process.exit(0) })] }));
+    }
+    if (stage === "confirm") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Confirm removal" }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Are you sure you want to remove:", " ", _jsx(Text, { bold: true, children: selectedConfig?.name })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: getMCPSummary(selectedConfig) }) }), _jsx(SingleSelect, { options: [
+                        {
+                            label: "Yes, remove it",
+                            value: "yes",
+                            description: "Permanently delete this MCP server configuration",
+                        },
+                        {
+                            label: "No, cancel",
+                            value: "no",
+                            description: "Go back to selection",
+                        },
+                    ], selected: null, onChange: () => { }, onSubmit: (choice) => {
+                        if (choice === "yes") {
+                            handleRemove();
+                        }
+                        else {
+                            setStage("select");
+                        }
+                    }, onCancel: () => setStage("select") })] }));
+    }
+    if (stage === "removing") {
+        return (_jsx(Box, { children: _jsx(Text, { children: "\uD83D\uDDD1\uFE0F Removing MCP server..." }) }));
+    }
+    if (stage === "done") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "\u2705 MCP server removed successfully" }) }), _jsx(Box, { children: _jsxs(Text, { children: ["Removed: ", _jsx(Text, { bold: true, children: selectedConfig?.name })] }) })] }));
+    }
+    return _jsxs(Text, { children: ["Unknown stage: ", stage] });
+}
+// ============================================================================
+// Export and Runner
+// ============================================================================
+export default MCPRemoveApp;
+export async function runMCPRemove() {
+    const { waitUntilExit, clear } = render(_jsx(MCPRemoveApp, {}));
+    try {
+        await waitUntilExit();
+    }
+    finally {
+        clear();
+        // Ensure cursor is visible
+        process.stdout.write("\x1B[?25h");
+    }
+}

package/dist/index.js

@@ -12,14 +12,7 @@ import { match } from "ts-pattern";
 import { configureCommand } from "./commands/configure.js";
 import { createCommand } from "./commands/create.js";
 import { createProjectCommand } from "./commands/create-project.js";
-import { deleteCommand } from "./commands/delete.js";
-import { editCommand } from "./commands/edit.js";
-import { listCommand } from "./commands/list.js";
 import { runCommand } from "./commands/run.js";
-import { runToolAdd } from "./commands/tool-add.js";
-import { runToolList } from "./commands/tool-list.js";
-import { runToolRegister } from "./commands/tool-register.js";
-import { runToolRemove } from "./commands/tool-remove.js";
 /**
  * Securely prompt for a secret value without echoing to the terminal
  */
@@ -46,33 +39,13 @@ const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy
     claude: optional(flag("--claude")),
 }), {
     brief: message `Create a new agent or project (with --init <path>). Use --claude to add Claude Code integration.`,
-}), command("list", constant("list"), { brief: message `List all agents.` }), command("run", object({
+}), command("run", object({
     command: constant("run"),
     name: argument(string({ metavar: "NAME" })),
     http: optional(flag("--http")),
     gui: optional(flag("--gui")),
     port: optional(option("-p", "--port", integer())),
-}), { brief: message `Run an agent.` }), command("edit", object({
-    command: constant("edit"),
-    name: argument(string({ metavar: "NAME" })),
-}), { brief: message `Edit an agent.` }), command("delete", object({
-    command: constant("delete"),
-    name: argument(string({ metavar: "NAME" })),
-}), { brief: message `Delete an agent.` }), command("tool", object({
-    command: constant("tool"),
-    subcommand: or(command("add", object({
-        action: constant("add"),
-        name: optional(argument(string({ metavar: "NAME" }))),
-    }), { brief: message `Create a new tool from a template.` }), command("list", constant("list"), {
-        brief: message `List all configured custom tools.`,
-    }), command("register", object({
-        action: constant("register"),
-        name: optional(option("-n", "--name", string())),
-        path: optional(option("-p", "--path", string())),
-    }), { brief: message `Register an existing custom tool.` }), command("remove", constant("remove"), {
-        brief: message `Remove a custom tool.`,
-    })),
-}), { brief: message `Manage custom tools.` }), command("secret", object({
+}), { brief: message `Run an agent.` }), command("secret", object({
     command: constant("secret"),
     subcommand: or(command("list", constant("list"), { brief: message `List secrets.` }), command("add", object({
         action: constant("add"),
@@ -171,9 +144,6 @@ async function main(parser, meta) {
                 });
             }
         }
-    })
-        .with("list", async () => {
-        await listCommand();
     })
         .with({ command: "run" }, async ({ name, http, gui, port }) => {
         const options = {
@@ -185,29 +155,6 @@ async function main(parser, meta) {
             options.port = port;
         }
         await runCommand(options);
-    })
-        .with({ command: "edit" }, async ({ name }) => {
-        await editCommand(name);
-    })
-        .with({ command: "delete" }, async ({ name }) => {
-        await deleteCommand(name);
-    })
-        .with({ command: "tool" }, async ({ subcommand }) => {
-        await match(subcommand)
-            .with({ action: "add" }, async ({ name }) => {
-            await runToolAdd({
-                ...(name !== undefined && { name }),
-            });
-        })
-            .with("list", async () => await runToolList())
-            .with({ action: "register" }, async ({ name, path }) => {
-            await runToolRegister({
-                ...(name !== undefined && { name }),
-                ...(path !== undefined && { path }),
-            });
-        })
-            .with("remove", async () => await runToolRemove())
-            .exhaustive();
     })
         .with({ command: "secret" }, async ({ subcommand }) => {
         await match(subcommand)

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

@@ -0,0 +1,32 @@
+export type MCPConfig = {
+    name: string;
+    transport: "stdio" | "http";
+    command?: string;
+    args?: string[];
+    url?: string;
+    headers?: Record<string, string>;
+};
+/**
+ * Save an MCP config to the store
+ */
+export declare function saveMCPConfig(config: MCPConfig): void;
+/**
+ * Load an MCP config by name
+ */
+export declare function loadMCPConfig(name: string): MCPConfig | null;
+/**
+ * Delete an MCP config by name
+ */
+export declare function deleteMCPConfig(name: string): boolean;
+/**
+ * List all MCP configs
+ */
+export declare function listMCPConfigs(): MCPConfig[];
+/**
+ * Check if an MCP config exists
+ */
+export declare function mcpConfigExists(name: string): boolean;
+/**
+ * Get a summary of an MCP config for display
+ */
+export declare function getMCPSummary(config: MCPConfig): string;

package/dist/lib/mcp-storage.js

@@ -0,0 +1,111 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// ============================================================================
+// Constants
+// ============================================================================
+const TOWN_CONFIG_DIR = join(homedir(), ".config", "town");
+const MCPS_FILE = join(TOWN_CONFIG_DIR, "mcps.json");
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Ensure the config directory exists
+ */
+function ensureConfigDir() {
+    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)}`);
+    }
+}
+/**
+ * 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)}`);
+    }
+}
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Save an MCP config to the store
+ */
+export function saveMCPConfig(config) {
+    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;
+}
+/**
+ * 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;
+}
+/**
+ * List all MCP configs
+ */
+export function listMCPConfigs() {
+    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;
+}
+/**
+ * Get a summary of an MCP config for display
+ */
+export function getMCPSummary(config) {
+    if (config.transport === "http") {
+        const parts = [`HTTP: ${config.url}`];
+        if (config.headers && Object.keys(config.headers).length > 0) {
+            parts.push(`(${Object.keys(config.headers).length} header${Object.keys(config.headers).length === 1 ? "" : "s"})`);
+        }
+        return parts.join(" ");
+    }
+    else {
+        const parts = [`Stdio: ${config.command}`];
+        if (config.args && config.args.length > 0) {
+            parts.push(`[${config.args.join(" ")}]`);
+        }
+        return parts.join(" ");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -15,17 +15,17 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.23",
+    "@townco/tsconfig": "0.1.24",
     "@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.31",
-    "@townco/core": "0.0.4",
-    "@townco/secret": "0.1.26",
-    "@townco/ui": "0.1.26",
+    "@townco/agent": "0.1.32",
+    "@townco/core": "0.0.5",
+    "@townco/secret": "0.1.27",
+    "@townco/ui": "0.1.27",
     "@types/inquirer": "^9.0.9",
     "ink": "^6.4.0",
     "ink-text-input": "^6.0.0",