@townco/cli 0.1.72 → 0.1.74

package/dist/commands/batch.d.ts

@@ -0,0 +1,8 @@
+export interface BatchCommandOptions {
+    name: string;
+    queries?: string[];
+    file?: string;
+    concurrency?: number;
+    port?: number;
+}
+export declare function batchCommand(options: BatchCommandOptions): Promise<void>;

package/dist/commands/batch.js

@@ -0,0 +1,270 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { isInsideTownProject } from "@townco/agent/storage";
+import { createLogger } from "@townco/core";
+import { AcpClient } from "@townco/ui";
+import { findAvailablePort } from "../lib/port-utils.js";
+// Helper to wait for server to be ready
+async function waitForServer(url, maxRetries = 30) {
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            const response = await fetch(url);
+            if (response.ok) {
+                return true;
+            }
+        }
+        catch {
+            // Server not ready yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return false;
+}
+// Run a single query
+async function runQuery(agentPort, query, queryNum, total, logger) {
+    logger.info("Starting query", { queryNum, total, query });
+    console.log(`[${queryNum}/${total}] Starting: "${query}"`);
+    const client = new AcpClient({
+        type: "http",
+        options: {
+            baseUrl: `http://localhost:${agentPort}`,
+        },
+    });
+    try {
+        // Connect and create a new session
+        await client.connect();
+        const sessionId = await client.startSession();
+        if (!sessionId) {
+            throw new Error("Failed to create session");
+        }
+        logger.info("Session created", { sessionId });
+        console.log(`[${queryNum}/${total}] Session: ${sessionId}`);
+        // Send the query
+        await client.sendMessage(query, sessionId);
+        // Collect the response (but don't print it - just wait for completion)
+        for await (const chunk of client.receiveMessages()) {
+            if (chunk.type === "content" && chunk.isComplete) {
+                break;
+            }
+        }
+        console.log(`[${queryNum}/${total}] ✓ Completed`);
+        logger.info("Query completed", { queryNum });
+        await client.disconnect();
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`[${queryNum}/${total}] ✗ Error: ${errorMsg}`);
+        logger.error("Query failed", { queryNum, error: errorMsg });
+        await client.disconnect();
+        throw error;
+    }
+}
+// Run queries in batches with concurrency limit
+async function runQueriesWithConcurrency(agentPort, queries, concurrency, logger) {
+    const total = queries.length;
+    let completed = 0;
+    let currentIndex = 0;
+    // Worker function
+    const worker = async () => {
+        while (currentIndex < queries.length) {
+            const index = currentIndex++;
+            const query = queries[index];
+            if (!query)
+                continue; // Skip if undefined (shouldn't happen)
+            const queryNum = index + 1;
+            try {
+                await runQuery(agentPort, query, queryNum, total, logger);
+                completed++;
+            }
+            catch (error) {
+                console.error(`Query ${queryNum} failed:`, error);
+                completed++;
+            }
+        }
+    };
+    // Start workers
+    const workers = Array.from({ length: concurrency }, () => worker());
+    await Promise.all(workers);
+    console.log(`\n✓ All ${completed}/${total} queries completed\n`);
+    logger.info("All queries completed", { total, completed });
+}
+export async function batchCommand(options) {
+    const { name, queries: inlineQueries = [], file, concurrency = 10, port = 3100, } = options;
+    const logger = createLogger("batch-command", "debug");
+    // Check if we're inside a Town project
+    const projectRoot = await isInsideTownProject();
+    if (projectRoot === null) {
+        console.error("Error: Not inside a Town project.");
+        console.log("\nPlease run this command inside a project directory, or run:\n" +
+            "  town create --init <path>\n" +
+            "to create a project.");
+        process.exit(1);
+    }
+    // Load queries from file or use inline queries
+    let queries = [];
+    if (file !== undefined) {
+        const filePath = file; // Type narrowing for TypeScript
+        try {
+            const content = await readFile(filePath, "utf-8");
+            // Split by newlines, trim, and filter empty lines
+            queries = content
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0 && !line.startsWith("#"));
+            if (queries.length === 0) {
+                console.error(`Error: No queries found in file: ${filePath}`);
+                process.exit(1);
+            }
+            console.log(`Loaded ${queries.length} queries from ${filePath}\n`);
+        }
+        catch (error) {
+            console.error(`Error reading file: ${filePath}`);
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    else if (inlineQueries.length > 0) {
+        queries = inlineQueries;
+    }
+    else {
+        console.error("Error: No queries provided.");
+        console.log("\nUsage:");
+        console.log('  town batch <agent> "query1" "query2" ...');
+        console.log("  town batch <agent> --file queries.txt");
+        process.exit(1);
+    }
+    console.log(`=== Batch Query Execution ===`);
+    console.log(`Agent: ${name}`);
+    console.log(`Queries: ${queries.length}`);
+    console.log(`Concurrency: ${concurrency}\n`);
+    const agentPath = join(projectRoot, "agents", name);
+    const binPath = join(agentPath, "bin.ts");
+    const tracesDbPath = join(agentPath, ".traces.db");
+    // Check if agent exists
+    try {
+        const { stat } = await import("node:fs/promises");
+        await stat(agentPath);
+    }
+    catch {
+        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 agent display name for debugger
+    let agentDisplayName = name;
+    try {
+        const agentIndexPath = join(agentPath, "index.ts");
+        const content = await readFile(agentIndexPath, "utf-8");
+        const displayNameMatch = content.match(/displayName:\s*["']([^"']+)["']/);
+        if (displayNameMatch?.[1]) {
+            agentDisplayName = displayNameMatch[1];
+        }
+    }
+    catch {
+        // Fallback to directory name
+    }
+    let debuggerProcess = null;
+    let agentProcess = null;
+    // Cleanup function
+    const cleanup = () => {
+        logger.info("Cleaning up processes");
+        if (agentProcess?.pid) {
+            try {
+                process.kill(-agentProcess.pid, "SIGINT");
+            }
+            catch (e) {
+                // Process may already be dead
+            }
+        }
+        if (debuggerProcess?.pid) {
+            try {
+                process.kill(-debuggerProcess.pid, "SIGKILL");
+            }
+            catch (e) {
+                // Process may already be dead
+            }
+        }
+    };
+    // Register cleanup handlers
+    process.on("SIGINT", () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+    });
+    try {
+        // 1. Start debugger process
+        console.log("Starting debugger...");
+        const debuggerPkgPath = require.resolve("@townco/debugger/package.json");
+        const debuggerDir = dirname(debuggerPkgPath);
+        debuggerProcess = spawn("bun", ["src/index.ts"], {
+            cwd: debuggerDir,
+            stdio: "ignore",
+            detached: true,
+            env: {
+                ...process.env,
+                DB_PATH: tracesDbPath,
+                AGENT_NAME: agentDisplayName,
+            },
+        });
+        // Wait for debugger to be ready
+        const debuggerReady = await waitForServer("http://localhost:4318/health");
+        if (!debuggerReady) {
+            throw new Error("Debugger failed to start");
+        }
+        console.log("✓ Debugger ready (UI: http://localhost:4000)\n");
+        logger.info("Debugger started");
+        // 2. Start agent HTTP server
+        console.log("Starting agent HTTP server...");
+        // Find available port
+        const availablePort = await findAvailablePort(port);
+        if (availablePort !== port) {
+            console.log(`Port ${port} in use, using port ${availablePort} instead`);
+        }
+        agentProcess = spawn("bun", [binPath, "http"], {
+            cwd: agentPath,
+            stdio: "ignore",
+            detached: true,
+            env: {
+                ...process.env,
+                PORT: String(availablePort),
+                ENABLE_TELEMETRY: "true",
+            },
+        });
+        // Wait for agent to be ready
+        const agentReady = await waitForServer(`http://localhost:${availablePort}/health`);
+        if (!agentReady) {
+            throw new Error("Agent failed to start");
+        }
+        console.log(`✓ Agent ready (port ${availablePort})\n`);
+        logger.info("Agent started", { port: availablePort });
+        // 3. Run queries in parallel
+        console.log(`Running ${queries.length} queries...\n`);
+        await runQueriesWithConcurrency(availablePort, queries, concurrency, logger);
+        // 4. Give telemetry time to flush
+        console.log("Flushing telemetry data...");
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+        console.log("========================================");
+        console.log(`✓ All ${queries.length} queries completed!`);
+        console.log("");
+        console.log("Results saved to:");
+        console.log(`  Sessions: agents/${name}/.sessions/`);
+        console.log(`  Traces:   agents/${name}/.traces.db`);
+        console.log("");
+        console.log("View traces at: http://localhost:4000");
+        console.log("========================================");
+    }
+    catch (error) {
+        console.error("\nError:", error instanceof Error ? error.message : String(error));
+        logger.error("Batch command failed", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        process.exit(1);
+    }
+    finally {
+        cleanup();
+    }
+}

package/dist/commands/login.js

@@ -1,4 +1,4 @@
-import { clearAuthCredentials, getAuthFilePath, getShedUrl, loadAuthCredentials, saveAuthCredentials, } from "@townco/core/auth";
+import { clearAuthCredentials, getShedUrl, loadAuthCredentialsFromDisk, saveAuthCredentials, } from "@townco/core/auth";
 import inquirer from "inquirer";
 // ============================================================================
 // Command Implementation
@@ -7,7 +7,7 @@ export async function loginCommand() {
     const shedUrl = getShedUrl();
     console.log("Town Login\n");
     // Check if already logged in
-    const existingCredentials = loadAuthCredentials();
+    const existingCredentials = loadAuthCredentialsFromDisk();
     if (existingCredentials) {
         console.log(`Currently logged in as: ${existingCredentials.user.email}`);
         console.log(`Shed URL: ${existingCredentials.shed_url}\n`);
@@ -93,9 +93,9 @@ export async function loginCommand() {
             user: data.user,
             shed_url: shedUrl,
         };
-        saveAuthCredentials(credentials);
+        const authFilePath = saveAuthCredentials(credentials);
         console.log(`\nLogged in as ${data.user.email}`);
-        console.log(`Credentials saved to ${getAuthFilePath()}`);
+        console.log(`Credentials saved to ${authFilePath}`);
     }
     catch (error) {
         if (error instanceof TypeError && error.message.includes("fetch")) {

package/dist/commands/run.d.ts

@@ -2,6 +2,8 @@ export interface RunCommandOptions {
     name: string;
     http?: boolean;
     gui?: boolean;
+    cli?: boolean;
+    prompt?: string;
     port?: number;
     noSession?: boolean;
 }

package/dist/commands/run.js

@@ -146,8 +146,235 @@ async function loadEnvVars(projectRoot, logger) {
     }
     return envVars;
 }
+// CLI mode runner - outputs directly to stdout without React UI
+async function runCliMode(options) {
+    const { binPath, workingDir, prompt, configEnvVars, noSession, waitForDebugger = false, } = options;
+    // Wait for debugger to be ready BEFORE starting agent
+    if (waitForDebugger) {
+        let debuggerReady = false;
+        let retries = 30; // 3 seconds
+        while (!debuggerReady && retries > 0) {
+            try {
+                const response = await fetch(`http://localhost:4318/v1/traces`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({}),
+                });
+                // Even a 405 or 400 means the server is up and responding
+                debuggerReady = true;
+                break;
+            }
+            catch (e) {
+                // Server not ready yet
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            retries--;
+        }
+        if (!debuggerReady) {
+            process.stderr.write("Warning: Debugger did not start in time, traces may not be collected\n");
+        }
+    }
+    // Start HTTP server for the agent (silently in CLI mode)
+    // Find available port
+    const { findAvailablePort } = await import("../lib/port-utils.js");
+    const agentPort = await findAvailablePort(3100);
+    // Spawn agent process with HTTP mode
+    const agentProcess = spawn("bun", [binPath, "http"], {
+        cwd: workingDir,
+        stdio: ["ignore", "inherit", "inherit"], // Show agent output for debugging
+        detached: true,
+        env: {
+            ...process.env,
+            ...configEnvVars,
+            PORT: String(agentPort),
+            ENABLE_TELEMETRY: "true",
+            ...(noSession ? { TOWN_NO_SESSION: "true" } : {}),
+        },
+    });
+    // Log any agent errors
+    agentProcess.on("error", (err) => {
+        process.stderr.write(`Agent process error: ${err.message}\n`);
+    });
+    agentProcess.on("exit", () => {
+        // Agent exit is expected, no need to log in CLI mode
+    });
+    // Wait for server to be ready
+    let serverReady = false;
+    let retries = 30; // 15 seconds
+    while (!serverReady && retries > 0) {
+        try {
+            const response = await fetch(`http://localhost:${agentPort}/health`);
+            if (response.ok) {
+                serverReady = true;
+                break;
+            }
+        }
+        catch {
+            // Server not ready yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        retries--;
+    }
+    if (!serverReady) {
+        process.stderr.write("Agent failed to start\n");
+        agentProcess.kill();
+        process.exit(1);
+    }
+    // Create ACP client with HTTP transport
+    const client = new AcpClient({
+        type: "http",
+        options: {
+            baseUrl: `http://localhost:${agentPort}`,
+        },
+    });
+    // Connect the client
+    await client.connect();
+    try {
+        // Start session
+        const sessionId = await client.startSession();
+        if (!sessionId) {
+            process.stderr.write("Failed to create session\n");
+            process.exit(1);
+        }
+        // Echo the user prompt
+        console.log("\n> User:", prompt);
+        console.log();
+        // Send message (HTTP transport works properly)
+        await client.sendMessage(prompt, sessionId);
+        // Track tool calls and message state
+        const toolCalls = new Map();
+        let currentAssistantMessage = "";
+        let isStreamingText = false;
+        // Receive and render messages
+        for await (const chunk of client.receiveMessages()) {
+            if (chunk.type === "content") {
+                // Content chunk - text streaming
+                if (chunk.contentDelta?.type === "text") {
+                    // Stream assistant text response
+                    if (!isStreamingText) {
+                        process.stdout.write("⏺ Assistant: ");
+                        isStreamingText = true;
+                    }
+                    process.stdout.write(chunk.contentDelta.text);
+                    currentAssistantMessage += chunk.contentDelta.text;
+                }
+                // Check if complete after processing content
+                if (chunk.isComplete) {
+                    if (isStreamingText) {
+                        console.log("\n");
+                        isStreamingText = false;
+                    }
+                    break;
+                }
+            }
+            else if (chunk.type === "tool_call") {
+                // New tool call
+                if (isStreamingText) {
+                    console.log("\n");
+                    isStreamingText = false;
+                }
+                const toolCall = chunk.toolCall;
+                toolCalls.set(toolCall.id, {
+                    id: toolCall.id,
+                    name: toolCall.title || toolCall.name,
+                    prettyName: toolCall.prettyName,
+                    status: toolCall.status || "pending",
+                    input: toolCall.rawInput,
+                });
+                const prettyName = toolCall.prettyName || toolCall.title || toolCall.name;
+                console.log(`\n🔧 Tool: ${prettyName}`);
+                console.log(`   Status: ${toolCall.status || "pending"}`);
+                if (toolCall.rawInput && Object.keys(toolCall.rawInput).length > 0) {
+                    console.log(`   Input: ${JSON.stringify(toolCall.rawInput, null, 2).split("\n").join("\n   ")}`);
+                }
+            }
+            else if (chunk.type === "tool_call_update") {
+                // Update existing tool call
+                const toolCallUpdate = chunk.toolCallUpdate;
+                const toolCall = toolCalls.get(toolCallUpdate.id);
+                if (toolCall) {
+                    if (toolCallUpdate.status) {
+                        toolCall.status = toolCallUpdate.status;
+                    }
+                    if (toolCallUpdate.rawInput) {
+                        toolCall.input = toolCallUpdate.rawInput;
+                    }
+                    // Print status update
+                    const prettyName = toolCall.prettyName || toolCall.name;
+                    if (toolCallUpdate.status) {
+                        console.log(`\n🔧 Tool: ${prettyName}`);
+                        console.log(`   Status: ${toolCallUpdate.status}`);
+                    }
+                    // Handle tool output
+                    if (toolCallUpdate.content && Array.isArray(toolCallUpdate.content)) {
+                        let outputText = "";
+                        for (const block of toolCallUpdate.content) {
+                            if (block.type === "content" && block.content.type === "text") {
+                                outputText += block.content.text;
+                            }
+                        }
+                        if (outputText) {
+                            toolCall.output = outputText;
+                            // Truncate very long output
+                            const maxOutputLength = 500;
+                            if (outputText.length > maxOutputLength) {
+                                const truncated = outputText.substring(0, maxOutputLength);
+                                console.log(`   Output: ${truncated}...`);
+                                console.log(`   (${outputText.length} characters, truncated)`);
+                            }
+                            else {
+                                console.log(`   Output: ${outputText}`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Final newline
+        if (isStreamingText) {
+            console.log("\n");
+        }
+        // Disconnect client and cleanup
+        await client.disconnect();
+        // Gracefully shutdown agent process with SIGINT (triggers telemetry flush)
+        if (agentProcess.pid) {
+            try {
+                process.kill(-agentProcess.pid, "SIGINT");
+                // Wait for agent to fully exit (including telemetry flush)
+                await new Promise((resolve) => {
+                    agentProcess.on("exit", () => resolve());
+                    // Fallback timeout in case agent doesn't exit
+                    setTimeout(() => resolve(), 3000);
+                });
+            }
+            catch (e) {
+                // Process may already be dead
+            }
+        }
+    }
+    catch (error) {
+        console.error("\nError:", error instanceof Error ? error.message : String(error));
+        console.error("Stack:", error instanceof Error ? error.stack : "");
+        try {
+            await client.disconnect();
+        }
+        catch (disconnectError) {
+            console.error("Failed to disconnect:", disconnectError);
+        }
+        // Kill agent process on error
+        if (agentProcess.pid) {
+            try {
+                process.kill(-agentProcess.pid, "SIGKILL");
+            }
+            catch (e) {
+                // Process may already be dead
+            }
+        }
+        process.exit(1);
+    }
+}
 export async function runCommand(options) {
-    const { name, http = false, gui = false, port = 3100, noSession = false, } = options;
+    const { name, http = false, gui = false, cli = false, prompt, port = 3100, noSession = false, } = options;
     // Check if we're inside a Town project
     const projectRoot = await isInsideTownProject();
     if (projectRoot === null) {
@@ -161,43 +388,51 @@ export async function runCommand(options) {
     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
+    // Load agent definition to get displayName and detect MCPs by parsing the file
     let agentDisplayName = name; // Fallback to agent directory name
+    let usesBibliotechaMcp = false;
     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];
+        const displayNameMatch = content.match(/displayName:\s*["']([^"']+)["']/);
+        if (displayNameMatch?.[1]) {
+            agentDisplayName = displayNameMatch[1];
         }
+        // Detect if agent uses bibliotecha MCP
+        // Looking for patterns like: name: "bibliotecha" or name: 'bibliotecha'
+        usesBibliotechaMcp = /name:\s*["']bibliotecha["']/.test(content);
     }
     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)
+    let debuggerProcess = null;
+    let cleanupDebugger = null;
     const debuggerPkgPath = require.resolve("@townco/debugger/package.json");
     const debuggerDir = dirname(debuggerPkgPath);
-    const debuggerProcess = spawn("bun", ["src/index.ts"], {
+    debuggerProcess = spawn("bun", ["src/index.ts"], {
         cwd: debuggerDir,
-        stdio: "inherit",
+        stdio: cli ? "ignore" : "inherit", // Silent in CLI mode
         detached: true,
         env: {
             ...process.env,
-            DB_PATH: join(projectRoot, ".traces.db"),
+            DB_PATH: join(projectRoot, "agents", name, ".traces.db"),
             AGENT_NAME: agentDisplayName,
         },
     });
-    console.log(`Debugger UI: http://localhost:4000`);
+    if (!cli) {
+        console.log(`Debugger UI: http://localhost:4000`);
+    }
     // Cleanup debugger process on exit
     let isDebuggerCleaningUp = false;
-    const cleanupDebugger = () => {
+    cleanupDebugger = () => {
         if (isDebuggerCleaningUp)
             return;
         isDebuggerCleaningUp = true;
-        if (debuggerProcess.pid) {
+        if (debuggerProcess?.pid) {
             try {
                 process.kill(-debuggerProcess.pid, "SIGKILL");
             }
@@ -206,7 +441,11 @@ export async function runCommand(options) {
             }
         }
     };
-    process.on("exit", cleanupDebugger);
+    // Only register exit handler for non-CLI modes
+    // In CLI mode, we cleanup manually after agent exits
+    if (!cli) {
+        process.on("exit", cleanupDebugger);
+    }
     // Check if agent exists
     try {
         const { stat } = await import("node:fs/promises");
@@ -222,7 +461,7 @@ export async function runCommand(options) {
     const logger = createLogger("cli", "debug");
     logger.info("Starting agent", {
         name,
-        mode: gui ? "gui" : http ? "http" : "tui",
+        mode: gui ? "gui" : http ? "http" : cli ? "cli" : "tui",
         agentPath,
     });
     // If GUI mode, run with tabbed interface
@@ -275,15 +514,21 @@ export async function runCommand(options) {
             },
         });
         // Start the GUI dev server (no package.json, run vite directly) with detached process group
-        const guiProcess = spawn("bunx", ["vite", ...(Bun.env.BIND_HOST ? ["--host", Bun.env.BIND_HOST] : [])], {
+        const guiProcess = spawn("bunx", ["vite"], {
             cwd: guiPath,
             stdio: ["ignore", "pipe", "pipe"], // Pipe stdout/stderr for capture
             detached: true,
             env: {
                 ...process.env,
                 ...configEnvVars,
-                VITE_AGENT_URL: `http://${Bun.env.EXT_HOST || "localhost"}:${availablePort}`,
+                VITE_AGENT_URL: `http://localhost:${availablePort}`,
                 VITE_DEBUGGER_URL: "http://localhost:4000",
+                // If agent uses bibliotecha MCP, pass BIBLIOTECHA_URL to GUI for auth
+                ...(usesBibliotechaMcp &&
+                    process.env.BIBLIOTECHA_URL && {
+                    VITE_BIBLIOTECHA_URL: process.env.BIBLIOTECHA_URL,
+                    VITE_BIBLIOTECHA_FRONTEND_URL: process.env.BIBLIOTECHA_FRONTEND_URL,
+                }),
             },
         });
         // Setup cleanup handlers for agent and GUI processes
@@ -310,7 +555,7 @@ export async function runCommand(options) {
                 }
             }
             // Also cleanup debugger
-            cleanupDebugger();
+            cleanupDebugger?.();
         };
         process.on("exit", cleanupProcesses);
         // Handle SIGINT (Control-C) explicitly and exit
@@ -372,7 +617,7 @@ export async function runCommand(options) {
                 }
             }
             // Also cleanup debugger
-            cleanupDebugger();
+            cleanupDebugger?.();
         };
         process.on("exit", cleanupAgentProcess);
         // Handle SIGINT (Control-C) explicitly and exit
@@ -396,6 +641,30 @@ export async function runCommand(options) {
         });
         return;
     }
+    // CLI mode: Run with single prompt and output to stdout
+    if (cli) {
+        if (!prompt) {
+            console.error("Error: --cli mode requires a PROMPT argument");
+            console.log('\nUsage: town run <agent> --cli "your prompt here"');
+            process.exit(1);
+        }
+        logger.info("Starting CLI mode", { name, agentPath, prompt });
+        // Run CLI mode and wait for completion
+        await runCliMode({
+            binPath,
+            agentPath,
+            workingDir: agentPath,
+            prompt,
+            configEnvVars,
+            noSession,
+            waitForDebugger: true, // Wait for debugger to be ready before starting agent
+        });
+        // Agent has exited cleanly, now cleanup debugger
+        if (cleanupDebugger) {
+            cleanupDebugger();
+        }
+        process.exit(0);
+    }
     // Default: Start TUI interface with the agent
     logger.info("Starting TUI mode", { name, agentPath });
     // Clear terminal and move cursor to top
@@ -408,7 +677,7 @@ export async function runCommand(options) {
     }
     // Setup signal handlers for TUI mode
     const handleTuiSigint = () => {
-        cleanupDebugger();
+        cleanupDebugger?.();
         process.exit(0);
     };
     process.on("SIGINT", handleTuiSigint);
@@ -416,7 +685,7 @@ export async function runCommand(options) {
     // 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();
+            cleanupDebugger?.();
         } }));
     await waitUntilExit();
     process.exit(0);

package/dist/commands/whoami.js

@@ -1,12 +1,12 @@
-import { loadAuthCredentials } from "@townco/core/auth";
+import { getShedAuth } from "@townco/core/auth";
 import { authGet } from "../lib/auth-fetch.js";
 export async function whoamiCommand() {
-    const credentials = loadAuthCredentials();
+    const credentials = getShedAuth();
     if (!credentials) {
-        console.log("Not logged in. Run 'town login' to authenticate.");
+        console.log("Not logged in. Run 'town login' or set SHED_API_KEY to authenticate.");
         return;
     }
-    console.log(`Shed URL: ${credentials.shed_url}`);
+    console.log(`Shed URL: ${credentials.shedUrl}`);
     console.log("Verifying credentials...\n");
     try {
         const response = await authGet("/api/cli/me");
@@ -25,7 +25,7 @@ export async function whoamiCommand() {
     }
     catch (error) {
         if (error instanceof TypeError && error.message.includes("fetch")) {
-            console.error(`Could not connect to ${credentials.shed_url}`);
+            console.error(`Could not connect to ${credentials.shedUrl}`);
             console.error("Please check your internet connection and try again.");
         }
         else {

package/dist/index.js

@@ -17,6 +17,7 @@ import walk from "ignore-walk";
 import inquirer from "inquirer";
 import superjson from "superjson";
 import { match } from "ts-pattern";
+import { batchCommand } from "./commands/batch.js";
 import { configureCommand } from "./commands/configure.js";
 import { createCommand } from "./commands/create.js";
 import { createProjectCommand } from "./commands/create-project.js";
@@ -64,9 +65,21 @@ const parser = or(command("deploy", object({ command: constant("deploy") }), {
     name: argument(string({ metavar: "NAME" })),
     http: optional(flag("--http")),
     gui: optional(flag("--gui")),
+    cli: optional(flag("--cli")),
+    prompt: optional(argument(string({ metavar: "PROMPT" }))),
     port: optional(option("-p", "--port", integer())),
     noSession: optional(flag("--no-session")),
-}), { brief: message `Run an agent.` }), command("secret", object({
+}), { brief: message `Run an agent.` }), command("batch", object({
+    command: constant("batch"),
+    name: argument(string({ metavar: "NAME" })),
+    queries: multiple(argument(string({ metavar: "QUERY" }))),
+    file: optional(option("-f", "--file", string())),
+    concurrency: optional(option("-c", "--concurrency", integer())),
+    port: optional(option("-p", "--port", integer())),
+}), {
+    brief: message `Run multiple queries in parallel against an agent.`,
+    description: message `Run multiple queries in parallel, each in its own session. Queries can be provided as arguments or loaded from a file.`,
+}), command("secret", object({
     command: constant("secret"),
     subcommand: or(command("list", object({ action: constant("list") }), {
         brief: message `List secrets.`,
@@ -122,24 +135,18 @@ const main = async (parser, meta) => await match(run(parser, meta))
         ],
     });
     console.log("Creating archive...");
-    const root = await findRoot({ rootMarker: "package.json" });
+    const root = await findRoot();
     const arc = archiver("tar", { gzip: true });
-    const chunks = [];
-    const done = new Promise((ok, err) => {
-        arc.on("data", (chunk) => chunks.push(chunk));
-        arc.on("end", () => ok(Buffer.concat(chunks)));
-        arc.on("error", err);
-    });
     (await walk({ path: root, ignoreFiles: [".gitignore"] }))
         .filter((path) => path.split("/")[0] !== ".git")
         .forEach((path) => {
         if (!fs.statSync(path).isFile())
             return;
-        arc.append(fs.createReadStream(path), { name: path });
+        arc.append(path, { name: path });
     });
     arc.finalize();
     console.log("Uploading archive...");
-    const { sha256, cached } = await client.uploadArchive.mutate(await done);
+    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 }, {
@@ -221,17 +228,39 @@ const main = async (parser, meta) => await match(run(parser, meta))
         }
     }
 })
-    .with({ command: "run" }, async ({ name, http, gui, port, noSession }) => {
+    .with({ command: "run" }, async ({ name, http, gui, cli, prompt, port, noSession }) => {
     const options = {
         name,
         http: http === true,
         gui: gui === true,
+        cli: cli === true,
         noSession: noSession === true,
     };
+    if (prompt !== null && prompt !== undefined) {
+        options.prompt = prompt;
+    }
     if (port !== null && port !== undefined) {
         options.port = port;
     }
     await runCommand(options);
+})
+    .with({ command: "batch" }, async ({ name, queries, file, concurrency, port }) => {
+    const options = {
+        name,
+    };
+    if (queries.length > 0) {
+        options.queries = [...queries]; // Convert readonly array to mutable
+    }
+    if (file !== null && file !== undefined) {
+        options.file = file;
+    }
+    if (concurrency !== null && concurrency !== undefined) {
+        options.concurrency = concurrency;
+    }
+    if (port !== null && port !== undefined) {
+        options.port = port;
+    }
+    await batchCommand(options);
 })
     .with({ command: "secret" }, async ({ subcommand }) => {
     await match(subcommand)

package/dist/lib/auth-fetch.d.ts

@@ -1,12 +1,14 @@
-import { type AuthCredentials } from "@townco/core/auth";
 /**
- * Get valid credentials, refreshing if necessary
- * Throws if not logged in or refresh fails
+ * Get valid credentials, refreshing if necessary.
+ * Checks disk credentials first, then falls back to SHED_API_KEY env var.
+ * Throws if not logged in or refresh fails.
  */
-export declare function getValidCredentials(): Promise<AuthCredentials>;
+export declare function getValidCredentials(): Promise<{
+    accessToken: string;
+    shedUrl: string;
+}>;
 /**
  * Make an authenticated fetch request to shed
- * Automatically refreshes token if expired
  */
 export declare function authFetch(path: string, options?: RequestInit): Promise<Response>;
 /**

package/dist/lib/auth-fetch.js

@@ -1,4 +1,4 @@
-import { isTokenExpired, loadAuthCredentials, saveAuthCredentials, } from "@townco/core/auth";
+import { getShedUrl, isTokenExpired, loadAuthCredentialsFromDisk, saveAuthCredentials, } from "@townco/core/auth";
 // ============================================================================
 // Token Refresh
 // ============================================================================
@@ -32,52 +32,53 @@ async function refreshAccessToken(credentials) {
 // Public API
 // ============================================================================
 /**
- * Get valid credentials, refreshing if necessary
- * Throws if not logged in or refresh fails
+ * Get valid credentials, refreshing if necessary.
+ * Checks disk credentials first, then falls back to SHED_API_KEY env var.
+ * Throws if not logged in or refresh fails.
  */
 export async function getValidCredentials() {
-    const credentials = loadAuthCredentials();
-    if (!credentials) {
-        throw new Error("Not logged in. Run 'town login' first.");
-    }
-    if (isTokenExpired(credentials)) {
-        try {
-            return await refreshAccessToken(credentials);
-        }
-        catch (error) {
-            throw new Error(`Session expired. Please run 'town login' again. (${error instanceof Error ? error.message : String(error)})`);
+    // Try disk credentials first
+    const credentials = loadAuthCredentialsFromDisk();
+    if (credentials) {
+        if (isTokenExpired(credentials)) {
+            try {
+                const refreshed = await refreshAccessToken(credentials);
+                return {
+                    accessToken: refreshed.access_token,
+                    shedUrl: refreshed.shed_url,
+                };
+            }
+            catch (error) {
+                throw new Error(`Session expired. Please run 'town login' again. (${error instanceof Error ? error.message : String(error)})`);
+            }
         }
+        return {
+            accessToken: credentials.access_token,
+            shedUrl: credentials.shed_url,
+        };
+    }
+    // Fall back to SHED_API_KEY
+    const apiKey = process.env.SHED_API_KEY;
+    if (apiKey) {
+        return {
+            accessToken: apiKey,
+            shedUrl: getShedUrl(),
+        };
     }
-    return credentials;
+    throw new Error("Not logged in. Run 'town login' first.");
 }
 /**
  * Make an authenticated fetch request to shed
- * Automatically refreshes token if expired
  */
 export async function authFetch(path, options = {}) {
-    let credentials = await getValidCredentials();
-    const url = path.startsWith("http") ? path : `${credentials.shed_url}${path}`;
+    const credentials = await getValidCredentials();
+    const url = path.startsWith("http") ? path : `${credentials.shedUrl}${path}`;
     const headers = new Headers(options.headers);
-    headers.set("Authorization", `Bearer ${credentials.access_token}`);
-    const response = await fetch(url, {
+    headers.set("Authorization", `Bearer ${credentials.accessToken}`);
+    return fetch(url, {
         ...options,
         headers,
     });
-    // If we get 401, try refreshing once
-    if (response.status === 401) {
-        try {
-            credentials = await refreshAccessToken(credentials);
-            headers.set("Authorization", `Bearer ${credentials.access_token}`);
-            return fetch(url, {
-                ...options,
-                headers,
-            });
-        }
-        catch {
-            throw new Error("Session expired. Please run 'town login' again.");
-        }
-    }
-    return response;
 }
 /**
  * Convenience method for GET requests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -15,7 +15,7 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.64",
+    "@townco/tsconfig": "0.1.66",
     "@types/archiver": "^7.0.0",
     "@types/bun": "^1.3.1",
     "@types/ignore-walk": "^4.0.3",
@@ -25,12 +25,12 @@
   "dependencies": {
     "@optique/core": "^0.6.2",
     "@optique/run": "^0.6.2",
-    "@townco/agent": "0.1.72",
-    "@townco/core": "0.0.45",
-    "@townco/debugger": "0.1.22",
-    "@townco/env": "0.1.17",
-    "@townco/secret": "0.1.67",
-    "@townco/ui": "0.1.67",
+    "@townco/agent": "0.1.74",
+    "@townco/core": "0.0.47",
+    "@townco/debugger": "0.1.24",
+    "@townco/env": "0.1.19",
+    "@townco/secret": "0.1.69",
+    "@townco/ui": "0.1.69",
     "@trpc/client": "^11.7.2",
     "@types/inquirer": "^9.0.9",
     "@types/ws": "^8.5.13",