@townco/cli 0.1.53 → 0.1.54

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,110 @@
+import inquirer from "inquirer";
+import { clearAuthCredentials, getAuthFilePath, getShedUrl, loadAuthCredentials, saveAuthCredentials, } from "../lib/auth-storage.js";
+// ============================================================================
+// Command Implementation
+// ============================================================================
+export async function loginCommand() {
+    const shedUrl = getShedUrl();
+    console.log("Town Login\n");
+    // Check if already logged in
+    const existingCredentials = loadAuthCredentials();
+    if (existingCredentials) {
+        console.log(`Currently logged in as: ${existingCredentials.user.email}`);
+        console.log(`Shed URL: ${existingCredentials.shed_url}\n`);
+        const { action } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "action",
+                message: "What would you like to do?",
+                choices: [
+                    { name: "Log in with a different account", value: "login" },
+                    { name: "Log out", value: "logout" },
+                    { name: "Cancel", value: "cancel" },
+                ],
+            },
+        ]);
+        if (action === "cancel") {
+            console.log("Cancelled.");
+            return;
+        }
+        if (action === "logout") {
+            clearAuthCredentials();
+            console.log("Logged out successfully.");
+            return;
+        }
+    }
+    // Prompt for credentials
+    const { email } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "email",
+            message: "Email:",
+            validate: (input) => {
+                if (!input.trim()) {
+                    return "Email is required";
+                }
+                if (!input.includes("@")) {
+                    return "Please enter a valid email address";
+                }
+                return true;
+            },
+        },
+    ]);
+    const { password } = await inquirer.prompt([
+        {
+            type: "password",
+            name: "password",
+            message: "Password:",
+            mask: "*",
+            validate: (input) => {
+                if (!input) {
+                    return "Password is required";
+                }
+                return true;
+            },
+        },
+    ]);
+    console.log("\nAuthenticating...");
+    try {
+        const response = await fetch(`${shedUrl}/api/cli/login`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ email, password }),
+        });
+        if (!response.ok) {
+            const errorData = await response
+                .json()
+                .catch(() => ({ error: "Login failed" }));
+            console.error(`\nLogin failed: ${errorData.error || "Unknown error"}`);
+            if (response.status === 401) {
+                console.log("\nPlease check your email and password and try again.");
+                console.log("If you don't have an account, sign up at " + shedUrl);
+            }
+            process.exit(1);
+        }
+        const data = (await response.json());
+        // Save credentials
+        const credentials = {
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            expires_at: data.expires_at,
+            user: data.user,
+            shed_url: shedUrl,
+        };
+        saveAuthCredentials(credentials);
+        console.log(`\nLogged in as ${data.user.email}`);
+        console.log(`Credentials saved to ${getAuthFilePath()}`);
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+            console.error(`\nCould not connect to ${shedUrl}`);
+            console.error("Please check your internet connection and try again.");
+        }
+        else {
+            console.error(`\nLogin failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/run.js

@@ -233,10 +233,11 @@ export async function runCommand(options) {
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
         }
-        // Start the agent in HTTP mode
+        // Start the agent in HTTP mode with detached process group
         const agentProcess = spawn("bun", [binPath, "http"], {
             cwd: agentPath,
             stdio: ["ignore", "pipe", "pipe"], // Pipe stdout/stderr for capture
+            detached: true,
             env: {
                 ...process.env,
                 ...configEnvVars,
@@ -246,20 +247,60 @@ export async function runCommand(options) {
                 ...(noSession ? { TOWN_NO_SESSION: "true" } : {}),
             },
         });
-        // Start the GUI dev server (no package.json, run vite directly)
+        // Start the GUI dev server (no package.json, run vite directly) with detached process group
         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://localhost:${availablePort}`,
+                VITE_DEBUGGER_URL: "http://localhost:4000",
             },
         });
+        // Setup cleanup handlers for agent and GUI processes
+        const cleanupProcesses = () => {
+            // Kill entire process group by using negative PID
+            if (agentProcess.pid) {
+                try {
+                    process.kill(-agentProcess.pid, "SIGTERM");
+                }
+                catch (e) {
+                    // Process may already be dead
+                }
+            }
+            if (guiProcess.pid) {
+                try {
+                    process.kill(-guiProcess.pid, "SIGTERM");
+                }
+                catch (e) {
+                    // Process may already be dead
+                }
+            }
+        };
+        process.on("exit", cleanupProcesses);
+        process.on("SIGINT", cleanupProcesses);
+        process.on("SIGTERM", cleanupProcesses);
         // Render the tabbed UI with dynamic port detection
         const { waitUntilExit } = render(_jsx(GuiRunner, { agentProcess: agentProcess, guiProcess: guiProcess, agentPort: availablePort, agentPath: agentPath, logger: logger, onExit: () => {
-                agentProcess.kill();
-                guiProcess.kill();
+                // Kill entire process group by using negative PID
+                if (agentProcess.pid) {
+                    try {
+                        process.kill(-agentProcess.pid, "SIGTERM");
+                    }
+                    catch (e) {
+                        // Process may already be dead
+                    }
+                }
+                if (guiProcess.pid) {
+                    try {
+                        process.kill(-guiProcess.pid, "SIGTERM");
+                    }
+                    catch (e) {
+                        // Process may already be dead
+                    }
+                }
             } }));
         await waitUntilExit();
         process.exit(0);
@@ -280,10 +321,11 @@ export async function runCommand(options) {
         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
+        // Run the agent in HTTP mode with detached process group
         const agentProcess = spawn("bun", [binPath, "http"], {
             cwd: agentPath,
             stdio: "inherit",
+            detached: true,
             env: {
                 ...process.env,
                 ...configEnvVars,
@@ -293,6 +335,20 @@ export async function runCommand(options) {
                 ...(noSession ? { TOWN_NO_SESSION: "true" } : {}),
             },
         });
+        // Setup cleanup handler for agent process
+        const cleanupAgentProcess = () => {
+            if (agentProcess.pid) {
+                try {
+                    process.kill(-agentProcess.pid, "SIGTERM");
+                }
+                catch (e) {
+                    // Process may already be dead
+                }
+            }
+        };
+        process.on("exit", cleanupAgentProcess);
+        process.on("SIGINT", cleanupAgentProcess);
+        process.on("SIGTERM", cleanupAgentProcess);
         agentProcess.on("error", (error) => {
             logger.error("Failed to start agent", { error: error.message });
             console.error(`Failed to start agent: ${error.message}`);

package/dist/commands/whoami.d.ts

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

package/dist/commands/whoami.js

@@ -0,0 +1,36 @@
+import { authGet } from "../lib/auth-fetch.js";
+import { loadAuthCredentials } from "../lib/auth-storage.js";
+export async function whoamiCommand() {
+    const credentials = loadAuthCredentials();
+    if (!credentials) {
+        console.log("Not logged in. Run 'town login' to authenticate.");
+        return;
+    }
+    console.log(`Shed URL: ${credentials.shed_url}`);
+    console.log("Verifying credentials...\n");
+    try {
+        const response = await authGet("/api/cli/me");
+        if (!response.ok) {
+            const error = await response
+                .json()
+                .catch(() => ({ error: "Unknown error" }));
+            console.error(`Authentication failed: ${error.error}`);
+            console.log("\nYour session may have expired. Run 'town login' again.");
+            process.exit(1);
+        }
+        const data = (await response.json());
+        console.log(`Email: ${data.email}`);
+        console.log(`User ID: ${data.id}`);
+        console.log("\nAuthentication verified successfully.");
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+            console.error(`Could not connect to ${credentials.shed_url}`);
+            console.error("Please check your internet connection and try again.");
+        }
+        else {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/components/TabbedOutput.js

@@ -1,10 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { spawn } from "node:child_process";
-import { appendFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { Box, useApp, useInput } from "ink";
+import { Box, Text, useApp, useInput } from "ink";
 import { useEffect, useRef, useState } from "react";
-import { MergedLogsPane } from "./MergedLogsPane.js";
+import { LogsPane } from "./LogsPane.js";
 import { ProcessPane } from "./ProcessPane.js";
 import { StatusLine } from "./StatusLine.js";
 function isProcessTab(tab) {
@@ -21,7 +20,6 @@ export function TabbedOutput({ processes, customTabs = [], logsDir, onExit, onPo
     const [statuses, setStatuses] = useState(processes.map(() => "starting"));
     const [ports, setPorts] = useState(processes.map((p) => p.port));
     const portDetectedRef = useRef(new Set());
-    const [logFileOutputs, setLogFileOutputs] = useState({});
     // Ensure logs directory exists if provided
     useEffect(() => {
         if (logsDir && !existsSync(logsDir)) {
@@ -176,57 +174,7 @@ export function TabbedOutput({ processes, customTabs = [], logsDir, onExit, onPo
     }, [processes, onPortDetected, logsDir]);
     // GUI mode: only process tabs, no custom tabs - use merged logs view
     const isGuiMode = customTabs.length === 0 && processes.length > 0;
-    // Tail log files in GUI mode to capture internal service logs
-    useEffect(() => {
-        if (!logsDir || !isGuiMode || !existsSync(logsDir)) {
-            return;
-        }
-        const tailProcesses = [];
-        const tailedFiles = new Set();
-        // Function to start tailing a specific log file
-        const tailLogFile = (file) => {
-            if (tailedFiles.has(file))
-                return;
-            tailedFiles.add(file);
-            const serviceName = file.replace(".log", "");
-            const filePath = join(logsDir, file);
-            // Use tail -F (follow by name, retry if file doesn't exist)
-            const tail = spawn("tail", ["-F", "-n", "50", filePath]);
-            tail.stdout.on("data", (data) => {
-                const lines = data
-                    .toString()
-                    .split("\n")
-                    .filter((line) => line.trim());
-                setLogFileOutputs((prev) => ({
-                    ...prev,
-                    [serviceName]: [...(prev[serviceName] || []), ...lines],
-                }));
-            });
-            tail.stderr.on("data", (_data) => {
-                // Ignore tail errors (like file not found initially)
-            });
-            tailProcesses.push(tail);
-        };
-        // Scan for log files and start tailing them
-        const scanLogFiles = () => {
-            if (!existsSync(logsDir))
-                return;
-            const logFiles = readdirSync(logsDir).filter((f) => f.endsWith(".log"));
-            for (const file of logFiles) {
-                tailLogFile(file);
-            }
-        };
-        // Initial scan
-        scanLogFiles();
-        // Re-scan every 2 seconds to catch new log files
-        const scanInterval = setInterval(scanLogFiles, 2000);
-        return () => {
-            clearInterval(scanInterval);
-            for (const tail of tailProcesses) {
-                tail.kill();
-            }
-        };
-    }, [logsDir, isGuiMode]);
+    // GUI mode now uses LogsPane which handles log file tailing internally
     const currentTab = allTabs[activeTab];
     if (!currentTab) {
         return null;
@@ -238,29 +186,9 @@ export function TabbedOutput({ processes, customTabs = [], logsDir, onExit, onPo
             return newOutputs;
         });
     };
-    const handleClearMergedOutput = (serviceIndex) => {
-        setOutputs((prev) => {
-            const newOutputs = [...prev];
-            newOutputs[serviceIndex] = [];
-            return newOutputs;
-        });
-    };
     if (isGuiMode) {
-        const serviceOutputs = processes.map((proc, idx) => ({
-            service: proc.name,
-            output: outputs[idx] || [],
-            port: ports[idx],
-            status: statuses[idx] || "starting",
-        }));
-        // Add log file services (internal agent services like adapter, agent-runner, etc.)
-        const logFileServices = Object.entries(logFileOutputs).map(([service, output]) => ({
-            service,
-            output,
-            port: undefined,
-            status: "running",
-        }));
-        const allServices = [...serviceOutputs, ...logFileServices];
-        return (_jsx(Box, { flexDirection: "column", height: "100%", children: _jsx(MergedLogsPane, { services: allServices, onClear: handleClearMergedOutput }) }));
+        // Use LogsPane for GUI mode - reads from log files like TUI mode
+        return (_jsx(Box, { flexDirection: "column", height: "100%", children: logsDir ? (_jsx(LogsPane, { logsDir: logsDir })) : (_jsx(Text, { children: "No logs directory configured" })) }));
     }
     // TUI mode: has custom tabs - use tabbed interface
     // Get status content from current tab if available

package/dist/index.js

@@ -12,8 +12,10 @@ import { match } from "ts-pattern";
 import { configureCommand } from "./commands/configure.js";
 import { createCommand } from "./commands/create.js";
 import { createProjectCommand } from "./commands/create-project.js";
+import { loginCommand } from "./commands/login.js";
 import { runCommand } from "./commands/run.js";
 import { upgradeCommand } from "./commands/upgrade.js";
+import { whoamiCommand } from "./commands/whoami.js";
 /**
  * Securely prompt for a secret value without echoing to the terminal
  */
@@ -30,6 +32,10 @@ async function promptSecret(secretName) {
 }
 const parser = or(command("deploy", constant("deploy"), { brief: message `Deploy a Town.` }), command("configure", constant("configure"), {
     brief: message `Configure environment variables.`,
+}), command("login", constant("login"), {
+    brief: message `Log in to Town Shed.`,
+}), command("whoami", constant("whoami"), {
+    brief: message `Show current login status.`,
 }), command("upgrade", constant("upgrade"), {
     brief: message `Upgrade dependencies by cleaning and reinstalling.`,
 }), command("create", object({
@@ -77,6 +83,12 @@ async function main(parser, meta) {
         .with("deploy", async () => { })
         .with("configure", async () => {
         await configureCommand();
+    })
+        .with("login", async () => {
+        await loginCommand();
+    })
+        .with("whoami", async () => {
+        await whoamiCommand();
     })
         .with("upgrade", async () => {
         await upgradeCommand();

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

@@ -0,0 +1,19 @@
+import { type AuthCredentials } from "./auth-storage.js";
+/**
+ * Get valid credentials, refreshing if necessary
+ * Throws if not logged in or refresh fails
+ */
+export declare function getValidCredentials(): Promise<AuthCredentials>;
+/**
+ * Make an authenticated fetch request to shed
+ * Automatically refreshes token if expired
+ */
+export declare function authFetch(path: string, options?: RequestInit): Promise<Response>;
+/**
+ * Convenience method for GET requests
+ */
+export declare function authGet(path: string): Promise<Response>;
+/**
+ * Convenience method for POST requests with JSON body
+ */
+export declare function authPost(path: string, body: unknown): Promise<Response>;

package/dist/lib/auth-fetch.js

@@ -0,0 +1,99 @@
+import { isTokenExpired, loadAuthCredentials, saveAuthCredentials, } from "./auth-storage.js";
+// ============================================================================
+// Token Refresh
+// ============================================================================
+async function refreshAccessToken(credentials) {
+    const response = await fetch(`${credentials.shed_url}/api/cli/refresh`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            refresh_token: credentials.refresh_token,
+        }),
+    });
+    if (!response.ok) {
+        const error = await response
+            .json()
+            .catch(() => ({ error: "Token refresh failed" }));
+        throw new Error(error.error || "Token refresh failed");
+    }
+    const data = (await response.json());
+    const newCredentials = {
+        ...credentials,
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: data.expires_at,
+    };
+    saveAuthCredentials(newCredentials);
+    return newCredentials;
+}
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Get valid credentials, refreshing if necessary
+ * 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)})`);
+        }
+    }
+    return credentials;
+}
+/**
+ * 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 headers = new Headers(options.headers);
+    headers.set("Authorization", `Bearer ${credentials.access_token}`);
+    const response = await 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
+ */
+export async function authGet(path) {
+    return authFetch(path, { method: "GET" });
+}
+/**
+ * Convenience method for POST requests with JSON body
+ */
+export async function authPost(path, body) {
+    return authFetch(path, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+}

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

@@ -0,0 +1,38 @@
+export interface AuthCredentials {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    user: {
+        id: string;
+        email: string;
+    };
+    shed_url: string;
+}
+/**
+ * Get the shed URL from environment or default
+ */
+export declare function getShedUrl(): string;
+/**
+ * Save auth credentials to disk
+ */
+export declare function saveAuthCredentials(credentials: AuthCredentials): void;
+/**
+ * Load auth credentials from disk
+ */
+export declare function loadAuthCredentials(): AuthCredentials | null;
+/**
+ * Delete auth credentials (logout)
+ */
+export declare function clearAuthCredentials(): boolean;
+/**
+ * Check if user is logged in (has valid credentials file)
+ */
+export declare function isLoggedIn(): boolean;
+/**
+ * Check if access token is expired or about to expire (within 5 minutes)
+ */
+export declare function isTokenExpired(credentials: AuthCredentials): boolean;
+/**
+ * Get the auth file path (for display purposes)
+ */
+export declare function getAuthFilePath(): string;

package/dist/lib/auth-storage.js

@@ -0,0 +1,89 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// ============================================================================
+// Constants
+// ============================================================================
+const TOWN_CONFIG_DIR = join(homedir(), ".config", "town");
+const AUTH_FILE = join(TOWN_CONFIG_DIR, "auth.json");
+const DEFAULT_SHED_URL = "http://localhost:3000";
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function ensureConfigDir() {
+    if (!existsSync(TOWN_CONFIG_DIR)) {
+        mkdirSync(TOWN_CONFIG_DIR, { recursive: true });
+    }
+}
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Get the shed URL from environment or default
+ */
+export function getShedUrl() {
+    return process.env.TOWN_SHED_URL || DEFAULT_SHED_URL;
+}
+/**
+ * Save auth credentials to disk
+ */
+export function saveAuthCredentials(credentials) {
+    ensureConfigDir();
+    try {
+        const content = JSON.stringify(credentials, null, 2);
+        writeFileSync(AUTH_FILE, content, { mode: 0o600 });
+    }
+    catch (error) {
+        throw new Error(`Failed to save auth credentials: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Load auth credentials from disk
+ */
+export function loadAuthCredentials() {
+    if (!existsSync(AUTH_FILE)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(AUTH_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (_error) {
+        return null;
+    }
+}
+/**
+ * Delete auth credentials (logout)
+ */
+export function clearAuthCredentials() {
+    if (!existsSync(AUTH_FILE)) {
+        return false;
+    }
+    try {
+        unlinkSync(AUTH_FILE);
+        return true;
+    }
+    catch (error) {
+        throw new Error(`Failed to clear auth credentials: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Check if user is logged in (has valid credentials file)
+ */
+export function isLoggedIn() {
+    return loadAuthCredentials() !== null;
+}
+/**
+ * Check if access token is expired or about to expire (within 5 minutes)
+ */
+export function isTokenExpired(credentials) {
+    const now = Math.floor(Date.now() / 1000);
+    const buffer = 5 * 60; // 5 minutes buffer
+    return credentials.expires_at <= now + buffer;
+}
+/**
+ * Get the auth file path (for display purposes)
+ */
+export function getAuthFilePath() {
+    return AUTH_FILE;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/cli",
-  "version": "0.1.53",
+  "version": "0.1.54",
   "type": "module",
   "bin": {
     "town": "./dist/index.js"
@@ -15,18 +15,18 @@
     "build": "tsc"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.45",
+    "@townco/tsconfig": "0.1.46",
     "@types/bun": "^1.3.1",
     "@types/react": "^19.2.2"
   },
   "dependencies": {
     "@optique/core": "^0.6.2",
     "@optique/run": "^0.6.2",
-    "@townco/agent": "0.1.53",
-    "@townco/debugger": "0.1.3",
-    "@townco/core": "0.0.26",
-    "@townco/secret": "0.1.48",
-    "@townco/ui": "0.1.48",
+    "@townco/agent": "0.1.54",
+    "@townco/debugger": "0.1.4",
+    "@townco/core": "0.0.27",
+    "@townco/secret": "0.1.49",
+    "@townco/ui": "0.1.49",
     "@types/inquirer": "^9.0.9",
     "ink": "^6.4.0",
     "ink-text-input": "^6.0.0",