@townco/cli 0.1.73 → 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;
 }