@townco/cli 0.1.55 → 0.1.56

package/README.md

@@ -64,3 +64,5 @@ npx @townco/cli delete my-agent
 
 - `todo_write` - Task management
 - `web_search` - Web search (requires EXA_API_KEY)
+- `generate_image` - Image generation (requires GEMINI_API_KEY)
+- `browser` - Browser automation (requires KERNEL_API_KEY)

package/dist/commands/create.js

@@ -48,6 +48,16 @@ const AVAILABLE_TOOLS = [
         value: "filesystem",
         description: "Read, write, and search files in the project directory",
     },
+    {
+        label: "Generate Image",
+        value: "generate_image",
+        description: "Generate images using Google's Gemini model (requires GEMINI_API_KEY)",
+    },
+    {
+        label: "Browser",
+        value: "browser",
+        description: "Cloud browser automation (requires KERNEL_API_KEY)",
+    },
 ];
 function NameInput({ nameInput, setNameInput, onSubmit }) {
     useInput((_input, key) => {

package/dist/commands/login.js

@@ -1,5 +1,5 @@
+import { clearAuthCredentials, getAuthFilePath, getShedUrl, loadAuthCredentials, saveAuthCredentials, } from "@townco/core/auth";
 import inquirer from "inquirer";
-import { clearAuthCredentials, getAuthFilePath, getShedUrl, loadAuthCredentials, saveAuthCredentials, } from "../lib/auth-storage.js";
 // ============================================================================
 // Command Implementation
 // ============================================================================

package/dist/commands/run.js

@@ -159,27 +159,54 @@ export async function runCommand(options) {
     }
     // Load environment variables from project .env
     const configEnvVars = await loadEnvVars(projectRoot);
+    // Resolve agent path to load agent definition
+    const agentPath = join(projectRoot, "agents", name);
+    // Load agent definition to get displayName by parsing the file
+    let agentDisplayName = name; // Fallback to agent directory name
+    try {
+        const agentIndexPath = join(agentPath, "index.ts");
+        const content = await readFile(agentIndexPath, "utf-8");
+        // Match displayName in the agent definition object
+        // Looking for patterns like: displayName: "Researcher" or displayName: 'Researcher'
+        const match = content.match(/displayName:\s*["']([^"']+)["']/);
+        if (match?.[1]) {
+            agentDisplayName = match[1];
+        }
+    }
+    catch (error) {
+        // If we can't read the agent definition, just use the directory name
+        // Silently fail - the directory name is a reasonable fallback
+    }
     // Start the debugger server as subprocess (OTLP collector + UI)
     const debuggerPkgPath = require.resolve("@townco/debugger/package.json");
     const debuggerDir = dirname(debuggerPkgPath);
     const debuggerProcess = spawn("bun", ["src/index.ts"], {
         cwd: debuggerDir,
         stdio: "inherit",
+        detached: true,
         env: {
             ...process.env,
             DB_PATH: join(projectRoot, ".traces.db"),
+            AGENT_NAME: agentDisplayName,
         },
     });
     console.log(`Debugger UI: http://localhost:4000`);
     // Cleanup debugger process on exit
+    let isDebuggerCleaningUp = false;
     const cleanupDebugger = () => {
-        debuggerProcess.kill();
+        if (isDebuggerCleaningUp)
+            return;
+        isDebuggerCleaningUp = true;
+        if (debuggerProcess.pid) {
+            try {
+                process.kill(-debuggerProcess.pid, "SIGKILL");
+            }
+            catch (e) {
+                // Process may already be dead
+            }
+        }
     };
     process.on("exit", cleanupDebugger);
-    process.on("SIGINT", cleanupDebugger);
-    process.on("SIGTERM", cleanupDebugger);
-    // Resolve agent path within the project
-    const agentPath = join(projectRoot, "agents", name);
     // Check if agent exists
     try {
         const { stat } = await import("node:fs/promises");
@@ -260,11 +287,15 @@ export async function runCommand(options) {
             },
         });
         // Setup cleanup handlers for agent and GUI processes
+        let isCleaningUp = false;
         const cleanupProcesses = () => {
+            if (isCleaningUp)
+                return;
+            isCleaningUp = true;
             // Kill entire process group by using negative PID
             if (agentProcess.pid) {
                 try {
-                    process.kill(-agentProcess.pid, "SIGTERM");
+                    process.kill(-agentProcess.pid, "SIGKILL");
                 }
                 catch (e) {
                     // Process may already be dead
@@ -272,35 +303,26 @@ export async function runCommand(options) {
             }
             if (guiProcess.pid) {
                 try {
-                    process.kill(-guiProcess.pid, "SIGTERM");
+                    process.kill(-guiProcess.pid, "SIGKILL");
                 }
                 catch (e) {
                     // Process may already be dead
                 }
             }
+            // Also cleanup debugger
+            cleanupDebugger();
         };
         process.on("exit", cleanupProcesses);
-        process.on("SIGINT", cleanupProcesses);
-        process.on("SIGTERM", cleanupProcesses);
+        // Handle SIGINT (Control-C) explicitly and exit
+        const handleSigint = () => {
+            cleanupProcesses();
+            process.exit(0);
+        };
+        process.on("SIGINT", handleSigint);
+        process.on("SIGTERM", handleSigint);
         // Render the tabbed UI with dynamic port detection
         const { waitUntilExit } = render(_jsx(GuiRunner, { agentProcess: agentProcess, guiProcess: guiProcess, agentPort: availablePort, agentPath: agentPath, logger: logger, onExit: () => {
-                // Kill entire process group by using negative PID
-                if (agentProcess.pid) {
-                    try {
-                        process.kill(-agentProcess.pid, "SIGTERM");
-                    }
-                    catch (e) {
-                        // Process may already be dead
-                    }
-                }
-                if (guiProcess.pid) {
-                    try {
-                        process.kill(-guiProcess.pid, "SIGTERM");
-                    }
-                    catch (e) {
-                        // Process may already be dead
-                    }
-                }
+                cleanupProcesses();
             } }));
         await waitUntilExit();
         process.exit(0);
@@ -336,19 +358,30 @@ export async function runCommand(options) {
             },
         });
         // Setup cleanup handler for agent process
+        let isCleaningUp = false;
         const cleanupAgentProcess = () => {
+            if (isCleaningUp)
+                return;
+            isCleaningUp = true;
             if (agentProcess.pid) {
                 try {
-                    process.kill(-agentProcess.pid, "SIGTERM");
+                    process.kill(-agentProcess.pid, "SIGKILL");
                 }
                 catch (e) {
                     // Process may already be dead
                 }
             }
+            // Also cleanup debugger
+            cleanupDebugger();
         };
         process.on("exit", cleanupAgentProcess);
-        process.on("SIGINT", cleanupAgentProcess);
-        process.on("SIGTERM", cleanupAgentProcess);
+        // Handle SIGINT (Control-C) explicitly and exit
+        const handleSigint = () => {
+            cleanupAgentProcess();
+            process.exit(0);
+        };
+        process.on("SIGINT", handleSigint);
+        process.on("SIGTERM", handleSigint);
         agentProcess.on("error", (error) => {
             logger.error("Failed to start agent", { error: error.message });
             console.error(`Failed to start agent: ${error.message}`);
@@ -373,9 +406,17 @@ export async function runCommand(options) {
     if (process.stdin.isTTY) {
         process.stdin.setRawMode(true);
     }
+    // Setup signal handlers for TUI mode
+    const handleTuiSigint = () => {
+        cleanupDebugger();
+        process.exit(0);
+    };
+    process.on("SIGINT", handleTuiSigint);
+    process.on("SIGTERM", handleTuiSigint);
     // Render the tabbed UI with Chat and Logs
     const { waitUntilExit } = render(_jsx(TuiRunner, { agentPath: binPath, workingDir: agentPath, noSession: noSession, onExit: () => {
             // Cleanup is handled by the ACP client disconnect
+            cleanupDebugger();
         } }));
     await waitUntilExit();
     process.exit(0);

package/dist/commands/whoami.js

@@ -1,5 +1,5 @@
+import { loadAuthCredentials } from "@townco/core/auth";
 import { authGet } from "../lib/auth-fetch.js";
-import { loadAuthCredentials } from "../lib/auth-storage.js";
 export async function whoamiCommand() {
     const credentials = loadAuthCredentials();
     if (!credentials) {

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import fs from "node:fs";
 import { join } from "node:path";
 import { argument, command, constant, flag, multiple, object, option, optional, or, } from "@optique/core";
 import { message } from "@optique/core/message";
@@ -6,8 +7,16 @@ import { integer, string } from "@optique/core/valueparser";
 import { run } from "@optique/run";
 import { initForClaudeCode } from "@townco/agent/scaffold";
 import { isInsideTownProject } from "@townco/agent/storage";
-import { createSecret, deleteSecret, genenv, listSecrets, } from "@townco/secret";
+import { router } from "@townco/api";
+import { findRoot } from "@townco/core";
+import { updateSchema as updateEnvSchema } from "@townco/env/update-schema";
+import { createSecret, deleteSecret, genenv, listSecrets, updateSecret, } from "@townco/secret";
+import { createTRPCClient, httpLink, httpSubscriptionLink, splitLink, } from "@trpc/client";
+import archiver from "archiver";
+import { EventSource } from "eventsource";
+import walk from "ignore-walk";
 import inquirer from "inquirer";
+import superjson from "superjson";
 import { match } from "ts-pattern";
 import { configureCommand } from "./commands/configure.js";
 import { createCommand } from "./commands/create.js";
@@ -19,7 +28,7 @@ import { whoamiCommand } from "./commands/whoami.js";
 /**
  * Securely prompt for a secret value without echoing to the terminal
  */
-async function promptSecret(secretName) {
+const promptSecret = async (secretName) => {
     const answers = await inquirer.prompt([
         {
             type: "password",
@@ -29,8 +38,11 @@ async function promptSecret(secretName) {
         },
     ]);
     return answers.value;
-}
-const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy a Town.` }), command("configure", constant("configure"), {
+};
+const parser = or(command("deploy", object({ command: constant("deploy") }), {
+    brief: message `Deploy agents.`,
+    description: message `Deploy agents to the Town cloud.`,
+}), command("configure", constant("configure"), {
     brief: message `Configure environment variables.`,
 }), command("login", constant("login"), {
     brief: message `Log in to Town Shed.`,
@@ -57,14 +69,23 @@ const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy
     noSession: optional(flag("--no-session")),
 }), { brief: message `Run an agent.` }), command("secret", object({
     command: constant("secret"),
-    subcommand: or(command("list", constant("list"), { brief: message `List secrets.` }), command("add", object({
+    subcommand: or(command("list", object({ action: 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({
+    }), { brief: message `Add a secret.` }), command("update", object({
+        action: constant("update"),
+        name: optional(argument(string({ metavar: "NAME" }))),
+        value: optional(argument(string({ metavar: "VALUE" }))),
+        genenv: optional(flag("-g", "--genenv", {
+            description: message `Regenerate .env file.`,
+        })),
+    }), { brief: message `Update a secret.` }), command("remove", object({
         action: constant("remove"),
         name: argument(string({ metavar: "NAME" })),
-    }), { brief: message `Remove a secret.` }), command("genenv", constant("genenv"), {
+    }), { brief: message `Remove a secret.` }), command("genenv", object({ action: constant("genenv") }), {
         brief: message `Generate .env file.`,
     })),
 }), { brief: message `Secrets management.` }));
@@ -76,136 +97,213 @@ const meta = {
     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("configure", async () => {
-        await configureCommand();
-    })
-        .with("login", async () => {
-        await loginCommand();
-    })
-        .with("whoami", async () => {
-        await whoamiCommand();
-    })
-        .with("upgrade", async () => {
-        await upgradeCommand();
-    })
-        .with({ command: "create" }, async ({ name, model, tools, systemPrompt, init, claude }) => {
-        // Handle --claude flag (initialize .claude in existing project)
-        if (claude === true) {
-            if (init !== null && init !== undefined) {
-                console.error("Error: --claude flag is redundant with --init (projects include .claude by default)");
-                process.exit(1);
-            }
-            // Check if we're in a Town project
-            const projectRoot = await isInsideTownProject();
-            if (projectRoot === null) {
-                console.error("Error: Not inside a Town project. Use 'town create --init <path>' to create a new project.");
-                process.exit(1);
-            }
-            // Initialize .claude directory only
-            await initForClaudeCode(projectRoot);
-            console.log("\n✓ Claude Code workspace initialized successfully!");
+const main = async (parser, meta) => await match(run(parser, meta))
+    .with("login", loginCommand)
+    .with("whoami", whoamiCommand)
+    .with({ command: "deploy" }, async () => {
+    const url = "http://localhost:3000/api/trpc";
+    const client = createTRPCClient({
+        links: [
+            splitLink({
+                condition: (op) => op.type === "subscription",
+                true: httpSubscriptionLink({
+                    url,
+                    transformer: superjson,
+                    EventSource,
+                }),
+                false: splitLink({
+                    condition: (op) => op.path === router.uploadArchive.name,
+                    true: httpLink({
+                        url,
+                        transformer: { serialize: (o) => o, deserialize: (o) => o },
+                    }),
+                    false: httpLink({ url, transformer: superjson }),
+                }),
+            }),
+        ],
+    });
+    console.log("Creating archive...");
+    const root = await findRoot();
+    const arc = archiver("tar", { gzip: true });
+    (await walk({ path: root, ignoreFiles: [".gitignore"] }))
+        .filter((path) => path.split("/")[0] !== ".git")
+        .forEach((path) => {
+        if (!fs.statSync(path).isFile())
             return;
-        }
-        // Check if --init flag is present for project scaffolding
+        arc.append(path, { name: path });
+    });
+    arc.finalize();
+    console.log("Uploading archive...");
+    const { sha256, cached } = await client.uploadArchive.mutate(Buffer.from(await Array.fromAsync(arc)));
+    console.log(`Archive uploaded: ${sha256} (${cached ? "cached" : "new"})`);
+    console.log("Deploying...");
+    client.deploy.subscribe({ sha256 }, {
+        onData: ({ status }) => console.log(`  ${status}`),
+        onError: (err) => console.error(err),
+        onComplete: () => console.log("\n✓ Deployment complete!"),
+    });
+})
+    .with("configure", configureCommand)
+    .with("upgrade", upgradeCommand)
+    .with({ command: "create" }, async ({ name, model, tools, systemPrompt, init, claude }) => {
+    // Handle --claude flag (initialize .claude in existing project)
+    if (claude === true) {
         if (init !== null && init !== undefined) {
-            // Project mode - scaffold a standalone project
-            await createProjectCommand({
-                path: init,
-            });
+            console.error("Error: --claude flag is redundant with --init (projects include .claude by default)");
+            process.exit(1);
         }
-        else {
-            // Check if we're inside a Town project
-            const projectRoot = await isInsideTownProject();
-            if (projectRoot === null) {
-                // Not in a project - prompt user to initialize
-                const answer = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "initProject",
-                        message: "Not inside a Town project. Initialize project in current directory?",
-                        default: true,
-                    },
-                ]);
-                if (answer.initProject) {
-                    // Initialize project first
-                    await createProjectCommand({ path: process.cwd() });
-                    // Then create agent
-                    await createCommand({
-                        ...(name !== undefined && { name }),
-                        ...(model !== undefined && { model }),
-                        ...(tools.length > 0 && { tools }),
-                        ...(systemPrompt !== undefined && { systemPrompt }),
-                        agentsDir: join(process.cwd(), "agents"),
-                    });
-                }
-                else {
-                    // User declined
-                    console.log("\nPlease run 'town create' inside a project directory, or run:\n" +
-                        "  town create --init <path>\n" +
-                        "to create a project.");
-                    process.exit(1);
-                }
-            }
-            else {
-                // Agent mode - create agent in existing project
-                // Create command starts a long-running Ink session
+        // Check if we're in a Town project
+        const projectRoot = await isInsideTownProject();
+        if (projectRoot === null) {
+            console.error("Error: Not inside a Town project. Use 'town create --init <path>' to create a new project.");
+            process.exit(1);
+        }
+        // Initialize .claude directory only
+        await initForClaudeCode(projectRoot);
+        console.log("\n✓ Claude Code workspace initialized successfully!");
+        return;
+    }
+    // Check if --init flag is present for project scaffolding
+    if (init !== null && init !== undefined) {
+        // Project mode - scaffold a standalone project
+        await createProjectCommand({
+            path: init,
+        });
+    }
+    else {
+        // Check if we're inside a Town project
+        const projectRoot = await isInsideTownProject();
+        if (projectRoot === null) {
+            // Not in a project - prompt user to initialize
+            const answer = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "initProject",
+                    message: "Not inside a Town project. Initialize project in current directory?",
+                    default: true,
+                },
+            ]);
+            if (answer.initProject) {
+                // Initialize project first
+                await createProjectCommand({ path: process.cwd() });
+                // Then create agent
                 await createCommand({
                     ...(name !== undefined && { name }),
                     ...(model !== undefined && { model }),
                     ...(tools.length > 0 && { tools }),
                     ...(systemPrompt !== undefined && { systemPrompt }),
-                    agentsDir: join(projectRoot, "agents"),
+                    agentsDir: join(process.cwd(), "agents"),
                 });
             }
+            else {
+                // User declined
+                console.log("\nPlease run 'town create' inside a project directory, or run:\n" +
+                    "  town create --init <path>\n" +
+                    "to create a project.");
+                process.exit(1);
+            }
         }
-    })
-        .with({ command: "run" }, async ({ name, http, gui, port, noSession }) => {
-        const options = {
-            name,
-            http: http === true,
-            gui: gui === true,
-            noSession: noSession === true,
+        else {
+            // Agent mode - create agent in existing project
+            // Create command starts a long-running Ink session
+            await createCommand({
+                ...(name !== undefined && { name }),
+                ...(model !== undefined && { model }),
+                ...(tools.length > 0 && { tools }),
+                ...(systemPrompt !== undefined && { systemPrompt }),
+                agentsDir: join(projectRoot, "agents"),
+            });
+        }
+    }
+})
+    .with({ command: "run" }, async ({ name, http, gui, port, noSession }) => {
+    const options = {
+        name,
+        http: http === true,
+        gui: gui === true,
+        noSession: noSession === true,
+    };
+    if (port !== null && port !== undefined) {
+        options.port = port;
+    }
+    await runCommand(options);
+})
+    .with({ command: "secret" }, async ({ subcommand }) => {
+    await match(subcommand)
+        .with({ action: "list" }, async () => {
+        const truncate = (str, maxLength = 50) => {
+            if (str.length <= maxLength)
+                return str;
+            return `${str.slice(0, maxLength - 3)}...`;
         };
-        if (port !== null && port !== undefined) {
-            options.port = port;
+        console.table((await listSecrets()).map((secret) => ({
+            Key: secret.key,
+            Valid: secret.valid ? "✓" : "✗",
+            Error: truncate(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 runCommand(options);
+        await createSecret(name, secretValue);
+        await updateEnvSchema();
+        console.log(`Secret '${name}' added successfully (& @packages/env schema updated).`);
     })
-        .with({ command: "secret" }, async ({ subcommand }) => {
-        await match(subcommand)
-            .with("list", async () => {
+        .with({ action: "update" }, async ({ name, value, genenv: regen }) => {
+        let secretName = name;
+        // If name is not provided, show a list prompt to select from existing secrets
+        if (!secretName) {
             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");
+            if (secrets.length === 0) {
+                console.error("No secrets found to update.");
                 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 () => {
+            const answer = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedSecret",
+                    message: "Select a secret to update:",
+                    choices: secrets.map((s) => ({
+                        name: `${s.key} ${s.valid ? "✓" : "✗"}`,
+                        value: s.key,
+                    })),
+                },
+            ]);
+            secretName = answer.selectedSecret;
+        }
+        // If value is not provided, prompt securely
+        if (!secretName) {
+            console.error("Error: Secret name is required");
+            process.exit(1);
+        }
+        const secretValue = value ?? (await promptSecret(secretName));
+        if (!secretValue) {
+            console.error("Error: Secret value cannot be empty");
+            process.exit(1);
+        }
+        await updateSecret(secretName, secretValue);
+        console.log(`Secret '${secretName}' updated successfully.`);
+        if (regen) {
             await genenv();
             console.log(".env file generated successfully.");
-        })
-            .exhaustive();
+        }
+    })
+        .with({ action: "remove" }, async ({ name }) => {
+        await deleteSecret(name);
+        await updateEnvSchema();
+        console.log(`Secret '${name}' removed successfully (& @packages/env schema updated).`);
+    })
+        .with({ action: "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/dist/lib/auth-fetch.d.ts

@@ -1,4 +1,4 @@
-import { type AuthCredentials } from "./auth-storage.js";
+import { type AuthCredentials } from "@townco/core/auth";
 /**
  * Get valid credentials, refreshing if necessary
  * Throws if not logged in or refresh fails

package/dist/lib/auth-fetch.js

@@ -1,4 +1,4 @@
-import { isTokenExpired, loadAuthCredentials, saveAuthCredentials, } from "./auth-storage.js";
+import { isTokenExpired, loadAuthCredentials, saveAuthCredentials, } from "@townco/core/auth";
 // ============================================================================
 // Token Refresh
 // ============================================================================