fix: avoid detecting build durations as ports

Author: dasomji

README.md

@@ -20,6 +20,8 @@ Use it when your dev server is running on a remote machine and you want to open
 - Runs any command you pass it, such as `pnpm dev`, `npm run dev`, `bun run dev`, or `python -m http.server`.
 - Streams the child command's stdout/stderr normally.
 - Detects common dev-server output formats, including `http://localhost:5173`, `http://127.0.0.1:3000`, `started server on 0.0.0.0:8080`, and `PORT=4321`.
+- Ignores timing output like `ready in 500 ms` so it does not accidentally expose port `500`.
+- Waits briefly after the first candidate port so multi-process commands, such as Laravel plus Vite, can print the better app-server URL.
 - Waits for the detected port to accept local connections before exposing it.
 - Runs `tailscale serve --bg http://127.0.0.1:<port>`.
 - Prints the HTTPS MagicDNS URL for the current Tailscale device.
@@ -150,6 +152,22 @@ That prints a URL like:
 https://my-host.tailabc.ts.net:8450
 ```
 
+### Laravel / `composer run dev`
+
+Laravel development commands often start both the PHP app server and the Vite asset server. `lizardtail` prefers output from the app server when it can see both ports:
+
+```bash
+lizardtail composer run dev
+```
+
+If your app server lands on a known port, you can force it:
+
+```bash
+lizardtail --port 8001 composer run dev
+```
+
+If browser assets fail to load, the Vite server may also need to be exposed or your Laravel/Vite config may need to allow the Tailscale hostname.
+
 ### Longer startup timeout
 
 ```bash

src/index.ts

@@ -17,6 +17,7 @@ export interface Options {
 }
 
 export const DEFAULT_TIMEOUT_MS = 30_000;
+const DETECTION_SETTLE_MS = 1_500;
 
 export function printUsage(): void {
   console.error(`Usage: lizardtail [options] -- <command> [args...]
@@ -158,19 +159,62 @@ export function stripAnsi(input: string): string {
   return input.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
 }
 
+interface PortCandidate {
+  port: number;
+  score: number;
+}
+
 export function detectPortFromText(text: string): number | undefined {
+  const candidates = detectPortCandidates(text);
+  candidates.sort((a, b) => b.score - a.score);
+  return candidates[0]?.port;
+}
+
+function detectPortCandidates(text: string): PortCandidate[] {
   const clean = stripAnsi(text);
+  const candidates: PortCandidate[] = [];
+
+  for (const line of clean.split(/\r?\n/)) {
+    candidates.push(...detectPortCandidatesFromLine(line));
+  }
 
-  const localUrl = clean.match(/https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]|::1)(?::(\d{1,5}))?/i);
-  if (localUrl?.[1]) return validDetectedPort(localUrl[1]);
+  return candidates;
+}
+
+function detectPortCandidatesFromLine(line: string): PortCandidate[] {
+  const candidates: PortCandidate[] = [];
+  const lowerLine = line.toLowerCase();
+  const lineLooksLikeDuration = /\b\d{1,5}\s*ms\b/i.test(line);
+  const lineLooksLikeServer = /\b(server|listening|started|running)\b/i.test(line) || /\[server\]/i.test(line);
+  const lineLooksLikeVite = /\[vite\]|\bvite\b/i.test(line);
+
+  const localUrlPattern = /https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]|::1):(\d{1,5})/gi;
+  for (const match of line.matchAll(localUrlPattern)) {
+    const port = validDetectedPort(match[2]);
+    if (!port) continue;
+
+    let score = 70;
+    if (lineLooksLikeServer) score += 30;
+    if (lineLooksLikeVite) score -= 15;
+    if (match[1] === "0.0.0.0") score -= 10;
+    candidates.push({ port, score });
+  }
 
-  const anyLocalUrl = clean.match(/(?:Local|localhost|loopback|listening|ready|server|started|running)[^\n\r]*?(?:on|at|:)?\s*(?:https?:\/\/)?(?:[^\s:]+:)?(\d{2,5})/i);
-  if (anyLocalUrl?.[1]) return validDetectedPort(anyLocalUrl[1]);
+  if (lineLooksLikeDuration) return candidates;
 
-  const portPhrase = clean.match(/\b(?:port|PORT)\s*(?:=|:|is|on)?\s*(\d{2,5})\b/);
-  if (portPhrase?.[1]) return validDetectedPort(portPhrase[1]);
+  const portPhrase = line.match(/\b(?:port|PORT)\s*(?:=|:|is|on)?\s*(\d{2,5})\b/);
+  if (portPhrase?.[1]) {
+    const port = validDetectedPort(portPhrase[1]);
+    if (port) candidates.push({ port, score: lowerLine.includes("in use") ? 20 : 45 });
+  }
+
+  const serverPort = line.match(/\b(?:listening|started|running|server)\b[^\n\r]*:(\d{2,5})\b/i);
+  if (serverPort?.[1]) {
+    const port = validDetectedPort(serverPort[1]);
+    if (port) candidates.push({ port, score: lineLooksLikeServer ? 60 : 40 });
+  }
 
-  return undefined;
+  return candidates;
 }
 
 function validDetectedPort(value: string): number | undefined {
@@ -318,6 +362,7 @@ export async function main(): Promise<void> {
   let exposed = false;
   let exposing: Promise<void> | undefined;
   let recentOutput = "";
+  let detectionTimer: NodeJS.Timeout | undefined;
 
   const stopChild = () => {
     if (!child.killed) child.kill("SIGTERM");
@@ -345,7 +390,14 @@ export async function main(): Promise<void> {
   const inspectChunk = (chunk: string) => {
     recentOutput = (recentOutput + chunk).slice(-8_000);
     const detectedPort = detectPortFromText(recentOutput);
-    if (detectedPort) expose(detectedPort);
+    if (!detectedPort || exposed || exposing) return;
+
+    if (detectionTimer) clearTimeout(detectionTimer);
+    detectionTimer = setTimeout(() => {
+      detectionTimer = undefined;
+      const settledPort = detectPortFromText(recentOutput);
+      if (settledPort) expose(settledPort);
+    }, DETECTION_SETTLE_MS);
   };
 
   child.stdout.on("data", (chunk: string) => {
@@ -383,6 +435,7 @@ export async function main(): Promise<void> {
 
   const [code, signal] = (await once(child, "exit")) as [number | null, NodeJS.Signals | null];
   if (timeout) clearTimeout(timeout);
+  if (detectionTimer) clearTimeout(detectionTimer);
   if (exposing) await exposing;
 
   if (signal) process.kill(process.pid, signal);

tests/index.test.ts

@@ -24,10 +24,22 @@ test("detectPortFromText strips ANSI escape sequences", () => {
   assert.equal(detectPortFromText(output), 24678);
 });
 
-test("detectPortFromText ignores invalid and missing ports", () => {
+test("detectPortFromText ignores invalid ports, missing ports, and build durations", () => {
   assert.equal(detectPortFromText("Server ready"), undefined);
   assert.equal(detectPortFromText("Local: http://localhost"), undefined);
   assert.equal(detectPortFromText("port 70000"), undefined);
+  assert.equal(detectPortFromText("VITE v8.0.13 ready in 500 ms"), undefined);
+});
+
+// Laravel's `composer run dev` commonly runs Vite and `php artisan serve` together.
+// Prefer the app server URL over Vite's asset server when both appear in the recent output.
+// Also ensure Vite's "ready in 500 ms" timing line is not mistaken for port 500.
+test("detectPortFromText prefers Laravel app server output over Vite output", () => {
+  const output = `[vite]   VITE v8.0.13  ready in 500 ms
+[vite]   ➜  Local:   http://localhost:5174/
+[server]    INFO  Server running on [http://127.0.0.1:8001].`;
+
+  assert.equal(detectPortFromText(output), 8001);
 });
 
 test("parseArgs parses options before the command", () => {
@@ -196,7 +208,7 @@ exit 1
 const server = http.createServer((req, res) => res.end("ok"));
 server.listen(0, "127.0.0.1", () => {
   console.log("Local: http://localhost:" + server.address().port);
-  setTimeout(() => server.close(), 1200);
+  setTimeout(() => server.close(), 2500);
 });`,
       ],
       {