@townco/cli 0.1.0

package/dist/commands/create.d.ts

@@ -0,0 +1,9 @@
+interface CreateCommandProps {
+    name?: string;
+    model?: string;
+    tools?: readonly string[];
+    systemPrompt?: string;
+    overwrite?: boolean;
+}
+export declare function createCommand(props: CreateCommandProps): Promise<void>;
+export {};

package/dist/commands/create.js

@@ -0,0 +1,385 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { spawn } from "node:child_process";
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { scaffoldAgent } from "@townco/agent/scaffold";
+import { InputBox, MultiSelect, SingleSelect } from "@townco/ui/tui";
+import { Box, render, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useEffect, useState } from "react";
+const AVAILABLE_MODELS = [
+    {
+        label: "Claude Sonnet 4.5",
+        value: "claude-sonnet-4-5-20250929",
+        description: "Latest Sonnet model - balanced performance and speed",
+    },
+    {
+        label: "Claude Sonnet 4",
+        value: "claude-sonnet-4-20250514",
+        description: "Previous Sonnet version",
+    },
+    {
+        label: "Claude Opus 4",
+        value: "claude-opus-4-20250514",
+        description: "Most capable model - best for complex tasks",
+    },
+    {
+        label: "Claude 3.5 Sonnet",
+        value: "claude-3-5-sonnet-20241022",
+        description: "Claude 3.5 generation Sonnet",
+    },
+    {
+        label: "Claude 3.5 Haiku",
+        value: "claude-3-5-haiku-20241022",
+        description: "Fastest model - great for simple tasks",
+    },
+];
+const AVAILABLE_TOOLS = [
+    {
+        label: "Todo Write",
+        value: "todo_write",
+        description: "Task management and planning tool",
+    },
+    {
+        label: "Web Search",
+        value: "web_search",
+        description: "Exa-powered web search (requires EXA_API_KEY)",
+    },
+];
+function NameInput({ nameInput, setNameInput, onSubmit }) {
+    useInput((_input, key) => {
+        if (key.escape) {
+            process.exit(0);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Enter agent name:" }) }), _jsxs(Box, { children: [_jsxs(Text, { children: [">", " "] }), _jsx(TextInput, { value: nameInput, onChange: setNameInput, onSubmit: onSubmit })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue \u2022 Esc: Cancel" }) })] }));
+}
+async function openEditor(initialContent) {
+    const tempFile = join(tmpdir(), `agent-prompt-${Date.now()}.txt`);
+    try {
+        // Write initial content
+        writeFileSync(tempFile, initialContent, "utf-8");
+        // Try $EDITOR first
+        const editor = process.env.EDITOR;
+        if (editor) {
+            try {
+                await new Promise((resolve, reject) => {
+                    const child = spawn(editor, [tempFile], {
+                        stdio: "inherit",
+                    });
+                    child.on("close", (code) => {
+                        if (code === 0)
+                            resolve();
+                        else
+                            reject(new Error(`Editor exited with code ${code}`));
+                    });
+                    child.on("error", reject);
+                });
+                const content = readFileSync(tempFile, "utf-8");
+                unlinkSync(tempFile);
+                return content;
+            }
+            catch (_error) {
+                // Fall through to try 'code'
+            }
+        }
+        // Try 'code' (VS Code) as fallback
+        try {
+            await new Promise((resolve, reject) => {
+                const child = spawn("code", ["--wait", tempFile], {
+                    stdio: "inherit",
+                });
+                child.on("close", (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(`Code exited with code ${code}`));
+                });
+                child.on("error", reject);
+            });
+            const content = readFileSync(tempFile, "utf-8");
+            unlinkSync(tempFile);
+            return content;
+        }
+        catch (_error) {
+            // Clean up and return null to signal fallback to inline
+            unlinkSync(tempFile);
+            return null;
+        }
+    }
+    catch (_error) {
+        // Clean up temp file if it exists
+        try {
+            unlinkSync(tempFile);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        return null;
+    }
+}
+function CreateApp({ name: initialName, model: initialModel, tools: initialTools, systemPrompt: initialSystemPrompt, overwrite = false, }) {
+    // Determine the starting stage based on what's provided
+    const determineInitialStage = () => {
+        if (!initialName)
+            return "name";
+        if (!initialModel)
+            return "model";
+        if (!initialTools || initialTools.length === 0)
+            return "tools";
+        if (!initialSystemPrompt)
+            return "systemPrompt";
+        return "review";
+    };
+    const [stage, setStage] = useState(determineInitialStage());
+    const [agentDef, setAgentDef] = useState({
+        name: initialName || "",
+        model: initialModel || "",
+        tools: initialTools ? [...initialTools] : [],
+        systemPrompt: initialSystemPrompt || "",
+    });
+    const [nameInput, setNameInput] = useState(initialName || "");
+    const [systemPromptInput, setSystemPromptInput] = useState(initialSystemPrompt || "");
+    const [isEditingPrompt, setIsEditingPrompt] = useState(false);
+    const [promptEditMode, setPromptEditMode] = useState(null);
+    const [reviewSelection, setReviewSelection] = useState(null);
+    const [isEditingFromReview, setIsEditingFromReview] = useState(false);
+    const [scaffoldStatus, setScaffoldStatus] = useState("pending");
+    const [scaffoldError, setScaffoldError] = useState(null);
+    const [agentPath, setAgentPath] = useState(null);
+    // Handle opening editor when systemPrompt stage is entered from review
+    useEffect(() => {
+        if (stage === "systemPrompt" &&
+            isEditingFromReview &&
+            !isEditingPrompt &&
+            promptEditMode === null) {
+            // Trigger editor opening
+            setIsEditingPrompt(true);
+            openEditor(agentDef.systemPrompt || "You are a helpful assistant.").then((editorContent) => {
+                if (editorContent !== null) {
+                    // Editor worked
+                    setAgentDef({ ...agentDef, systemPrompt: editorContent });
+                    setIsEditingPrompt(false);
+                    setIsEditingFromReview(false);
+                    setStage("review");
+                }
+                else {
+                    // Fallback to inline
+                    setPromptEditMode("inline");
+                    setIsEditingPrompt(false);
+                    setSystemPromptInput(agentDef.systemPrompt || "You are a helpful assistant.");
+                }
+            });
+        }
+    }, [stage, isEditingFromReview, isEditingPrompt, promptEditMode, agentDef]);
+    // Handle scaffolding when entering "done" stage
+    useEffect(() => {
+        if (stage === "done" && scaffoldStatus === "pending") {
+            setScaffoldStatus("scaffolding");
+            // Scaffold the agent
+            // At this point, all required fields should be present
+            if (!agentDef.name || !agentDef.model) {
+                setScaffoldStatus("error");
+                return;
+            }
+            const name = agentDef.name;
+            const model = agentDef.model;
+            scaffoldAgent({
+                name,
+                definition: {
+                    model,
+                    systemPrompt: agentDef.systemPrompt || null,
+                    tools: agentDef.tools || [],
+                },
+                overwrite,
+            }).then((result) => {
+                if (result.success) {
+                    setScaffoldStatus("done");
+                    setAgentPath(result.path);
+                    // Output in the same format as 'town list'
+                    const modelLabel = model.replace("claude-", "");
+                    console.log(`\n\x1b[1mAgent created successfully!\x1b[0m\n`);
+                    console.log(`  \x1b[32m●\x1b[0m \x1b[1m${name}\x1b[0m`);
+                    console.log(`    \x1b[2mModel: ${modelLabel}\x1b[0m`);
+                    if (agentDef.tools && agentDef.tools.length > 0) {
+                        console.log(`    \x1b[2mTools: ${agentDef.tools.join(", ")}\x1b[0m`);
+                    }
+                    console.log(`    \x1b[2mPath: ${result.path}\x1b[0m`);
+                    console.log();
+                    console.log(`\x1b[2mRun an agent with: town run ${agentDef.name}\x1b[0m`);
+                    console.log(`\x1b[2mTUI mode (default), --gui for web interface, --http for API server\x1b[0m`);
+                    // Exit immediately
+                    process.exit(0);
+                }
+                else {
+                    setScaffoldStatus("error");
+                    setScaffoldError(result.error || "Unknown error occurred");
+                }
+            });
+        }
+    }, [stage, scaffoldStatus, agentDef, overwrite]);
+    // Name stage
+    if (stage === "name") {
+        return (_jsx(NameInput, { nameInput: nameInput, setNameInput: setNameInput, onSubmit: () => {
+                if (nameInput.trim()) {
+                    setAgentDef({ ...agentDef, name: nameInput.trim() });
+                    if (isEditingFromReview) {
+                        setIsEditingFromReview(false);
+                        setStage("review");
+                    }
+                    else {
+                        setStage("model");
+                    }
+                }
+            } }));
+    }
+    // Model selection stage
+    if (stage === "model") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Select model for agent: ", agentDef.name] }) }), _jsx(SingleSelect, { options: AVAILABLE_MODELS, selected: agentDef.model || null, onChange: (model) => setAgentDef({ ...agentDef, model }), onSubmit: (model) => {
+                        setAgentDef({ ...agentDef, model });
+                        if (isEditingFromReview) {
+                            setIsEditingFromReview(false);
+                            setStage("review");
+                        }
+                        else {
+                            setStage("tools");
+                        }
+                    }, onCancel: () => {
+                        if (initialName) {
+                            process.exit(0);
+                        }
+                        else {
+                            setStage("name");
+                        }
+                    } })] }));
+    }
+    // Tools selection stage
+    if (stage === "tools") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Select tools for agent: ", agentDef.name] }) }), _jsx(MultiSelect, { options: AVAILABLE_TOOLS, selected: agentDef.tools || [], onChange: (tools) => setAgentDef({ ...agentDef, tools }), onSubmit: async () => {
+                        // If editing from review, just go back to review
+                        if (isEditingFromReview) {
+                            setIsEditingFromReview(false);
+                            setStage("review");
+                            return;
+                        }
+                        // If systemPrompt was provided via flag, skip to review
+                        if (initialSystemPrompt) {
+                            setStage("review");
+                            return;
+                        }
+                        setStage("systemPrompt");
+                        // Attempt to open editor
+                        setIsEditingPrompt(true);
+                        const editorContent = await openEditor(agentDef.systemPrompt || "You are a helpful assistant.");
+                        if (editorContent !== null) {
+                            // Editor worked
+                            setAgentDef({ ...agentDef, systemPrompt: editorContent });
+                            setIsEditingPrompt(false);
+                            setStage("review");
+                        }
+                        else {
+                            // Fallback to inline
+                            setPromptEditMode("inline");
+                            setIsEditingPrompt(false);
+                            setSystemPromptInput(agentDef.systemPrompt || "You are a helpful assistant.");
+                        }
+                    }, onCancel: () => setStage("model") })] }));
+    }
+    // System prompt stage (inline fallback)
+    if (stage === "systemPrompt") {
+        if (isEditingPrompt) {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Opening editor for system prompt..." }) }), _jsx(Text, { dimColor: true, children: "You can edit the system prompt in your preferred editor." })] }));
+        }
+        if (promptEditMode === "inline") {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Enter system prompt (multi-line supported):" }) }), _jsx(InputBox, { value: systemPromptInput, onChange: setSystemPromptInput, onSubmit: () => {
+                            setAgentDef({ ...agentDef, systemPrompt: systemPromptInput });
+                            if (isEditingFromReview) {
+                                setIsEditingFromReview(false);
+                                setPromptEditMode(null);
+                            }
+                            setStage("review");
+                        }, onEscape: () => {
+                            if (isEditingFromReview) {
+                                setIsEditingFromReview(false);
+                                setPromptEditMode(null);
+                                setStage("review");
+                            }
+                            else {
+                                setStage("tools");
+                            }
+                        }, isSubmitting: false, attachedFiles: [] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue \u2022 Esc: Back" }) })] }));
+        }
+        return null;
+    }
+    // Review stage
+    if (stage === "review") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Review Agent Configuration:" }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Name: " }), agentDef.name] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Model: " }), agentDef.model] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Tools: " }), agentDef.tools && agentDef.tools.length > 0
+                                    ? agentDef.tools.join(", ")
+                                    : "none"] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: "System Prompt:" }) }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: agentDef.systemPrompt?.split("\n").map((line) => (_jsx(Text, { dimColor: true, children: line || " " }, line))) })] }), _jsx(SingleSelect, { options: [
+                        {
+                            label: "Looks good, continue",
+                            value: "continue",
+                            description: "Proceed to next step",
+                        },
+                        {
+                            label: "Edit name",
+                            value: "name",
+                            description: "Go back and change the agent name",
+                        },
+                        {
+                            label: "Edit model",
+                            value: "model",
+                            description: "Go back and change the model",
+                        },
+                        {
+                            label: "Edit tools",
+                            value: "tools",
+                            description: "Go back and change tool selection",
+                        },
+                        {
+                            label: "Edit system prompt",
+                            value: "systemPrompt",
+                            description: "Go back and change the system prompt",
+                        },
+                    ], selected: reviewSelection, onChange: (value) => {
+                        setReviewSelection(value);
+                    }, onSubmit: (value) => {
+                        // Navigate based on selection
+                        setReviewSelection(value);
+                        if (value === "continue") {
+                            setStage("done");
+                        }
+                        else if (value === "name" ||
+                            value === "model" ||
+                            value === "tools" ||
+                            value === "systemPrompt") {
+                            // Set flag so we return to review after editing
+                            setIsEditingFromReview(true);
+                            setStage(value);
+                        }
+                    }, onCancel: () => setStage("tools") })] }));
+    }
+    // Done stage
+    if (stage === "done") {
+        if (scaffoldStatus === "scaffolding") {
+            return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "\u23F3 Creating agent package..." }) }));
+        }
+        if (scaffoldStatus === "error") {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u2717 Error creating agent package" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: scaffoldError }) })] }));
+        }
+        if (scaffoldStatus === "done") {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", children: "\u2713 Agent package created successfully!" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Path: ", agentPath] }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["You can run the agent with:", " ", _jsxs(Text, { bold: true, color: "cyan", children: ["town run ", agentDef.name] })] }) })] }));
+        }
+    }
+    return null;
+}
+export async function createCommand(props) {
+    // Set stdin to raw mode to capture input
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    const { waitUntilExit } = render(_jsx(CreateApp, { ...props }));
+    // Wait for the app to exit before returning
+    await waitUntilExit();
+}

package/dist/commands/delete.d.ts

@@ -0,0 +1 @@
+export declare function deleteCommand(name: string): Promise<void>;

package/dist/commands/delete.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { agentExists, deleteAgent } from "@townco/agent/storage";
+import { SingleSelect } from "@townco/ui/tui";
+import { Box, render, Text } from "ink";
+import { useState } from "react";
+function DeleteApp({ name }) {
+    const [confirmed, setConfirmed] = useState(null);
+    if (confirmed === null) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, children: ["Are you sure you want to delete agent", " ", _jsx(Text, { color: "red", children: name }), "?"] }) }), _jsx(Text, { dimColor: true, children: "This action cannot be undone." }), _jsx(Box, { marginTop: 1, children: _jsx(SingleSelect, { options: [
+                            {
+                                label: "Yes, delete",
+                                value: "yes",
+                                description: "Permanently delete this agent",
+                            },
+                            {
+                                label: "No, cancel",
+                                value: "no",
+                                description: "Keep the agent",
+                            },
+                        ], selected: null, onChange: () => { }, onSubmit: async (value) => {
+                            if (value === "yes") {
+                                setConfirmed(true);
+                                try {
+                                    await deleteAgent(name);
+                                    setTimeout(() => process.exit(0), 1500);
+                                }
+                                catch (error) {
+                                    console.error(`Error deleting agent: ${error instanceof Error ? error.message : String(error)}`);
+                                    process.exit(1);
+                                }
+                            }
+                            else {
+                                setConfirmed(false);
+                                setTimeout(() => process.exit(0), 500);
+                            }
+                        }, onCancel: () => {
+                            setConfirmed(false);
+                            setTimeout(() => process.exit(0), 500);
+                        } }) })] }));
+    }
+    if (confirmed) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "green", children: "\u2713 Agent deleted successfully" }) }));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { dimColor: true, children: "Cancelled" }) }));
+}
+export async function deleteCommand(name) {
+    // Check if agent exists
+    const exists = await agentExists(name);
+    if (!exists) {
+        console.error(`Error: Agent "${name}" not found.`);
+        console.log('\nList agents with "town list"');
+        process.exit(1);
+    }
+    // Set stdin to raw mode to capture input
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    const { waitUntilExit } = render(_jsx(DeleteApp, { name: name }));
+    await waitUntilExit();
+}

package/dist/commands/edit.d.ts

@@ -0,0 +1 @@
+export declare function editCommand(name: string): Promise<void>;

package/dist/commands/edit.js

@@ -0,0 +1,82 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { agentExists, getAgentPath } from "@townco/agent/storage";
+import { createCommand } from "./create.js";
+async function loadAgentConfig(name) {
+    try {
+        const agentPath = getAgentPath(name);
+        const indexPath = join(agentPath, "index.ts");
+        const content = await readFile(indexPath, "utf-8");
+        // Parse model
+        const modelMatch = content.match(/model:\s*"([^"]+)"/);
+        if (!modelMatch) {
+            throw new Error("Failed to parse model from agent configuration");
+        }
+        const model = modelMatch[1];
+        // Parse tools
+        const toolsMatch = content.match(/tools:\s*\[([^\]]*)\]/);
+        let tools = [];
+        if (toolsMatch?.[1]) {
+            const toolsStr = toolsMatch[1];
+            tools = toolsStr
+                .split(",")
+                .map((t) => t.trim().replace(/["']/g, ""))
+                .filter((t) => t.length > 0);
+        }
+        // Parse systemPrompt - handle multiline strings and null
+        const systemPromptMatch = content.match(/systemPrompt:\s*(null|"([^"]*)"|`([^`]*)`)/s);
+        let systemPrompt;
+        if (systemPromptMatch) {
+            if (systemPromptMatch[1] === "null") {
+                systemPrompt = "";
+            }
+            else {
+                // Get either double-quoted (group 2) or backtick-quoted (group 3) content
+                systemPrompt = systemPromptMatch[2] || systemPromptMatch[3] || "";
+            }
+        }
+        if (systemPrompt !== undefined && systemPrompt !== "") {
+            return {
+                name,
+                model: model,
+                tools,
+                systemPrompt,
+            };
+        }
+        return {
+            name,
+            model: model,
+            tools,
+        };
+    }
+    catch (error) {
+        console.error(`Error loading agent config: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+export async function editCommand(name) {
+    // Check if agent exists
+    const exists = await agentExists(name);
+    if (!exists) {
+        console.error(`Error: Agent "${name}" not found.`);
+        console.log('\nCreate an agent with "town create" or list agents with "town list"');
+        process.exit(1);
+    }
+    // Load existing config
+    const config = await loadAgentConfig(name);
+    if (!config) {
+        console.error(`Error: Failed to load agent configuration for "${name}".`);
+        process.exit(1);
+    }
+    console.log(`Editing agent: ${name}\n`);
+    // Reuse create command with existing values and overwrite flag
+    await createCommand({
+        name: config.name,
+        model: config.model,
+        tools: config.tools,
+        ...(config.systemPrompt !== undefined && {
+            systemPrompt: config.systemPrompt,
+        }),
+        overwrite: true,
+    });
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function listCommand(): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,55 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAgentPath, listAgents } from "@townco/agent/storage";
+async function getAgentInfo(name) {
+    try {
+        const agentPath = getAgentPath(name);
+        const configPath = join(agentPath, "agent.json");
+        const content = await readFile(configPath, "utf-8");
+        const config = JSON.parse(content);
+        return {
+            name,
+            model: config.model,
+            tools: config.tools || [],
+        };
+    }
+    catch (error) {
+        return {
+            name,
+            error: error instanceof Error ? error.message : "Failed to read agent",
+        };
+    }
+}
+export async function listCommand() {
+    const agents = await listAgents();
+    if (agents.length === 0) {
+        console.log("No agents found.");
+        console.log('\x1b[2mCreate your first agent with "town create"\x1b[0m');
+        return;
+    }
+    console.log(`\x1b[1mFound ${agents.length} agent${agents.length === 1 ? "" : "s"}:\x1b[0m\n`);
+    // Get info for all agents
+    const agentInfos = await Promise.all(agents.map((name) => getAgentInfo(name)));
+    // Display each agent
+    for (const info of agentInfos) {
+        const agentPath = getAgentPath(info.name);
+        if (info.error) {
+            console.log(`  \x1b[31m✗\x1b[0m \x1b[1m${info.name}\x1b[0m`);
+            console.log(`    \x1b[2mError: ${info.error}\x1b[0m`);
+        }
+        else {
+            const modelLabel = info.model
+                ? info.model.replace("claude-", "")
+                : "unknown";
+            console.log(`  \x1b[32m●\x1b[0m \x1b[1m${info.name}\x1b[0m`);
+            console.log(`    \x1b[2mModel: ${modelLabel}\x1b[0m`);
+            if (info.tools && info.tools.length > 0) {
+                console.log(`    \x1b[2mTools: ${info.tools.join(", ")}\x1b[0m`);
+            }
+            console.log(`    \x1b[2mPath: ${agentPath}\x1b[0m`);
+        }
+        console.log(); // Empty line between agents
+    }
+    console.log(`\x1b[2mRun an agent with: town run <name>\x1b[0m`);
+    console.log(`\x1b[2mTUI mode (default), --gui for web interface, --http for API server\x1b[0m`);
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,7 @@
+export interface RunCommandOptions {
+    name: string;
+    http?: boolean;
+    gui?: boolean;
+    port?: number;
+}
+export declare function runCommand(options: RunCommandOptions): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,129 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { agentExists, getAgentPath } from "@townco/agent/storage";
+export async function runCommand(options) {
+    const { name, http = false, gui = false, port = 3100 } = options;
+    // Check if agent exists
+    const exists = await agentExists(name);
+    if (!exists) {
+        console.error(`Error: Agent "${name}" not found.`);
+        console.log('\nCreate an agent with "town create" or list agents with "town list"');
+        process.exit(1);
+    }
+    const agentPath = getAgentPath(name);
+    const binPath = join(agentPath, "bin.ts");
+    // If GUI or HTTP-only mode, run differently
+    if (gui) {
+        const guiPath = join(agentPath, "gui");
+        // Check if GUI exists
+        try {
+            const { stat } = await import("node:fs/promises");
+            await stat(guiPath);
+        }
+        catch {
+            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.`);
+            process.exit(1);
+        }
+        console.log(`Starting agent "${name}" with GUI...`);
+        console.log(`Starting agent HTTP server on port ${port}...`);
+        console.log(`Starting GUI development server...\n`);
+        // Start the agent in HTTP mode first
+        const agentProcess = spawn("bun", [binPath, "http"], {
+            cwd: agentPath,
+            stdio: "pipe",
+            env: {
+                ...process.env,
+                NODE_ENV: process.env.NODE_ENV || "production",
+                PORT: port.toString(),
+            },
+        });
+        agentProcess.on("error", (error) => {
+            console.error(`Failed to start agent: ${error.message}`);
+            process.exit(1);
+        });
+        // Wait a bit for agent to start, then start the GUI
+        setTimeout(() => {
+            // Start the GUI dev server
+            const guiProcess = spawn("bun", ["run", "dev"], {
+                cwd: guiPath,
+                stdio: "inherit",
+                env: {
+                    ...process.env,
+                    VITE_AGENT_URL: `http://localhost:${port}`,
+                },
+            });
+            guiProcess.on("error", (error) => {
+                console.error(`Failed to start GUI: ${error.message}`);
+                agentProcess.kill();
+                process.exit(1);
+            });
+            guiProcess.on("close", (code) => {
+                agentProcess.kill();
+                if (code !== 0 && code !== null) {
+                    console.error(`GUI exited with code ${code}`);
+                    process.exit(code);
+                }
+            });
+        }, 1000);
+        agentProcess.on("close", (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`Agent exited with code ${code}`);
+                process.exit(code);
+            }
+        });
+        return;
+    }
+    else if (http) {
+        console.log(`Starting agent "${name}" in HTTP mode on port ${port}...`);
+        console.log(`\nEndpoints:`);
+        console.log(`  http://localhost:${port}/health - Health check`);
+        console.log(`  http://localhost:${port}/rpc - RPC endpoint`);
+        console.log(`  http://localhost:${port}/events - SSE event stream\n`);
+        // Run the agent in HTTP mode
+        const agentProcess = spawn("bun", [binPath, "http"], {
+            cwd: agentPath,
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                NODE_ENV: process.env.NODE_ENV || "production",
+                PORT: port.toString(),
+            },
+        });
+        agentProcess.on("error", (error) => {
+            console.error(`Failed to start agent: ${error.message}`);
+            process.exit(1);
+        });
+        agentProcess.on("close", (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`Agent exited with code ${code}`);
+                process.exit(code);
+            }
+        });
+        return;
+    }
+    // Default: Start TUI interface with the agent
+    console.log(`Starting interactive terminal for agent "${name}"...\n`);
+    // Get path to TUI app
+    const tuiPath = join(process.cwd(), "apps", "tui", "src", "index.tsx");
+    // Run TUI with the agent
+    const tuiProcess = spawn("bun", [tuiPath, "--agent", binPath], {
+        cwd: agentPath,
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            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);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/index.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env bun
+import { argument, command, constant, flag, multiple, object, option, optional, or, } from "@optique/core";
+import { message } from "@optique/core/message";
+import { integer, string } from "@optique/core/valueparser";
+import { run } from "@optique/run";
+import { createSecret, deleteSecret, genenv, listSecrets } from "@townco/secret";
+import inquirer from "inquirer";
+import { match } from "ts-pattern";
+import { createCommand } from "./commands/create.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";
+/**
+ * Securely prompt for a secret value without echoing to the terminal
+ */
+async function promptSecret(secretName) {
+    const answers = await inquirer.prompt([
+        {
+            type: "password",
+            name: "value",
+            message: `Enter value for secret '${secretName}':`,
+            mask: "*",
+        },
+    ]);
+    return answers.value;
+}
+const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy a Town.` }), command("create", object({
+    command: constant("create"),
+    name: optional(option("-n", "--name", string())),
+    model: optional(option("-m", "--model", string())),
+    tools: multiple(option("-t", "--tool", string())),
+    systemPrompt: optional(option("-p", "--prompt", string())),
+}), { brief: message `Create a new agent.` }), command("list", constant("list"), { brief: message `List all agents.` }), 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("secret", object({
+    command: constant("secret"),
+    subcommand: or(command("list", constant("list"), { brief: message `List secrets.` }), command("add", object({
+        action: constant("add"),
+        name: argument(string({ metavar: "NAME" })),
+        value: optional(argument(string({ metavar: "VALUE" }))),
+    }), { brief: message `Add a secret.` }), command("remove", object({
+        action: constant("remove"),
+        name: argument(string({ metavar: "NAME" })),
+    }), { brief: message `Remove a secret.` }), command("genenv", constant("genenv"), {
+        brief: message `Generate .env file.`,
+    })),
+}), { brief: message `Secrets management.` }));
+const meta = {
+    programName: "town",
+    help: "both",
+    version: "both",
+    completion: "both",
+    brief: message `Your one-stop shop for all things Town in the terminal\n`,
+    description: message `Town CLI is a first-class command-line experience for working with Town Agents.`,
+};
+async function main(parser, meta) {
+    const result = run(parser, meta);
+    await match(result)
+        // TODO
+        .with("deploy", async () => { })
+        .with({ command: "create" }, async ({ name, model, tools, systemPrompt }) => {
+        // Create command starts a long-running Ink session
+        // Only pass defined properties to satisfy exactOptionalPropertyTypes
+        await createCommand({
+            ...(name !== undefined && { name }),
+            ...(model !== undefined && { model }),
+            ...(tools.length > 0 && { tools }),
+            ...(systemPrompt !== undefined && { systemPrompt }),
+        });
+    })
+        .with("list", async () => {
+        await listCommand();
+    })
+        .with({ command: "run" }, async ({ name, http, gui, port }) => {
+        const options = {
+            name,
+            http: http === true,
+            gui: gui === true,
+        };
+        if (port !== null && port !== undefined) {
+            options.port = port;
+        }
+        await runCommand(options);
+    })
+        .with({ command: "edit" }, async ({ name }) => {
+        await editCommand(name);
+    })
+        .with({ command: "delete" }, async ({ name }) => {
+        await deleteCommand(name);
+    })
+        .with({ command: "secret" }, async ({ subcommand }) => {
+        await match(subcommand)
+            .with("list", async () => {
+            const secrets = await listSecrets();
+            for (const secret of secrets) {
+                console.log(`${secret.key}\t${secret.value}\t${secret.valid ? "✓" : "✗"}\t${secret.error ?? ""}`);
+            }
+        })
+            .with({ action: "add" }, async ({ name, value }) => {
+            // If value is not provided, prompt securely
+            const secretValue = value ?? (await promptSecret(name));
+            if (!secretValue) {
+                console.error("Error: Secret value cannot be empty");
+                process.exit(1);
+            }
+            await createSecret(name, secretValue);
+            console.log(`Secret '${name}' added successfully.`);
+        })
+            .with({ action: "remove" }, async ({ name }) => {
+            await deleteSecret(name);
+            console.log(`Secret '${name}' removed successfully.`);
+        })
+            .with("genenv", async () => {
+            await genenv();
+            console.log(".env file generated successfully.");
+        })
+            .exhaustive();
+    })
+        .exhaustive();
+}
+main(parser, meta).catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@townco/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "townco": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/federicoweber/agent_hub.git"
+  },
+  "author": "Federico Weber",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@townco/tsconfig": "^0.1.0",
+    "@types/bun": "^1.3.1",
+    "@types/react": "^19.2.2"
+  },
+  "dependencies": {
+    "@optique/core": "^0.6.2",
+    "@optique/run": "^0.6.2",
+    "@townco/secret": "^0.1.0",
+    "@townco/ui": "^0.1.0",
+    "@townco/agent": "^0.1.0",
+    "@types/inquirer": "^9.0.9",
+    "ink": "^6.4.0",
+    "ink-text-input": "^6.0.0",
+    "inquirer": "^12.10.0",
+    "react": "^19.2.0",
+    "ts-pattern": "^5.9.0"
+  }
+}