@townco/cli 0.1.78 → 0.1.79

package/dist/commands/batch.js

@@ -5,6 +5,16 @@ 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 check if server is already running
+async function isServerRunning(url) {
+    try {
+        const response = await fetch(url);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
 // Helper to wait for server to be ready
 async function waitForServer(url, maxRetries = 30) {
     for (let i = 0; i < maxRetries; i++) {
@@ -196,51 +206,67 @@ export async function batchCommand(options) {
         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");
+        // Check if services are already running
+        const debuggerRunning = await isServerRunning("http://localhost:4318/health");
+        const agentRunning = await isServerRunning(`http://localhost:${port}/health`);
+        let availablePort = port;
+        // 1. Start debugger if not running
+        if (debuggerRunning) {
+            console.log("✓ Using existing debugger (UI: http://localhost:4000)\n");
+            logger.info("Debugger already running");
         }
-        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`);
+        else {
+            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");
         }
-        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");
+        // 2. Start agent HTTP server if not running
+        if (agentRunning) {
+            console.log(`✓ Using existing agent (port ${port})\n`);
+            logger.info("Agent already running", { port });
+        }
+        else {
+            console.log("Starting agent HTTP server...");
+            // Find available port
+            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 });
         }
-        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);

package/dist/commands/run.js

@@ -12,7 +12,7 @@ import open from "open";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { LogsPane } from "../components/LogsPane.js";
 import { TabbedOutput } from "../components/TabbedOutput.js";
-import { findAvailablePort } from "../lib/port-utils.js";
+import { ensurePortAvailable } from "../lib/port-utils.js";
 function TuiRunner({ agentPath, workingDir, noSession, onExit, }) {
     const [client, setClient] = useState(null);
     const [error, setError] = useState(null);
@@ -175,14 +175,14 @@ async function runCliMode(options) {
         }
     }
     // 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);
+    // Ensure port is available
+    const { ensurePortAvailable } = await import("../lib/port-utils.js");
+    const agentPort = 3100;
+    await ensurePortAvailable(agentPort, "agent HTTP server");
     // 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,
@@ -337,19 +337,17 @@ async function runCliMode(options) {
         // 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
-            }
+        try {
+            agentProcess.kill("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) {
@@ -362,13 +360,11 @@ async function runCliMode(options) {
             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
-            }
+        try {
+            agentProcess.kill("SIGKILL");
+        }
+        catch (e) {
+            // Process may already be dead
         }
         process.exit(1);
     }
@@ -413,10 +409,14 @@ export async function runCommand(options) {
     let cleanupDebugger = null;
     const debuggerPkgPath = require.resolve("@townco/debugger/package.json");
     const debuggerDir = dirname(debuggerPkgPath);
+    // Check debugger ports are available before starting
+    const debuggerUiPort = 4000;
+    const debuggerOtlpPort = 4318;
+    await ensurePortAvailable(debuggerUiPort, "debugger UI");
+    await ensurePortAvailable(debuggerOtlpPort, "OTLP collector");
     debuggerProcess = spawn("bun", ["src/index.ts"], {
         cwd: debuggerDir,
         stdio: cli ? "ignore" : "inherit", // Silent in CLI mode
-        detached: true,
         env: {
             ...process.env,
             DB_PATH: join(projectRoot, "agents", name, ".traces.db"),
@@ -424,7 +424,7 @@ export async function runCommand(options) {
         },
     });
     if (!cli) {
-        console.log(`Debugger UI: http://localhost:4000`);
+        console.log(`Debugger UI: http://localhost:${debuggerUiPort}`);
     }
     // Cleanup debugger process on exit
     let isDebuggerCleaningUp = false;
@@ -434,7 +434,7 @@ export async function runCommand(options) {
         isDebuggerCleaningUp = true;
         if (debuggerProcess?.pid) {
             try {
-                process.kill(-debuggerProcess.pid, "SIGKILL");
+                debuggerProcess.kill("SIGTERM");
             }
             catch (e) {
                 // Process may already be dead
@@ -479,41 +479,35 @@ export async function runCommand(options) {
             console.log(`Recreate the agent with "town create" to include the GUI.`);
             process.exit(1);
         }
-        // Find an available port for the agent
-        const availablePort = await findAvailablePort(port);
-        if (availablePort !== port) {
-            logger.info("Port in use, using alternative", {
-                requestedPort: port,
-                actualPort: availablePort,
-            });
-            console.log(`Port ${port} is in use, using port ${availablePort} instead`);
-        }
+        // Ensure agent and GUI ports are available (debugger ports already checked above)
+        const guiPort = 5173;
+        await ensurePortAvailable(port, "agent HTTP server");
+        await ensurePortAvailable(guiPort, "GUI dev server");
         logger.info("Starting GUI mode", {
-            agentPort: availablePort,
-            guiPort: 5173,
+            agentPort: port,
+            guiPort,
         });
         console.log(`Starting agent "${name}" with GUI...`);
-        console.log(`Agent HTTP server will run on port ${availablePort}`);
-        console.log(`GUI dev server will run on port 5173\n`);
+        console.log(`Agent HTTP server will run on port ${port}`);
+        console.log(`GUI dev server will run on port ${guiPort}\n`);
         // Set stdin to raw mode for Ink
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
         }
-        // Start the agent in HTTP mode with detached process group
+        // Start the agent in HTTP mode
         const agentProcess = spawn("bun", [binPath, "http"], {
             cwd: agentPath,
             stdio: ["ignore", "pipe", "pipe"], // Pipe stdout/stderr for capture
-            detached: true,
             env: {
                 ...process.env,
                 ...configEnvVars,
                 NODE_ENV: process.env.NODE_ENV || "production",
-                PORT: availablePort.toString(),
+                PORT: port.toString(),
                 ENABLE_TELEMETRY: "true",
                 ...(noSession ? { TOWN_NO_SESSION: "true" } : {}),
             },
         });
-        // Start the GUI dev server (no package.json, run vite directly) with detached process group
+        // Start the GUI dev server (no package.json, run vite directly)
         const viteArgs = ["vite"];
         if (process.env.BIND_HOST) {
             viteArgs.push("--host", process.env.BIND_HOST);
@@ -521,12 +515,11 @@ export async function runCommand(options) {
         const guiProcess = spawn("bunx", viteArgs, {
             cwd: guiPath,
             stdio: ["ignore", "pipe", "pipe"], // Pipe stdout/stderr for capture
-            detached: true,
             env: {
                 ...process.env,
                 ...configEnvVars,
-                VITE_AGENT_URL: `${process.env.EXT_HOST}:${availablePort}`,
-                VITE_DEBUGGER_URL: "http://localhost:4000",
+                VITE_AGENT_URL: `${process.env.EXT_HOST || "http://localhost"}:${port}`,
+                VITE_DEBUGGER_URL: `http://localhost:${debuggerUiPort}`,
                 // If agent uses bibliotecha MCP, pass BIBLIOTECHA_URL to GUI for auth
                 ...(usesBibliotechaMcp &&
                     process.env.BIBLIOTECHA_URL && {
@@ -541,67 +534,62 @@ export async function runCommand(options) {
             if (isCleaningUp)
                 return;
             isCleaningUp = true;
-            // Kill entire process group by using negative PID
-            if (agentProcess.pid) {
-                try {
-                    process.kill(-agentProcess.pid, "SIGKILL");
-                }
-                catch (e) {
-                    // Process may already be dead
-                }
+            // Kill child processes - since they're not detached, they're in our process group
+            try {
+                agentProcess.kill("SIGTERM");
             }
-            if (guiProcess.pid) {
-                try {
-                    process.kill(-guiProcess.pid, "SIGKILL");
-                }
-                catch (e) {
-                    // Process may already be dead
-                }
+            catch (e) {
+                // Process may already be dead
+            }
+            try {
+                guiProcess.kill("SIGTERM");
+            }
+            catch (e) {
+                // Process may already be dead
             }
             // Also cleanup debugger
             cleanupDebugger?.();
         };
-        process.on("exit", cleanupProcesses);
-        // Handle SIGINT (Control-C) explicitly and exit
+        // Render the tabbed UI with dynamic port detection
+        const { waitUntilExit } = render(_jsx(GuiRunner, { agentProcess: agentProcess, guiProcess: guiProcess, agentPort: port, agentPath: agentPath, logger: logger, onExit: () => {
+                cleanupProcesses();
+            } }));
+        // Register signal handlers AFTER Ink render to ensure they take precedence
+        // Use a wrapper that forces cleanup before Ink's handlers can interfere
         const handleSigint = () => {
             cleanupProcesses();
+            // Force exit immediately to prevent Ink from keeping process alive
             process.exit(0);
         };
+        // Remove any existing listeners and add ours with highest priority
+        process.removeAllListeners("SIGINT");
+        process.removeAllListeners("SIGTERM");
         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: () => {
-                cleanupProcesses();
-            } }));
+        process.on("exit", cleanupProcesses);
+        process.on("beforeExit", cleanupProcesses);
         await waitUntilExit();
+        cleanupProcesses();
         process.exit(0);
     }
     else if (http) {
-        // Find an available port for the agent
-        const availablePort = await findAvailablePort(port);
-        if (availablePort !== port) {
-            logger.info("Port in use, using alternative", {
-                requestedPort: port,
-                actualPort: availablePort,
-            });
-            console.log(`Port ${port} is in use, using port ${availablePort} instead\n`);
-        }
-        logger.info("Starting HTTP mode", { port: availablePort });
-        console.log(`Starting agent "${name}" in HTTP mode on port ${availablePort}...`);
+        // Ensure agent port is available (debugger ports already checked above)
+        await ensurePortAvailable(port, "agent HTTP server");
+        logger.info("Starting HTTP mode", { port });
+        console.log(`Starting agent "${name}" in HTTP mode on port ${port}...`);
         console.log(`\nEndpoints:`);
-        console.log(`  http://localhost:${availablePort}/health - Health check`);
-        console.log(`  http://localhost:${availablePort}/rpc - RPC endpoint`);
-        console.log(`  http://localhost:${availablePort}/events - SSE event stream\n`);
-        // Run the agent in HTTP mode with detached process group
+        console.log(`  http://localhost:${port}/health - Health check`);
+        console.log(`  http://localhost:${port}/rpc - RPC endpoint`);
+        console.log(`  http://localhost:${port}/events - SSE event stream\n`);
+        // Run the agent in HTTP mode
         const agentProcess = spawn("bun", [binPath, "http"], {
             cwd: agentPath,
             stdio: "inherit",
-            detached: true,
             env: {
                 ...process.env,
                 ...configEnvVars,
                 NODE_ENV: process.env.NODE_ENV || "production",
-                PORT: availablePort.toString(),
+                PORT: port.toString(),
                 ENABLE_TELEMETRY: "true",
                 ...(noSession ? { TOWN_NO_SESSION: "true" } : {}),
             },
@@ -612,13 +600,11 @@ export async function runCommand(options) {
             if (isCleaningUp)
                 return;
             isCleaningUp = true;
-            if (agentProcess.pid) {
-                try {
-                    process.kill(-agentProcess.pid, "SIGKILL");
-                }
-                catch (e) {
-                    // Process may already be dead
-                }
+            try {
+                agentProcess.kill("SIGTERM");
+            }
+            catch (e) {
+                // Process may already be dead
             }
             // Also cleanup debugger
             cleanupDebugger?.();

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import fs from "node:fs";
+import afs from "node:fs/promises";
 import { join } from "node:path";
 import { argument, command, constant, flag, multiple, object, option, optional, or, } from "@optique/core";
 import { message } from "@optique/core/message";
@@ -7,7 +8,7 @@ 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 { API_ROUTES, findRoot } from "@townco/core";
+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";
@@ -25,6 +26,7 @@ import { loginCommand } from "./commands/login.js";
 import { runCommand } from "./commands/run.js";
 import { upgradeCommand } from "./commands/upgrade.js";
 import { whoamiCommand } from "./commands/whoami.js";
+import { getValidCredentials } from "./lib/auth-fetch";
 /**
  * Securely prompt for a secret value without echoing to the terminal
  */
@@ -39,7 +41,10 @@ const promptSecret = async (secretName) => {
     ]);
     return answers.value;
 };
-const parser = or(command("deploy", object({ command: constant("deploy") }), {
+const parser = or(command("deploy", object({
+    command: constant("deploy"),
+    agent: option("-a", "--agent", string()),
+}), {
     brief: message `Deploy agents.`,
     description: message `Deploy agents to the Town cloud.`,
 }), command("configure", constant("configure"), {
@@ -112,45 +117,57 @@ const meta = {
 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";
+    .with({ command: "deploy" }, async ({ agent }) => {
+    const projectRoot = await isInsideTownProject();
+    if (!projectRoot)
+        throw new Error("Not inside a Town project");
+    if (!(await afs.exists(join(projectRoot, "agents", agent))))
+        throw new Error(`Agent ${agent} not found`);
+    const { accessToken, shedUrl } = await getValidCredentials();
+    const authHeader = { Authorization: `Bearer ${accessToken}` };
+    const url = `${shedUrl}/api/trpc`;
+    const baseLinkOpts = { url, transformer: superjson };
     const client = createTRPCClient({
         links: [
             splitLink({
                 condition: (op) => op.type === "subscription",
                 true: httpSubscriptionLink({
-                    url,
-                    transformer: superjson,
+                    ...baseLinkOpts,
                     EventSource,
+                    eventSourceOptions: {
+                        fetch: async (url, init) => fetch(url, {
+                            ...init,
+                            headers: { ...init.headers, ...authHeader },
+                        }),
+                    },
                 }),
-                false: splitLink({
-                    condition: (op) => op.path === API_ROUTES.UPLOAD_ARCHIVE,
-                    true: httpLink({
-                        url,
-                        transformer: { serialize: (o) => o, deserialize: (o) => o },
-                    }),
-                    false: httpLink({ url, transformer: superjson }),
-                }),
+                false: httpLink({ ...baseLinkOpts, headers: authHeader }),
             }),
         ],
     });
     console.log("Creating archive...");
-    const root = await findRoot();
+    const root = await findRoot({ rootMarker: "package.json" });
     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(path, { name: path });
+        arc.append(fs.createReadStream(path), { name: path });
     });
     arc.finalize();
     console.log("Uploading archive...");
-    const { sha256, cached } = await client.uploadArchive.mutate(Buffer.from(await Array.fromAsync(arc)));
+    const { sha256, cached } = await client.uploadArchive.mutate(await done);
     console.log(`Archive uploaded: ${sha256} (${cached ? "cached" : "new"})`);
     console.log("Deploying...");
-    client.deploy.subscribe({ sha256 }, {
-        onData: ({ status }) => console.log(`  ${status}`),
+    client.deploy.subscribe({ sha256, agent, shedUrl }, {
+        onData: ({ status, error }) => console.log(status ? status : error),
         onError: (err) => console.error(err),
         onComplete: () => console.log("\n✓ Deployment complete!"),
     });

package/dist/lib/port-utils.d.ts

@@ -6,3 +6,7 @@ export declare function isPortAvailable(port: number): Promise<boolean>;
  * Find the next available port starting from the given port
  */
 export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;
+/**
+ * Ensure a specific port is available, throwing an error if it's in use
+ */
+export declare function ensurePortAvailable(port: number, serviceName: string): Promise<void>;

package/dist/lib/port-utils.js

@@ -33,3 +33,12 @@ export async function findAvailablePort(startPort, maxAttempts = 10) {
     }
     throw new Error(`Could not find an available port between ${startPort} and ${startPort + maxAttempts - 1}`);
 }
+/**
+ * Ensure a specific port is available, throwing an error if it's in use
+ */
+export async function ensurePortAvailable(port, serviceName) {
+    const available = await isPortAvailable(port);
+    if (!available) {
+        throw new Error(`Port ${port} is already in use. Cannot start ${serviceName}. Please free up the port and try again.`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.78",
+  "version": "0.1.79",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -15,7 +15,7 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.70",
+    "@townco/tsconfig": "0.1.71",
     "@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.78",
-    "@townco/core": "0.0.51",
-    "@townco/debugger": "0.1.28",
-    "@townco/env": "0.1.23",
-    "@townco/secret": "0.1.73",
-    "@townco/ui": "0.1.73",
+    "@townco/agent": "0.1.79",
+    "@townco/core": "0.0.52",
+    "@townco/debugger": "0.1.29",
+    "@townco/env": "0.1.24",
+    "@townco/secret": "0.1.74",
+    "@townco/ui": "0.1.74",
     "@trpc/client": "^11.7.2",
     "@types/inquirer": "^9.0.9",
     "@types/ws": "^8.5.13",