adding more mcp tests

Author: igorcosta

src/core/agent.ts

@@ -96,6 +96,7 @@ import {
 import { WorkspaceFileCollector } from './agent/WorkspaceFileCollector.js';
 import { ProviderConfigManager } from './agent/ProviderConfigManager.js';
 import { AutoReportManager } from '../reporting/AutoReportManager.js';
+import { isLikelyFilePathSlashInput } from './slashInputDetection.js';
 
 export class AutohandAgent {
   private mentionContexts: { path: string; contents: string }[] = [];
@@ -1212,20 +1213,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
       return null;
     }
 
-    // Check if it looks like a file path rather than a slash command
-    // Slash commands are short: /help, /model, /new
-    // File paths have: multiple /, /Users/, extensions like .png, .ts, etc.
-    const looksLikeFilePath = (text: string): boolean => {
-      // Has multiple path separators (e.g., /Users/foo/bar)
-      if ((text.match(/\//g) || []).length > 1) return true;
-      // Starts with common path prefixes
-      if (/^\/(?:Users|home|tmp|var|opt|etc|usr)\//i.test(text)) return true;
-      // Has a file extension
-      if (/\.[a-z0-9]{1,5}(?:\s|$)/i.test(text)) return true;
-      return false;
-    };
-
-    if (normalized.startsWith('/') && !looksLikeFilePath(normalized)) {
+    if (normalized.startsWith('/') && !isLikelyFilePathSlashInput(normalized)) {
       // Parse command and arguments from input
       const parts = normalized.split(/\s+/);
       let command = parts[0];

src/core/slashInputDetection.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Heuristic to distinguish slash commands from file paths that begin with "/".
+ * Only inspects the first token so slash-command arguments (e.g. npm package
+ * specs like "@playwright/mcp@latest") do not accidentally trigger path mode.
+ */
+export function isLikelyFilePathSlashInput(text: string): boolean {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('/')) {
+    return false;
+  }
+
+  const firstToken = trimmed.split(/\s+/, 1)[0] ?? '';
+
+  // Has nested path separators (e.g. /Users/foo/bar, /tmp/x)
+  if ((firstToken.match(/\//g) || []).length > 1) {
+    return true;
+  }
+
+  // Starts with common absolute path prefixes
+  if (/^\/(?:Users|home|tmp|var|opt|etc|usr)\//i.test(firstToken)) {
+    return true;
+  }
+
+  // Looks like a file with extension
+  if (/\.[a-z0-9]{1,5}$/i.test(firstToken)) {
+    return true;
+  }
+
+  return false;
+}
+

src/mcp/McpClientManager.ts

@@ -297,6 +297,16 @@ class McpStdioConnection extends EventEmitter {
     while (this.frameBuffer.length > 0) {
       const header = this.findHeaderEnd(this.frameBuffer);
       if (!header) {
+        // Compatibility: some legacy MCP servers speak newline-delimited JSON-RPC.
+        // If buffered stdout looks like JSON lines, parse it immediately instead of
+        // waiting for a Content-Length timeout.
+        const preview = this.frameBuffer.toString('utf8', 0, Math.min(this.frameBuffer.length, 256));
+        const trimmed = preview.trimStart();
+        const looksLikeJsonLine = trimmed.startsWith('{') || trimmed.startsWith('[');
+        if (looksLikeJsonLine && this.frameBuffer.includes(0x0a)) {
+          this.parseLineDelimitedData(this.frameBuffer);
+          this.frameBuffer = Buffer.alloc(0);
+        }
         return;
       }
 
@@ -817,7 +827,7 @@ export class McpClientManager {
    */
   private async connectStdio(config: McpServerConfig): Promise<void> {
     try {
-      const connected = await this.connectStdioWithFraming(config, 'content-length');
+      const connected = await this.connectStdioWithFallbackFraming(config);
       this.registerConnectedStdioServer(config, connected.connection, connected.tools);
     } catch (error) {
       if (!this.shouldRetryNpxWithIsolatedCache(config, error)) {
@@ -830,7 +840,7 @@ export class McpClientManager {
       };
 
       try {
-        const connected = await this.connectStdioWithFraming(retryConfig, 'content-length');
+        const connected = await this.connectStdioWithFallbackFraming(retryConfig);
         // Keep persisted config intact; retry cache env is only a runtime override.
         this.registerConnectedStdioServer(config, connected.connection, connected.tools);
       } catch (retryError) {
@@ -849,6 +859,42 @@ export class McpClientManager {
     return isRetriableNpxInstallError(message);
   }
 
+  /**
+   * Some MCP servers still use newline-delimited JSON-RPC over stdio.
+   * Start with Content-Length framing (spec), then fallback to newline when
+   * initialize stalls/closes without a successful handshake.
+   */
+  private shouldRetryWithNewlineFraming(error: unknown): boolean {
+    const message = error instanceof Error ? error.message : String(error);
+    return (
+      message.includes('MCP request "initialize" timed out')
+      || message.includes('MCP connection closed before initialization completed')
+      || message.includes('MCP connection closed (server exited with code')
+    );
+  }
+
+  private async connectStdioWithFallbackFraming(
+    config: McpServerConfig
+  ): Promise<{ connection: McpStdioConnection; tools: McpToolDefinition[] }> {
+    try {
+      return await this.connectStdioWithFraming(config, 'content-length');
+    } catch (contentLengthError) {
+      if (!this.shouldRetryWithNewlineFraming(contentLengthError)) {
+        throw contentLengthError;
+      }
+
+      try {
+        return await this.connectStdioWithFraming(config, 'newline');
+      } catch (newlineError) {
+        const first = contentLengthError instanceof Error
+          ? contentLengthError.message
+          : String(contentLengthError);
+        const second = newlineError instanceof Error ? newlineError.message : String(newlineError);
+        throw new Error(`${first}\nRetry with newline framing failed: ${second}`);
+      }
+    }
+  }
+
   /**
    * Tries to establish a stdio MCP connection with a specific framing mode.
    */

tests/core/slashInputDetection.spec.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, expect, it } from 'vitest';
+import { isLikelyFilePathSlashInput } from '../../src/core/slashInputDetection.js';
+
+describe('isLikelyFilePathSlashInput', () => {
+  it('detects absolute file paths', () => {
+    expect(isLikelyFilePathSlashInput('/Users/me/project/file.ts')).toBe(true);
+    expect(isLikelyFilePathSlashInput('/tmp/test.txt')).toBe(true);
+    expect(isLikelyFilePathSlashInput('/opt/bin/script.sh --flag')).toBe(true);
+  });
+
+  it('does not classify slash commands as file paths', () => {
+    expect(isLikelyFilePathSlashInput('/mcp')).toBe(false);
+    expect(isLikelyFilePathSlashInput('/mcp add playwright npx @playwright/mcp@latest')).toBe(false);
+    expect(isLikelyFilePathSlashInput('/mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest')).toBe(false);
+  });
+
+  it('ignores non-slash input', () => {
+    expect(isLikelyFilePathSlashInput('mcp add')).toBe(false);
+    expect(isLikelyFilePathSlashInput('@playwright/mcp@latest')).toBe(false);
+  });
+});
+