fix: check server responds to HTTP requests before allowing user messages

Author: avi-alpert

browser-tests/fixtures.ts

@@ -1,5 +1,5 @@
 import { ENV_FILE } from './constants';
-import { test as base } from '@playwright/test';
+import { type Page, test as base, expect } from '@playwright/test';
 import { readFileSync } from 'node:fs';
 
 interface BrowserTestEnv {
@@ -28,4 +28,29 @@ export const test = base.extend<{ testEnv: BrowserTestEnv }>({
   },
 });
 
-export { expect } from '@playwright/test';
+/**
+ * Send a chat message and wait for the agent to finish responding.
+ * Returns the assistant message locator.
+ */
+export async function sendMessage(page: Page, text: string) {
+  const chatInput = page.getByTestId('chat-input');
+  await expect(chatInput).toBeEnabled({ timeout: 60_000 });
+
+  const messageList = page.getByTestId('message-list');
+  const existingCount = await messageList.getByTestId(/^chat-message-/).count();
+
+  await chatInput.fill(text);
+  await page.getByRole('button', { name: 'Send message' }).click();
+
+  const assistantMessage = messageList.getByTestId(`chat-message-${existingCount + 1}`);
+  await expect(assistantMessage).toBeVisible({ timeout: 60_000 });
+  await expect(assistantMessage).not.toContainText('ECONNREFUSED');
+
+  // Wait for streaming to complete so the agent is idle for subsequent tests.
+  await chatInput.fill('.');
+  await expect(page.getByRole('button', { name: 'Send message' })).toBeEnabled({ timeout: 30_000 });
+
+  return assistantMessage;
+}
+
+export { expect };

browser-tests/tests/chat-invocation.test.ts

@@ -1,22 +1,10 @@
-import { expect, test } from '../fixtures';
+import { expect, sendMessage, test } from '../fixtures';
 
 test.describe('Chat invocation', () => {
   test('send a message and receive a response', async ({ page }) => {
     await page.goto('/');
 
-    const chatInput = page.getByTestId('chat-input');
-    await expect(chatInput).toBeEnabled({ timeout: 60_000 });
-
-    await chatInput.fill('What is 2 plus 2? Reply with just the number.');
-    await page.getByRole('button', { name: 'Send message' }).click();
-
-    const messageList = page.getByTestId('message-list');
-    await expect(messageList).toBeVisible();
-
-    await expect(messageList.getByTestId('chat-message-0')).toBeVisible({ timeout: 10_000 });
-
-    const assistantMessage = messageList.getByTestId('chat-message-1');
-    await expect(assistantMessage).toBeVisible({ timeout: 60_000 });
+    const assistantMessage = await sendMessage(page, 'What is 2 plus 2? Reply with just the number.');
     await expect(assistantMessage).not.toBeEmpty();
   });
 });

browser-tests/tests/traces.test.ts

@@ -1,19 +1,10 @@
-import { expect, test } from '../fixtures';
+import { expect, sendMessage, test } from '../fixtures';
 
 test.describe('Traces', () => {
   test('traces panel shows trace after invocation', async ({ page }) => {
     await page.goto('/');
 
-    const chatInput = page.getByTestId('chat-input');
-    await expect(chatInput).toBeEnabled({ timeout: 60_000 });
-
-    await chatInput.fill('Say hello');
-    await page.getByRole('button', { name: 'Send message' }).click();
-
-    const messageList = page.getByTestId('message-list');
-    const assistantMessage = messageList.getByTestId('chat-message-1');
-    await expect(assistantMessage).toBeVisible({ timeout: 60_000 });
-    await expect(assistantMessage).not.toContainText('ECONNREFUSED');
+    await sendMessage(page, 'Say hello');
 
     await page.getByRole('tab', { name: 'Traces' }).click();
 

src/cli/operations/dev/utils.ts

@@ -1,4 +1,5 @@
-import { createConnection, createServer } from 'net';
+import { createServer } from 'net';
+import { request as httpRequest } from 'node:http';
 
 /** Check if a port is available on a specific host */
 function checkPort(port: number, host: string): Promise<boolean> {
@@ -39,24 +40,22 @@ export async function waitForPort(port: number, timeoutMs = 3000): Promise<boole
   return false;
 }
 
-/** Wait until a server is accepting connections on the given port, with timeout. */
-export async function waitForServerReady(port: number, timeoutMs = 60000): Promise<boolean> {
+/** Wait until a server is responding to HTTP requests on the given port, with timeout. */
+export function waitForServerReady(port: number, timeoutMs = 60000): Promise<boolean> {
   const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    const listening = await new Promise<boolean>(resolve => {
-      const socket = createConnection({ port, host: '127.0.0.1' }, () => {
-        socket.destroy();
+  return new Promise(resolve => {
+    const attempt = () => {
+      if (Date.now() - start > timeoutMs) return resolve(false);
+      const req = httpRequest({ hostname: '127.0.0.1', port, path: '/', method: 'GET', timeout: 2000 }, res => {
+        res.resume();
         resolve(true);
       });
-      socket.on('error', () => {
-        socket.destroy();
-        resolve(false);
-      });
-    });
-    if (listening) return true;
-    await new Promise(resolve => setTimeout(resolve, 500));
-  }
-  return false;
+      req.on('error', () => setTimeout(attempt, 500));
+      req.on('timeout', () => req.destroy());
+      req.end();
+    };
+    attempt();
+  });
 }
 
 /** Sleep helper for retry delays. */

src/cli/operations/dev/web-ui/handlers/start.ts

@@ -170,10 +170,12 @@ async function doStartAgent(
     return { success: false, name: agentName, port: 0, error: errorMsg };
   }
 
-  ctx.runningAgents.set(agentName, { server: agentServer, port: agentPort, protocol: config.protocol });
-
-  // Wait for the server to actually accept connections before telling the
-  // frontend it's ready — otherwise immediate invocations get ECONNREFUSED.
+  // Wait for the server to accept HTTP requests, not just TCP connections.
+  // uvicorn binds the port before the ASGI app is ready, so a TCP-only check
+  // lets the frontend send invocations that get ECONNREFUSED or 503.
+  // The agent must NOT be added to runningAgents until this check passes,
+  // otherwise /api/status reports it as running and concurrent /api/start
+  // calls short-circuit without verifying readiness.
   const ready = await waitForServerReady(agentPort);
   if (!ready) {
     const errorMsg =
@@ -182,5 +184,6 @@ async function doStartAgent(
     return { success: false, name: agentName, port: 0, error: errorMsg };
   }
 
+  ctx.runningAgents.set(agentName, { server: agentServer, port: agentPort, protocol: config.protocol });
   return { success: true, name: agentName, port: agentPort };
 }