@townco/cli 0.1.12 → 0.1.13

package/dist/commands/create.js

@@ -1,13 +1,10 @@
 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";
+import { openInEditor } from "../lib/editor-utils";
 const AVAILABLE_MODELS = [
     {
         label: "Claude Sonnet 4.5",
@@ -55,70 +52,6 @@ function NameInput({ nameInput, setNameInput, onSubmit }) {
     });
     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 = () => {
@@ -150,13 +83,14 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
     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) => {
+        (async () => {
+            if (stage === "systemPrompt" &&
+                isEditingFromReview &&
+                !isEditingPrompt &&
+                promptEditMode === null) {
+                // Trigger editor opening
+                setIsEditingPrompt(true);
+                const editorContent = await openInEditor(agentDef.systemPrompt || "You are a helpful assistant.");
                 if (editorContent !== null) {
                     // Editor worked
                     setAgentDef({ ...agentDef, systemPrompt: editorContent });
@@ -170,8 +104,8 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
                     setIsEditingPrompt(false);
                     setSystemPromptInput(agentDef.systemPrompt || "You are a helpful assistant.");
                 }
-            });
-        }
+            }
+        })();
     }, [stage, isEditingFromReview, isEditingPrompt, promptEditMode, agentDef]);
     // Handle scaffolding when entering "done" stage
     useEffect(() => {
@@ -271,7 +205,7 @@ function CreateApp({ name: initialName, model: initialModel, tools: initialTools
                         setStage("systemPrompt");
                         // Attempt to open editor
                         setIsEditingPrompt(true);
-                        const editorContent = await openEditor(agentDef.systemPrompt || "You are a helpful assistant.");
+                        const editorContent = await openInEditor(agentDef.systemPrompt || "You are a helpful assistant.");
                         if (editorContent !== null) {
                             // Editor worked
                             setAgentDef({ ...agentDef, systemPrompt: editorContent });

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -19,16 +19,16 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.4",
+    "@townco/tsconfig": "0.1.5",
     "@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.13",
+    "@townco/secret": "0.1.8",
+    "@townco/ui": "0.1.8",
     "@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>;

package/dist/commands/tool-stub.js

@@ -1,376 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { spawn } from "node:child_process";
-import { copyFileSync, existsSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { getAgentPath, listAgents } from "@townco/agent/storage";
-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 { ensureToolsDir, getToolsDir, saveToolConfig, toolConfigExists, } from "../lib/tool-storage";
-// ============================================================================
-// Helper Functions
-// ============================================================================
-/**
- * Normalize a tool name to kebab-case for use as a filename
- */
-function normalizeToolName(name) {
-    return name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-}
-/**
- * Convert kebab-case or snake_case to camelCase for function names
- */
-function toCamelCase(str) {
-    return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase());
-}
-/**
- * Convert a name to snake_case for the tool name export
- */
-function toSnakeCase(str) {
-    return str
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "_")
-        .replace(/^_+|_+$/g, "");
-}
-/**
- * Generate the stub template content
- */
-function generateStubTemplate(toolName) {
-    const snakeCaseName = toolName ? toSnakeCase(toolName) : "tool_name";
-    const camelCaseName = toolName ? toCamelCase(toolName) : "toolName";
-    const description = toolName
-        ? `Describe what ${toolName} does here`
-        : "Describe what your tool does here";
-    return `// biome-ignore lint/suspicious/noExplicitAny: .
-export const schema = (z: any) =>
-  z.object({
-    // Define your input parameters here
-    // Example: message: z.string().describe("The message to process"),
-    input: z.string().optional(),
-  });
-
-export const name = "${snakeCaseName}";
-export const description = "${description}";
-
-export default function ${camelCaseName}(_input: unknown) {
-  // TODO: Implement your tool logic here
-
-  return "result";
-}
-`;
-}
-/**
- * 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) {
-            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 NameInputStage({ value, onChange, onNext, onBack, }) {
-    const [localError, setLocalError] = useState(null);
-    const handleSubmit = () => {
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return;
-        }
-        // Check for duplicate
-        if (toolConfigExists(trimmed)) {
-            setLocalError(`Tool "${trimmed}" already exists`);
-            return;
-        }
-        onNext(trimmed);
-    };
-    const handleChange = (newValue) => {
-        if (localError) {
-            setLocalError(null);
-        }
-        onChange(newValue);
-    };
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TextInputStage, { title: "Enter tool name:", value: value, onChange: handleChange, onSubmit: handleSubmit, onCancel: onBack, placeholder: "my-custom-tool" }), localError && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["\u274C ", localError] }) }))] }));
-}
-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. Tool 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: "Register tool with agents (optional):" }) }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Select which agents should have access to this tool." }), _jsx(Text, { dimColor: true, children: "You can skip this step and register 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 tool configuration..." }) }));
-    }
-    if (status === "error") {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u274C Error saving tool" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: error }) })] }));
-    }
-    if (status === "done") {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", children: "\u2705 Tool saved successfully!" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["Name: ", config.name] }), _jsxs(Text, { dimColor: true, children: ["Path: ", config.path] })] }), attachedAgents.length > 0 && (_jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Text, { dimColor: true, children: ["Registered with agents: ", attachedAgents.join(", ")] }) }))] }));
-    }
-    return null;
-}
-// ============================================================================
-// Main Component
-// ============================================================================
-function ToolStubApp({ name: initialName }) {
-    const { exit } = useApp();
-    const [stage, setStage] = useState("name");
-    const [config, setConfig] = useState({});
-    const [nameInput, setNameInput] = useState(initialName || "");
-    const [saveStatus, setSaveStatus] = useState("pending");
-    const [saveError, setSaveError] = useState(null);
-    const [selectedAgents, setSelectedAgents] = useState([]);
-    const [tempFilePath, setTempFilePath] = useState(null);
-    const [editorOpened, setEditorOpened] = useState(false);
-    // On mount, create temp file and open editor
-    useEffect(() => {
-        if (editorOpened)
-            return;
-        const setupAndOpenEditor = async () => {
-            try {
-                // Generate temp file path
-                const tempFile = join(tmpdir(), `town-tool-${Date.now()}.ts`);
-                setTempFilePath(tempFile);
-                // Generate and write stub template
-                const stubContent = generateStubTemplate(initialName);
-                writeFileSync(tempFile, stubContent, "utf-8");
-                // Open in editor
-                await openInEditor(tempFile);
-                // After editor closes, move to name input stage
-                setEditorOpened(true);
-            }
-            catch (error) {
-                setSaveStatus("error");
-                setSaveError(`Failed to open editor: ${error instanceof Error ? error.message : String(error)}`);
-                setStage("done");
-            }
-        };
-        setupAndOpenEditor();
-    }, [initialName, editorOpened]);
-    const handleSave = (toolName, agentsToAttach) => {
-        setSaveStatus("saving");
-        try {
-            if (!tempFilePath) {
-                setSaveStatus("error");
-                setSaveError("Temp file path not found");
-                return;
-            }
-            // Check if temp file still exists
-            if (!existsSync(tempFilePath)) {
-                setSaveStatus("error");
-                setSaveError("Temp file was deleted");
-                return;
-            }
-            // Read the edited content
-            const editedContent = readFileSync(tempFilePath, "utf-8");
-            // Ensure tools directory exists
-            ensureToolsDir();
-            // Normalize the tool name for the filename
-            const normalizedName = normalizeToolName(toolName);
-            const toolsDir = getToolsDir();
-            const targetPath = join(toolsDir, `${normalizedName}.ts`);
-            // Write the edited content to the target path
-            try {
-                writeFileSync(targetPath, editedContent, "utf-8");
-            }
-            catch (error) {
-                setSaveStatus("error");
-                setSaveError(`Failed to save file: ${error instanceof Error ? error.message : String(error)}`);
-                return;
-            }
-            // Create tool config
-            const toolConfig = {
-                name: toolName,
-                path: targetPath,
-            };
-            // Save to global tool storage
-            saveToolConfig(toolConfig);
-            // 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 tool to tools array (create array if doesn't exist)
-                    if (!agentDef.tools) {
-                        agentDef.tools = [];
-                    }
-                    // Create custom tool object
-                    const customTool = {
-                        type: "custom",
-                        modulePath: targetPath,
-                    };
-                    // Check if this tool is already in the agent's config
-                    const existingIndex = agentDef.tools.findIndex((tool) => typeof tool === "object" &&
-                        tool !== null &&
-                        "type" in tool &&
-                        tool.type === "custom" &&
-                        "modulePath" in tool &&
-                        tool.modulePath === targetPath);
-                    if (existingIndex >= 0) {
-                        // Update existing config
-                        agentDef.tools[existingIndex] = customTool;
-                    }
-                    else {
-                        // Add new config
-                        agentDef.tools.push(customTool);
-                    }
-                    // 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
-                }
-            }
-            // Clean up temp file
-            try {
-                unlinkSync(tempFilePath);
-            }
-            catch (error) {
-                // Ignore cleanup errors
-            }
-            setConfig(toolConfig);
-            setSaveStatus("done");
-        }
-        catch (error) {
-            setSaveStatus("error");
-            setSaveError(error instanceof Error ? error.message : "Unknown error occurred");
-        }
-    };
-    // Wait for editor to open and close before showing UI
-    if (!editorOpened) {
-        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "Opening editor..." }) }));
-    }
-    // If there was an error during editor setup, show done stage with error
-    if (saveStatus === "error" && stage === "done") {
-        return (_jsx(DoneStage, { config: config, status: saveStatus, error: saveError, attachedAgents: selectedAgents }));
-    }
-    // Name input stage
-    if (stage === "name") {
-        return (_jsx(NameInputStage, { value: nameInput, onChange: setNameInput, onNext: (name) => {
-                setConfig({ ...config, name });
-                setStage("agentSelection");
-            }, onBack: () => {
-                // Clean up temp file
-                if (tempFilePath) {
-                    try {
-                        unlinkSync(tempFilePath);
-                    }
-                    catch (error) {
-                        // Ignore cleanup errors
-                    }
-                }
-                exit();
-            } }));
-    }
-    // Agent selection stage
-    if (stage === "agentSelection") {
-        return (_jsx(AgentSelectionStage, { selectedAgents: selectedAgents, onSelectedAgentsChange: setSelectedAgents, onNext: () => {
-                if (!config.name) {
-                    setSaveStatus("error");
-                    setSaveError("Tool name is required");
-                    setStage("done");
-                    return;
-                }
-                handleSave(config.name, selectedAgents);
-                setStage("done");
-            }, onBack: () => setStage("name") }));
-    }
-    // Done stage
-    if (stage === "done") {
-        return (_jsx(DoneStage, { config: config, status: saveStatus, error: saveError, attachedAgents: selectedAgents }));
-    }
-    return null;
-}
-// ============================================================================
-// Export and Runner
-// ============================================================================
-export default ToolStubApp;
-export async function runToolStub(props = {}) {
-    // Set stdin to raw mode to capture input
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-    }
-    const { waitUntilExit } = render(_jsx(ToolStubApp, { ...props }));
-    // Wait for the app to exit before returning
-    await waitUntilExit();
-}