fix(e2e): fix serverUrl port detection using URL constructor

The getServerUrl helper used .includes(':') to detect an explicit port,
which false-positived on the scheme colon (e.g. http://localhost).
Extract resolveServerUrl using the URL constructor and apply to both
dev() and serve().

Author: jacekradko

integration/models/__tests__/application.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveServerUrl } from '../application';
+
+describe('resolveServerUrl', () => {
+  describe('with opts.serverUrl', () => {
+    it('appends port to a URL without an explicit port', () => {
+      expect(resolveServerUrl('http://localhost', undefined, 3000)).toBe('http://localhost:3000');
+    });
+
+    it('appends port to an https URL without an explicit port', () => {
+      expect(resolveServerUrl('https://example.com', undefined, 4000)).toBe('https://example.com:4000');
+    });
+
+    it('preserves an explicit port in the URL', () => {
+      expect(resolveServerUrl('http://localhost:8080', undefined, 3000)).toBe('http://localhost:8080');
+    });
+
+    it('handles a URL with a path (returns origin only)', () => {
+      expect(resolveServerUrl('http://localhost/some/path', undefined, 3000)).toBe('http://localhost:3000');
+    });
+
+    it('handles a bare hostname by appending port', () => {
+      expect(resolveServerUrl('myhost', undefined, 5000)).toBe('myhost:5000');
+    });
+
+    it('handles a bare IP address by appending port', () => {
+      expect(resolveServerUrl('127.0.0.1', undefined, 5000)).toBe('127.0.0.1:5000');
+    });
+  });
+
+  describe('with fallback serverUrl', () => {
+    it('uses fallback when opts.serverUrl is undefined', () => {
+      expect(resolveServerUrl(undefined, 'http://fallback:9000', 3000)).toBe('http://fallback:9000');
+    });
+
+    it('prefers opts.serverUrl over fallback', () => {
+      expect(resolveServerUrl('http://localhost', 'http://fallback:9000', 3000)).toBe('http://localhost:3000');
+    });
+  });
+
+  describe('with no serverUrl at all', () => {
+    it('defaults to http://localhost with the given port', () => {
+      expect(resolveServerUrl(undefined, undefined, 4567)).toBe('http://localhost:4567');
+    });
+
+    it('defaults when fallback is empty string', () => {
+      expect(resolveServerUrl(undefined, '', 4567)).toBe('http://localhost:4567');
+    });
+  });
+});

integration/models/application.ts

@@ -9,6 +9,31 @@ import type { EnvironmentConfig } from './environment.js';
 
 export type Application = ReturnType<typeof application>;
 
+/**
+ * Resolves the server URL for a dev/serve process, ensuring the runtime port
+ * is always reflected in the URL. Uses the URL constructor to detect whether
+ * an explicit port is present (avoiding false positives from the scheme colon).
+ */
+export const resolveServerUrl = (
+  optsServerUrl: string | undefined,
+  fallbackServerUrl: string | undefined,
+  port: number,
+): string => {
+  if (optsServerUrl) {
+    try {
+      const parsed = new URL(optsServerUrl);
+      if (!parsed.port) {
+        parsed.port = String(port);
+      }
+      return parsed.origin;
+    } catch {
+      // Bare host (e.g. "localhost"), not a full URL
+      return `${optsServerUrl}:${port}`;
+    }
+  }
+  return fallbackServerUrl || `http://localhost:${port}`;
+};
+
 export const application = (
   config: ApplicationConfig,
   appDirPath: string,
@@ -58,13 +83,7 @@ export const application = (
     dev: async (opts: { port?: number; manualStart?: boolean; detached?: boolean; serverUrl?: string } = {}) => {
       const log = logger.child({ prefix: 'dev' }).info;
       const port = opts.port || (await getPort());
-      const getServerUrl = () => {
-        if (opts.serverUrl) {
-          return opts.serverUrl.includes(':') ? opts.serverUrl : `${opts.serverUrl}:${port}`;
-        }
-        return serverUrl || `http://localhost:${port}`;
-      };
-      const runtimeServerUrl = getServerUrl();
+      const runtimeServerUrl = resolveServerUrl(opts.serverUrl, serverUrl, port);
       log(`Will try to serve app at ${runtimeServerUrl}`);
       if (opts.manualStart) {
         // for debugging, you can start the dev server manually by cd'ing into the temp dir
@@ -147,13 +166,7 @@ export const application = (
     serve: async (opts: { port?: number; manualStart?: boolean; detached?: boolean; serverUrl?: string } = {}) => {
       const log = logger.child({ prefix: 'serve' }).info;
       const port = opts.port || (await getPort());
-      const getServerUrl = () => {
-        if (opts.serverUrl) {
-          return opts.serverUrl.includes(':') ? opts.serverUrl : `${opts.serverUrl}:${port}`;
-        }
-        return serverUrl || `http://localhost:${port}`;
-      };
-      const runtimeServerUrl = getServerUrl();
+      const runtimeServerUrl = resolveServerUrl(opts.serverUrl, serverUrl, port);
       log(`Will try to serve app at ${runtimeServerUrl}`);
 
       if (opts.manualStart) {