adding tui ui for mcp

Author: igorcosta

src/commands/mcp.ts

@@ -373,6 +373,10 @@ async function handleAdd(
   if (!targetConfig.mcp.servers) {
     targetConfig.mcp.servers = [];
   }
+  const wasMcpDisabled = targetConfig.mcp.enabled === false;
+  if (wasMcpDisabled) {
+    targetConfig.mcp.enabled = true;
+  }
 
   const newServer = transport === 'stdio'
     ? {
@@ -405,7 +409,31 @@ async function handleAdd(
         && existing.url === target;
 
     if (sameConfig) {
-      return `Server "${name}" is already configured with the same settings${scopeSuffix}.`;
+      const wasAutoConnectDisabled = existing.autoConnect === false;
+      if (!wasAutoConnectDisabled && !wasMcpDisabled) {
+        return `Server "${name}" is already configured with the same settings${scopeSuffix}.`;
+      }
+
+      existing.autoConnect = true;
+      const reenabledParts: string[] = [];
+      if (wasMcpDisabled) reenabledParts.push('MCP support');
+      if (wasAutoConnectDisabled) reenabledParts.push('auto-connect');
+      const reenabled = reenabledParts.join(' and ');
+
+      try {
+        await saveConfig(targetConfig);
+        syncRuntimeConfig(config, targetConfig);
+
+        try {
+          await manager.connect(existing);
+          const tools = manager.getToolsForServer(name);
+          return `Server "${name}" is already configured${scopeSuffix}. Re-enabled ${reenabled} and connected (${tools.length} tools available).`;
+        } catch (connectError) {
+          return `Server "${name}" is already configured${scopeSuffix}. Re-enabled ${reenabled} but failed to connect: ${connectError instanceof Error ? connectError.message : 'Unknown error'}`;
+        }
+      } catch (error) {
+        return `Failed to save config: ${error instanceof Error ? error.message : 'Unknown error'}`;
+      }
     }
 
     // Update in-place

src/core/agent.ts

@@ -97,6 +97,11 @@ import { WorkspaceFileCollector } from './agent/WorkspaceFileCollector.js';
 import { ProviderConfigManager } from './agent/ProviderConfigManager.js';
 import { AutoReportManager } from '../reporting/AutoReportManager.js';
 import { isLikelyFilePathSlashInput } from './slashInputDetection.js';
+import {
+  buildMcpStartupSummaryRows,
+  getAutoConnectMcpServerNames,
+  truncateMcpStartupError,
+} from './mcpStartupHistory.js';
 
 export class AutohandAgent {
   private mentionContexts: { path: string; contents: string }[] = [];
@@ -646,6 +651,9 @@ export class AutohandAgent {
   /** Promise that resolves when background init is complete */
   private initReady: Promise<void> | null = null;
   private initDone = false;
+  private mcpStartupAutoConnectServers: string[] = [];
+  private mcpStartupConnectStartedAt: number | null = null;
+  private mcpStartupSummaryPrinted = false;
 
   async runInteractive(): Promise<void> {
     // Bail out early if stdin is not a TTY - interactive mode requires a terminal
@@ -655,6 +663,16 @@ export class AutohandAgent {
       return;
     }
 
+    // Prepare startup visibility for async MCP connections.
+    this.mcpStartupAutoConnectServers = getAutoConnectMcpServerNames(this.runtime.config.mcp?.servers);
+    this.mcpStartupConnectStartedAt = null;
+    this.mcpStartupSummaryPrinted = false;
+    if (this.runtime.config.mcp?.enabled !== false && this.mcpStartupAutoConnectServers.length > 0) {
+      const count = this.mcpStartupAutoConnectServers.length;
+      const label = count === 1 ? 'server' : 'servers';
+      console.log(chalk.gray(`MCP startup: connecting ${count} ${label} in background...`));
+    }
+
     // Start ALL initialization in background so prompt appears instantly.
     // The user can start typing while managers initialize.
     // When they submit, we await initReady before processing.
@@ -685,6 +703,7 @@ export class AutohandAgent {
       // Servers connect asynchronously; tools become available once ready.
       // Does NOT block the main init pipeline or user prompt.
       if (this.runtime.config.mcp?.enabled !== false) {
+        this.mcpStartupConnectStartedAt = Date.now();
         this.mcpReady = this.mcpManager
           .connectAll(this.runtime.config.mcp?.servers ?? [])
           .then(() => { this.syncMcpTools(); })
@@ -732,6 +751,7 @@ export class AutohandAgent {
       if (this.mcpReady) {
         await this.mcpReady;
       }
+      this.printMcpStartupSummaryIfNeeded();
 
       // Fire session-start hook now that the prompt is closed and stdout is clean
       const session = this.sessionManager.getCurrentSession();
@@ -1213,33 +1233,32 @@ If lint or tests fail, report the issues but do NOT commit.`;
       return null;
     }
 
-    if (normalized.startsWith('/') && !isLikelyFilePathSlashInput(normalized)) {
-      // Parse command and arguments from input
-      const parts = normalized.split(/\s+/);
-      let command = parts[0];
-      let args = parts.slice(1);
-
-      // Handle multi-word commands like "/skills install", "/mcp install"
-      const twoWordCommands = ['/skills install', '/skills new', '/skills use', '/agents new', '/mcp install'];
-      const potentialTwoWord = `${parts[0]} ${parts[1] || ''}`.trim();
-      if (twoWordCommands.includes(potentialTwoWord)) {
-        command = potentialTwoWord;
-        args = parts.slice(2);
-      }
-
-      // /quit and /exit return themselves as pass-through instructions
-      // so the interactive loop's special exit handler (line 963) can catch them.
-      // Skip the slash handler for these — they're control-flow, not commands.
-      if (command === '/quit' || command === '/exit') {
-        return command;
-      }
+    if (normalized.startsWith('/')) {
+      // Always prioritize known slash commands, even when args contain '/'
+      // (e.g. package specs like "@playwright/mcp@latest").
+      const parsed = this.parseSlashCommand(normalized);
+      const isKnownSlashCommand = this.isSlashCommandSupported(parsed.command);
+      if (!isKnownSlashCommand && isLikelyFilePathSlashInput(normalized)) {
+        // Looks like an absolute file path, not a command.
+        // Fall through to normal prompt handling below.
+      } else {
+        const command = parsed.command;
+        const args = parsed.args;
+
+        // /quit and /exit return themselves as pass-through instructions
+        // so the interactive loop's special exit handler (line 963) can catch them.
+        // Skip the slash handler for these — they're control-flow, not commands.
+        if (command === '/quit' || command === '/exit') {
+          return command;
+        }
 
-      const handled = await this.handleSlashCommand(command, args);
-      if (handled !== null) {
-        // Slash command returned display output — print it, don't send to LLM
-        console.log(handled);
+        const handled = await this.handleSlashCommand(command, args);
+        if (handled !== null) {
+          // Slash command returned display output — print it, don't send to LLM
+          console.log(handled);
+        }
+        return null;
       }
-      return null;
     }
 
     // Handle # trigger for storing memories
@@ -4013,6 +4032,12 @@ If lint or tests fail, report the issues but do NOT commit.`;
    * Returns the command output or null if the command doesn't exist
    */
   async handleSlashCommand(command: string, args: string[] = []): Promise<string | null> {
+    // /mcp depends on background startup state (notably MCP auto-connect).
+    // Ensure startup init is settled before rendering server status/actions.
+    if (command === '/mcp' || command === '/mcp install') {
+      await this.ensureInitComplete();
+    }
+
     const result = await this.slashHandler.handle(command, args);
     if (command === '/mcp' || command === '/mcp install') {
       this.syncMcpTools();
@@ -4264,6 +4289,64 @@ If lint or tests fail, report the issues but do NOT commit.`;
     return `${planIndicator}${percent}% context left · ${t('ui.commandHint')}${queueStatus}`;
   }
 
+  private printMcpStartupSummaryIfNeeded(): void {
+    if (this.mcpStartupSummaryPrinted) {
+      return;
+    }
+    if (this.runtime.config.mcp?.enabled === false) {
+      this.mcpStartupSummaryPrinted = true;
+      return;
+    }
+    if (this.mcpStartupAutoConnectServers.length === 0) {
+      this.mcpStartupSummaryPrinted = true;
+      return;
+    }
+
+    this.mcpStartupSummaryPrinted = true;
+
+    const rows = buildMcpStartupSummaryRows(
+      this.mcpStartupAutoConnectServers,
+      this.mcpManager.listServers()
+    );
+
+    const elapsed = this.mcpStartupConnectStartedAt
+      ? formatElapsedTime(this.mcpStartupConnectStartedAt)
+      : null;
+
+    const connected = rows.filter((row) => row.status === 'connected').length;
+    const failed = rows.filter((row) => row.status === 'error').length;
+    const disconnected = rows.filter((row) => row.status === 'disconnected').length;
+    const summaryParts = [
+      `${connected} connected`,
+      failed > 0 ? `${failed} failed` : null,
+      disconnected > 0 ? `${disconnected} disconnected` : null,
+    ].filter(Boolean).join(', ');
+    const elapsedSuffix = elapsed ? ` in ${elapsed}` : '';
+
+    console.log(chalk.bold('\n* MCP startup'));
+    console.log(chalk.gray(`  Async connection phase complete${elapsedSuffix} (${summaryParts})`));
+
+    for (const row of rows) {
+      if (row.status === 'connected') {
+        const toolLabel = row.toolCount === 1 ? 'tool' : 'tools';
+        console.log(`  ${chalk.green('✓')} ${row.name} connected (${row.toolCount} ${toolLabel})`);
+        continue;
+      }
+
+      if (row.status === 'error') {
+        const errorSuffix = row.error
+          ? `: ${truncateMcpStartupError(row.error)}`
+          : '';
+        console.log(`  ${chalk.red('✖')} ${row.name} failed${errorSuffix}`);
+        continue;
+      }
+
+      console.log(`  ${chalk.yellow('○')} ${row.name} not connected`);
+    }
+
+    console.log();
+  }
+
   private async resetConversationContext(): Promise<void> {
     const systemPrompt = await this.buildSystemPrompt();
     this.conversation.reset(systemPrompt);

src/core/mcpStartupHistory.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export interface McpStartupConfiguredServer {
+  name: string;
+  autoConnect?: boolean;
+}
+
+export interface McpStartupRuntimeServer {
+  name: string;
+  status: 'connected' | 'disconnected' | 'error';
+  toolCount: number;
+  error?: string;
+}
+
+export interface McpStartupSummaryRow {
+  name: string;
+  status: 'connected' | 'disconnected' | 'error';
+  toolCount: number;
+  error?: string;
+}
+
+/**
+ * Return configured MCP server names that should auto-connect on startup.
+ */
+export function getAutoConnectMcpServerNames(
+  servers: McpStartupConfiguredServer[] | undefined
+): string[] {
+  if (!servers || servers.length === 0) {
+    return [];
+  }
+
+  return servers
+    .filter((server) => server.autoConnect !== false)
+    .map((server) => server.name);
+}
+
+/**
+ * Build a stable startup summary in configured order.
+ */
+export function buildMcpStartupSummaryRows(
+  autoConnectServerNames: string[],
+  runtimeServers: McpStartupRuntimeServer[]
+): McpStartupSummaryRow[] {
+  const runtimeMap = new Map(runtimeServers.map((server) => [server.name, server]));
+
+  return autoConnectServerNames.map((name) => {
+    const runtime = runtimeMap.get(name);
+    if (!runtime) {
+      return {
+        name,
+        status: 'disconnected',
+        toolCount: 0,
+      };
+    }
+
+    return {
+      name,
+      status: runtime.status,
+      toolCount: runtime.toolCount,
+      error: runtime.error,
+    };
+  });
+}
+
+export function truncateMcpStartupError(error: string, maxLength = 140): string {
+  if (error.length <= maxLength) {
+    return error;
+  }
+  return `${error.slice(0, maxLength - 1)}…`;
+}
+

src/index.ts

@@ -388,6 +388,10 @@ mcpCmd
 
     if (!config.mcp) config.mcp = {};
     if (!config.mcp.servers) config.mcp.servers = [];
+    const wasMcpDisabled = config.mcp.enabled === false;
+    if (wasMcpDisabled) {
+      config.mcp.enabled = true;
+    }
 
     const transport = (options.transport ?? 'stdio').toLowerCase();
     if (transport !== 'stdio' && transport !== 'http' && transport !== 'sse') {
@@ -444,6 +448,21 @@ mcpCmd
           && existing.url === target;
 
       if (sameConfig) {
+        const wasAutoConnectDisabled = existing.autoConnect === false;
+        if (wasAutoConnectDisabled || wasMcpDisabled) {
+          existing.autoConnect = true;
+          await saveConfig(config);
+
+          const reenabledParts: string[] = [];
+          if (wasMcpDisabled) reenabledParts.push('MCP support');
+          if (wasAutoConnectDisabled) reenabledParts.push('auto-connect');
+          const reenabled = reenabledParts.join(' and ');
+
+          console.log(chalk.green(`Server "${name}" is already configured. Re-enabled ${reenabled}.`));
+          console.log(chalk.gray('Server will auto-connect when you start autohand.'));
+          process.exit(0);
+        }
+
         console.log(chalk.green(`Server "${name}" is already configured with the same settings.`));
         process.exit(0);
       }

src/mcp/McpClientManager.ts

@@ -999,12 +999,15 @@ export class McpClientManager {
     connection: McpStdioConnection,
     tools: McpToolDefinition[]
   ): void {
-    connection.on('close', () => {
+    connection.on('close', (code: number | null | undefined) => {
       const state = this.servers.get(config.name);
-      // Only set to 'disconnected' if currently connected.
-      // Preserve 'error' status so the user can see why connection failed.
+      // Only mutate state if currently connected.
+      // Preserve existing error state from handshake failures.
       if (state && state.status === 'connected') {
-        state.status = 'disconnected';
+        state.status = 'error';
+        state.error = typeof code === 'number'
+          ? `MCP server process exited with code ${code}`
+          : 'MCP server disconnected unexpectedly';
       }
     });