fix: nitro app workaround

.github/workflows/tests.yml

@@ -188,7 +188,7 @@ jobs:
         run: ./scripts/resolve-symlinks.sh workbench/${{ matrix.app.name }}
 
       - name: Run E2E Tests
-        run: cd workbench/${{ matrix.app.name }} && pnpm dev & echo "starting tests in 10 seconds" && sleep 10 && pnpm vitest run packages/core/e2e/dev.test.ts && pnpm run test:e2e
+        run: cd workbench/${{ matrix.app.name }} && pnpm dev & echo "starting tests in 10 seconds" && sleep 10 && pnpm vitest run packages/core/e2e/dev.test.ts && sleep 5 && pnpm run test:e2e
         env:
           APP_NAME: ${{ matrix.app.name }}
           DEPLOYMENT_URL: "http://localhost:${{ matrix.app.name == 'sveltekit' && '5173' || '3000' }}"

packages/utils/src/get-port.test.ts

@@ -1,80 +1,165 @@
 import http from 'node:http';
-import { describe, expect, it } from 'vitest';
+import type { AddressInfo } from 'node:net';
+import { afterEach, describe, expect, it } from 'vitest';
 import { getPort } from './get-port';
 
 describe('getPort', () => {
-  it('should return undefined or a positive number', async () => {
+  let servers: http.Server[] = [];
+
+  afterEach(() => {
+    servers.forEach((server) => {
+      server.close();
+    });
+    servers = [];
+  });
+
+  it('should return undefined when no ports are in use', async () => {
     const port = await getPort();
-    expect(port === undefined || typeof port === 'number').toBe(true);
-    if (port !== undefined) {
-      expect(port).toBeGreaterThan(0);
-    }
+
+    expect(port).toBeUndefined();
+  });
+
+  it('should handle servers listening on specific ports', async () => {
+    const server = http.createServer();
+    servers.push(server);
+
+    // Listen on a specific port instead of 0
+    const specificPort = 3000;
+    server.listen(specificPort);
+
+    const port = await getPort();
+
+    expect(port).toEqual(specificPort);
   });
 
-  it('should return a port number when a server is listening', async () => {
+  it('should return the port number that the server is listening', async () => {
     const server = http.createServer();
+    servers.push(server);
 
     server.listen(0);
 
-    try {
-      const port = await getPort();
-      const address = server.address();
-
-      // Port detection may not work immediately in all environments (CI, Docker, etc.)
-      // so we just verify the function returns a valid result
-      if (port !== undefined) {
-        expect(typeof port).toBe('number');
-        expect(port).toBeGreaterThan(0);
-
-        // If we have the address, optionally verify it matches
-        if (address && typeof address === 'object') {
-          // In most cases it should match, but not required for test to pass
-          expect([port, undefined]).toContain(port);
-        }
-      }
-    } finally {
-      await new Promise<void>((resolve, reject) => {
-        server.close((err) => (err ? reject(err) : resolve()));
-      });
-    }
+    const port = await getPort();
+    const addr = server.address() as AddressInfo;
+
+    expect(typeof port).toBe('number');
+    expect(port).toEqual(addr.port);
   });
 
-  it('should return the smallest port when multiple servers are listening', async () => {
+  it('should return the first port of the server', async () => {
     const server1 = http.createServer();
     const server2 = http.createServer();
+    servers.push(server1);
+    servers.push(server2);
 
     server1.listen(0);
     server2.listen(0);
 
+    const port = await getPort();
+    const addr1 = server1.address() as AddressInfo;
+
+    expect(port).toEqual(addr1.port);
+  });
+
+  it('should return consistent results when called multiple times', async () => {
+    const server = http.createServer();
+    servers.push(server);
+    server.listen(0);
+
+    const port1 = await getPort();
+    const port2 = await getPort();
+    const port3 = await getPort();
+
+    expect(port1).toEqual(port2);
+    expect(port2).toEqual(port3);
+  });
+
+  it('should handle IPv6 addresses', async () => {
+    const server = http.createServer();
+    servers.push(server);
+
     try {
+      server.listen(0, '::1'); // IPv6 localhost
       const port = await getPort();
-      const addr1 = server1.address();
-      const addr2 = server2.address();
-
-      // Port detection may not work in all environments
-      if (
-        port !== undefined &&
-        addr1 &&
-        typeof addr1 === 'object' &&
-        addr2 &&
-        typeof addr2 === 'object'
-      ) {
-        // Should return the smallest port
-        expect(port).toBeLessThanOrEqual(Math.max(addr1.port, addr2.port));
-        expect(port).toBeGreaterThan(0);
-      } else {
-        // If port detection doesn't work in this environment, just pass
-        expect(port === undefined || typeof port === 'number').toBe(true);
-      }
-    } finally {
-      await Promise.all([
-        new Promise<void>((resolve, reject) => {
-          server1.close((err) => (err ? reject(err) : resolve()));
-        }),
-        new Promise<void>((resolve, reject) => {
-          server2.close((err) => (err ? reject(err) : resolve()));
-        }),
-      ]);
+      const addr = server.address() as AddressInfo;
+
+      expect(port).toEqual(addr.port);
+    } catch {
+      // Skip test if IPv6 is not available
+      console.log('IPv6 not available, skipping test');
     }
   });
+
+  it('should handle multiple calls in sequence', async () => {
+    const server = http.createServer();
+    servers.push(server);
+
+    server.listen(0);
+
+    const port1 = await getPort();
+    const port2 = await getPort();
+    const addr = server.address() as AddressInfo;
+
+    // Should return the same port each time
+    expect(port1).toEqual(addr.port);
+    expect(port2).toEqual(addr.port);
+  });
+
+  it('should handle closed servers', async () => {
+    const server = http.createServer();
+
+    server.listen(0);
+    const addr = server.address() as AddressInfo;
+    const serverPort = addr.port;
+
+    // Close the server before calling getPort
+    server.close();
+
+    const port = await getPort();
+
+    // Port should not be the closed server's port
+    expect(port).not.toEqual(serverPort);
+  });
+
+  it('should handle server restart on same port', async () => {
+    const server1 = http.createServer();
+    servers.push(server1);
+    server1.listen(3000);
+
+    const port1 = await getPort();
+    expect(port1).toEqual(3000);
+
+    server1.close();
+    servers = servers.filter((s) => s !== server1);
+
+    // Small delay to ensure port is released
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    const server2 = http.createServer();
+    servers.push(server2);
+    server2.listen(3000);
+
+    const port2 = await getPort();
+    expect(port2).toEqual(3000);
+  });
+
+  it('should handle concurrent getPort calls', async () => {
+    // Workflow makes lots of concurrent getPort calls
+    const server = http.createServer();
+    servers.push(server);
+    server.listen(0);
+
+    const addr = server.address() as AddressInfo;
+
+    // Call getPort concurrently 10 times
+    const results = await Promise.all(
+      Array(10)
+        .fill(0)
+        .map(() => getPort())
+    );
+
+    // All should return the same port without errors
+    results.forEach((port) => {
+      expect(port).toEqual(addr.port);
+    });
+  });
 });

packages/utils/src/get-port.ts

@@ -1,23 +1,71 @@
-import { pidToPorts } from 'pid-port';
+import { exec, execFileSync } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
 
 /**
  * Gets the port number that the process is listening on.
  * @returns The port number that the process is listening on, or undefined if the process is not listening on any port.
- * NOTE: Can't move this to @workflow/utils because it's being imported into @workflow/errors for RetryableError (inside workflow runtime)
  */
 export async function getPort(): Promise<number | undefined> {
+  const { pid, platform } = process;
+
+  let port: number | undefined;
+
   try {
-    const pid = process.pid;
-    const ports = await pidToPorts(pid);
-    if (!ports || ports.size === 0) {
-      return undefined;
+    // Use our fallback
+    switch (platform) {
+      case 'linux':
+      case 'darwin': {
+        const lsofResult = execFileSync(
+          'lsof',
+          ['-a', '-i', '-P', '-n', '-p', pid.toString()],
+          {
+            encoding: 'utf-8',
+          }
+        );
+        const awkResult = execFileSync(
+          'awk',
+          ['/LISTEN/ {split($9,a,":"); print a[length(a)]; exit}'],
+          {
+            encoding: 'utf-8',
+            input: lsofResult,
+          }
+        );
+        const result = { stdout: awkResult };
+        port = parseInt(result.stdout.trim(), 10);
+        break;
+      }
+      case 'win32': {
+        const lsofResult = execFileSync(
+          'netstat',
+          ['-a', '-n', '-o', pid.toString()],
+          {
+            encoding: 'utf-8',
+          }
+        );
+        const awkResult = execFileSync(
+          'awk',
+          [
+            '/LISTENING/ && /${pid}/ {split($2,a,\":\"); print a[length(a)]; exit}',
+          ],
+          {
+            encoding: 'utf-8',
+            input: lsofResult,
+          }
+        );
+        const result = { stdout: awkResult };
+        port = parseInt(result.stdout.trim(), 10);
+        break;
+      }
+    }
+  } catch (error) {
+    // In dev, it's helpful to know why detection failed
+    if (process.env.NODE_ENV === 'development') {
+      console.debug('[getPort] Detection failed:', error);
     }
-
-    const smallest = Math.min(...ports);
-    return smallest;
-  } catch {
-    // If port detection fails (e.g., `ss` command not available in production),
-    // return undefined and fall back to default port
     return undefined;
   }
+
+  return port || undefined;
 }