@townco/cli 0.1.2 → 0.1.4

package/dist/commands/configure.d.ts

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

package/dist/commands/configure.js

@@ -0,0 +1,146 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import inquirer from "inquirer";
+const ENV_KEYS = [
+    {
+        key: "ANTHROPIC_API_KEY",
+        description: "Anthropic API key for Claude models",
+        required: true,
+    },
+    {
+        key: "EXA_API_KEY",
+        description: "Exa API key for web search tool",
+        required: false,
+    },
+    {
+        key: "OPENAI_API_KEY",
+        description: "OpenAI API key (optional, for OpenAI models)",
+        required: false,
+    },
+];
+function getConfigDir() {
+    return join(homedir(), ".config", "town");
+}
+function getEnvFilePath() {
+    return join(getConfigDir(), ".env");
+}
+async function loadExistingEnv() {
+    const envPath = getEnvFilePath();
+    if (!existsSync(envPath)) {
+        return {};
+    }
+    const content = await readFile(envPath, "utf-8");
+    const config = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const [key, ...valueParts] = trimmed.split("=");
+        const value = valueParts.join("=").trim();
+        if (key && value) {
+            config[key.trim()] = value;
+        }
+    }
+    return config;
+}
+async function saveEnv(config) {
+    const configDir = getConfigDir();
+    await mkdir(configDir, { recursive: true });
+    const lines = [
+        "# Town CLI Configuration",
+        "# Environment variables for Town agents",
+        "",
+    ];
+    for (const { key, description } of ENV_KEYS) {
+        const value = config[key];
+        if (value) {
+            lines.push(`# ${description}`);
+            lines.push(`${key}=${value}`);
+            lines.push("");
+        }
+    }
+    await writeFile(getEnvFilePath(), lines.join("\n"), "utf-8");
+}
+export async function configureCommand() {
+    console.log("🔧 Town Configuration\n");
+    const existingConfig = await loadExistingEnv();
+    const hasExisting = Object.keys(existingConfig).length > 0;
+    if (hasExisting) {
+        console.log("Found existing configuration:\n");
+        for (const { key, description } of ENV_KEYS) {
+            const value = existingConfig[key];
+            if (value) {
+                const masked = value.slice(0, 4) + "..." + value.slice(-4);
+                console.log(`  ${key}: ${masked}`);
+            }
+        }
+        console.log("");
+        const { action } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "action",
+                message: "What would you like to do?",
+                choices: [
+                    { name: "Update existing keys", value: "update" },
+                    { name: "Add new keys", value: "add" },
+                    { name: "Reconfigure all keys", value: "reconfigure" },
+                    { name: "Cancel", value: "cancel" },
+                ],
+            },
+        ]);
+        if (action === "cancel") {
+            console.log("Configuration cancelled.");
+            return;
+        }
+        if (action === "reconfigure") {
+            // Clear existing config for fresh start
+            Object.keys(existingConfig).forEach((key) => {
+                delete existingConfig[key];
+            });
+        }
+    }
+    const newConfig = { ...existingConfig };
+    // Prompt for each key
+    for (const { key, description, required } of ENV_KEYS) {
+        const hasValue = !!existingConfig[key];
+        if (hasValue && !hasExisting) {
+            // Skip if we're only adding new keys and this one exists
+            continue;
+        }
+        const { shouldSet } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "shouldSet",
+                message: hasValue
+                    ? `Update ${key}? (${description})`
+                    : `Set ${key}? (${description})`,
+                default: required || !hasValue,
+            },
+        ]);
+        if (shouldSet) {
+            const { value } = await inquirer.prompt([
+                {
+                    type: "password",
+                    name: "value",
+                    message: `Enter ${key}:`,
+                    mask: "*",
+                    validate: (input) => {
+                        if (required && !input.trim()) {
+                            return "This key is required";
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            if (value.trim()) {
+                newConfig[key] = value.trim();
+            }
+        }
+    }
+    // Save configuration
+    await saveEnv(newConfig);
+    console.log(`\n✅ Configuration saved to ${getEnvFilePath()}`);
+    console.log("\nThese environment variables will be automatically loaded when running agents.");
+}

package/dist/commands/run.js

@@ -1,8 +1,37 @@
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { agentExists, getAgentPath } from "@townco/agent/storage";
+async function loadEnvVars() {
+    const envPath = join(homedir(), ".config", "town", ".env");
+    const envVars = {};
+    if (!existsSync(envPath)) {
+        return envVars;
+    }
+    try {
+        const content = await readFile(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const [key, ...valueParts] = trimmed.split("=");
+            const value = valueParts.join("=").trim();
+            if (key && value) {
+                envVars[key.trim()] = value;
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Could not load environment variables from ${envPath}`);
+    }
+    return envVars;
+}
 export async function runCommand(options) {
     const { name, http = false, gui = false, port = 3100 } = options;
+    // Load environment variables from ~/.config/town/.env
+    const configEnvVars = await loadEnvVars();
     // Check if agent exists
     const exists = await agentExists(name);
     if (!exists) {
@@ -35,6 +64,7 @@ export async function runCommand(options) {
             stdio: "pipe",
             env: {
                 ...process.env,
+                ...configEnvVars,
                 NODE_ENV: process.env.NODE_ENV || "production",
                 PORT: port.toString(),
             },
@@ -51,6 +81,7 @@ export async function runCommand(options) {
                 stdio: "inherit",
                 env: {
                     ...process.env,
+                    ...configEnvVars,
                     VITE_AGENT_URL: `http://localhost:${port}`,
                 },
             });
@@ -87,6 +118,7 @@ export async function runCommand(options) {
             stdio: "inherit",
             env: {
                 ...process.env,
+                ...configEnvVars,
                 NODE_ENV: process.env.NODE_ENV || "production",
                 PORT: port.toString(),
             },
@@ -105,12 +137,19 @@ export async function runCommand(options) {
     }
     // Default: Start TUI interface with the agent
     console.log(`Starting interactive terminal for agent "${name}"...\n`);
-    // Run the agent in stdio mode directly
-    const tuiProcess = spawn("bun", [binPath, "stdio"], {
+    // Get path to TUI app from CLI package
+    const { fileURLToPath } = await import("node:url");
+    const { dirname } = await import("node:path");
+    const currentFile = fileURLToPath(import.meta.url);
+    const cliRoot = join(dirname(currentFile), "..", "..");
+    const tuiPath = join(cliRoot, "tui", "index.js");
+    // Run TUI with the agent
+    const tuiProcess = spawn("bun", [tuiPath, "--agent", binPath], {
         cwd: agentPath,
         stdio: "inherit",
         env: {
             ...process.env,
+            ...configEnvVars,
             NODE_ENV: process.env.NODE_ENV || "production",
         },
     });

package/dist/index.js

@@ -6,6 +6,7 @@ import { run } from "@optique/run";
 import { createSecret, deleteSecret, genenv, listSecrets } from "@townco/secret";
 import inquirer from "inquirer";
 import { match } from "ts-pattern";
+import { configureCommand } from "./commands/configure.js";
 import { createCommand } from "./commands/create.js";
 import { deleteCommand } from "./commands/delete.js";
 import { editCommand } from "./commands/edit.js";
@@ -25,7 +26,9 @@ async function promptSecret(secretName) {
     ]);
     return answers.value;
 }
-const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy a Town.` }), command("create", object({
+const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy a Town.` }), command("configure", constant("configure"), {
+    brief: message `Configure environment variables.`,
+}), command("create", object({
     command: constant("create"),
     name: optional(option("-n", "--name", string())),
     model: optional(option("-m", "--model", string())),
@@ -69,6 +72,9 @@ async function main(parser, meta) {
     await match(result)
         // TODO
         .with("deploy", async () => { })
+        .with("configure", async () => {
+        await configureCommand();
+    })
         .with({ command: "create" }, async ({ name, model, tools, systemPrompt }) => {
         // Create command starts a long-running Ink session
         // Only pass defined properties to satisfy exactOptionalPropertyTypes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist",
+    "tui",
     "README.md"
   ],
   "repository": {

package/tui/App.d.ts

@@ -0,0 +1,5 @@
+import type { CliConfig } from "./cli.js";
+export interface AppProps {
+    config: CliConfig;
+}
+export declare function App({ config }: AppProps): import("react/jsx-runtime").JSX.Element;

package/tui/App.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AcpClient } from "@townco/ui";
+import { ChatView } from "@townco/ui/tui";
+import { Box, Text } from "ink";
+import { useMemo } from "react";
+export function App({ config }) {
+    // Create ACP client
+    const client = useMemo(() => {
+        try {
+            const newClient = new AcpClient({
+                type: "stdio",
+                options: {
+                    agentPath: config.agentPath,
+                    workingDirectory: config.workingDir ?? process.cwd(),
+                },
+            });
+            return newClient;
+        }
+        catch (error) {
+            console.error("Failed to create client:", error);
+            return null;
+        }
+    }, [config.agentPath, config.workingDir]);
+    if (!client) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "red", bold: true, children: "Error: Failed to create ACP client" }), _jsx(Text, { color: "gray", children: "Please check your agent path and try again." })] }));
+    }
+    return _jsx(ChatView, { client: client });
+}

package/tui/cli.d.ts

@@ -0,0 +1,12 @@
+import type { InferValue } from "@optique/core/parser";
+/**
+ * CLI configuration using Optique
+ */
+export declare const cliParser: import("@optique/core/parser").Parser<{
+    readonly agentPath: string;
+    readonly workingDir: string | undefined;
+}, {
+    readonly agentPath: import("@optique/core/valueparser").ValueParserResult<string> | undefined;
+    readonly workingDir: [[import("@optique/core/valueparser").ValueParserResult<string> | undefined] | undefined] | undefined;
+}>;
+export type CliConfig = InferValue<typeof cliParser>;

package/tui/cli.js

@@ -0,0 +1,14 @@
+import { text } from "@optique/core/message";
+import { object, option, optional, withDefault } from "@optique/core/parser";
+import { string } from "@optique/core/valueparser";
+/**
+ * CLI configuration using Optique
+ */
+export const cliParser = object({
+    agentPath: option("-a", "--agent", string(), {
+        description: [text("Path to the ACP agent executable")],
+    }),
+    workingDir: withDefault(optional(option("-d", "--dir", string(), {
+        description: [text("Working directory for the agent")],
+    })), process.cwd()),
+});

package/tui/index.d.ts

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

package/tui/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { run } from "@optique/run";
+import { render } from "ink";
+import { App } from "./App.js";
+import { cliParser } from "./cli.js";
+/**
+ * Agent Hub TUI
+ * Terminal chat interface for ACP agents
+ */
+async function main() {
+    // Parse CLI arguments
+    const config = run(cliParser, {
+        help: "both", // Show help for both commands and the program
+        programName: "agent-tui",
+        description: [
+            {
+                type: "text",
+                text: "Terminal chat interface for Agent Client Protocol (ACP) agents",
+            },
+        ],
+        version: "0.0.1",
+    });
+    // Render the app
+    render(_jsx(App, { config: config }));
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});