@se-studio/site-check 2.1.0 → 2.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 2.1.1
+
+### Patch Changes
+
+- Fix `smoke-test-one` appearing to hang: add fetch timeouts, startup/progress logging, fail fast when port is busy but not responding, reuse an already-healthy dev server (`SMOKE_TEST_USE_RUNNING_SERVER`, default true), and inherit stdio so dev server output is visible.
+
 ## 2.1.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@se-studio/site-check",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Validate SE marketing sites (sitemap, llms.txt) and download markdown files preserving structure",
   "repository": {
     "type": "git",

package/smoke-test-one.mjs

@@ -5,13 +5,15 @@
  * Usage: smoke-test-one <port>  (from app directory)
  *
  * Env:
- *   SMOKE_TEST_IGNORE=true          — skip entirely
- *   SMOKE_TEST_SERVER_SCRIPT=dev:dev — pnpm script to start server (default dev:dev; use "start" for prod)
- *   SMOKE_TEST_VERIFY_CACHE=true    — run smoke twice and assert cache headers / timing
- *   SMOKE_TEST_READY_PATH=/         — path polled until server responds
- *   LOG_CMS_FETCH=1                 — set automatically when SMOKE_TEST_VERIFY_CACHE=true
+ *   SMOKE_TEST_IGNORE=true              — skip entirely
+ *   SMOKE_TEST_SERVER_SCRIPT=dev:dev    — pnpm script to start server (default dev:dev; use "start" for prod)
+ *   SMOKE_TEST_VERIFY_CACHE=true        — run smoke twice and assert cache headers / timing
+ *   SMOKE_TEST_READY_PATH=/             — path polled until server responds
+ *   SMOKE_TEST_USE_RUNNING_SERVER=true  — reuse server already on port (default true)
+ *   LOG_CMS_FETCH=1                     — set automatically when SMOKE_TEST_VERIFY_CACHE=true
  */
 
+import net from 'node:net';
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
@@ -25,6 +27,15 @@ if (!port || !/^\d+$/.test(port)) {
 const appDir = process.cwd();
 const baseUrl = `http://localhost:${port}`;
 const pollIntervalMs = 1_000;
+const progressIntervalMs = 10_000;
+const fetchTimeoutMs = 10_000;
+
+function fetchWithTimeout(url, options = {}) {
+  return fetch(url, {
+    ...options,
+    signal: AbortSignal.timeout(fetchTimeoutMs),
+  });
+}
 
 function parseEnvFile(filePath) {
   const env = {};
@@ -49,20 +60,70 @@ function loadEnv() {
   return { ...process.env, ...envLocal, PORT: port };
 }
 
-async function waitForServer(url, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(url, { method: 'GET', redirect: 'follow' });
-      if (res.status >= 200 && res.status < 500) {
-        return;
-      }
-    } catch {
-      // Server not ready yet
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function isServerUp(url) {
+  try {
+    const res = await fetchWithTimeout(url, { method: 'GET', redirect: 'follow' });
+    return res.status >= 200 && res.status < 500;
+  } catch {
+    return false;
+  }
+}
+
+function isPortListening(listenPort) {
+  return new Promise((resolve) => {
+    const socket = net.connect(Number(listenPort), '127.0.0.1');
+    socket.setTimeout(2_000);
+    socket.once('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once('timeout', () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.once('error', () => resolve(false));
+  });
+}
+
+async function waitForServer(url, timeoutMs, options = {}) {
+  const { child, label = 'Server' } = options;
+  const started = Date.now();
+  let lastProgressAt = 0;
+  let childExited = false;
+  let childExitCode = null;
+
+  if (child) {
+    child.on('exit', (code) => {
+      childExited = true;
+      childExitCode = code;
+    });
+  }
+
+  while (Date.now() - started < timeoutMs) {
+    if (childExited) {
+      throw new Error(
+        `${label} process exited with code ${childExitCode ?? 'unknown'} before ${url} was ready`,
+      );
+    }
+
+    if (await isServerUp(url)) {
+      return Date.now() - started;
+    }
+
+    const elapsed = Date.now() - started;
+    if (elapsed - lastProgressAt >= progressIntervalMs) {
+      console.log(`Still waiting for ${url} (${Math.round(elapsed / 1000)}s)...`);
+      lastProgressAt = elapsed;
     }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+
+    await sleep(pollIntervalMs);
   }
-  throw new Error(`Server did not respond at ${url} within ${timeoutMs}ms`);
+
+  throw new Error(`${label} did not respond at ${url} within ${timeoutMs}ms`);
 }
 
 function killProcessTree(child) {
@@ -78,21 +139,6 @@ function killProcessTree(child) {
   }
 }
 
-function createLogForwarder(onLine) {
-  let buffer = '';
-  return (chunk) => {
-    process.stdout.write(chunk);
-    buffer += chunk.toString();
-    let newlineIndex = buffer.indexOf('\n');
-    while (newlineIndex !== -1) {
-      const line = buffer.slice(0, newlineIndex);
-      buffer = buffer.slice(newlineIndex + 1);
-      onLine(line);
-      newlineIndex = buffer.indexOf('\n');
-    }
-  };
-}
-
 const env = loadEnv();
 
 if ((env.SMOKE_TEST_IGNORE ?? '').toLowerCase() === 'true') {
@@ -102,6 +148,7 @@ if ((env.SMOKE_TEST_IGNORE ?? '').toLowerCase() === 'true') {
 
 const serverScript = env.SMOKE_TEST_SERVER_SCRIPT ?? 'dev:dev';
 const verifyCache = (env.SMOKE_TEST_VERIFY_CACHE ?? '').toLowerCase() === 'true';
+const useRunningServer = (env.SMOKE_TEST_USE_RUNNING_SERVER ?? 'true').toLowerCase() !== 'false';
 const readyPath = env.SMOKE_TEST_READY_PATH ?? '/';
 const readyUrl = `${baseUrl}${readyPath.startsWith('/') ? readyPath : `/${readyPath}`}`;
 const isProductionStart = serverScript === 'start';
@@ -119,36 +166,52 @@ if (isProductionStart) {
   }
 }
 
-let cmsFetchCount = 0;
-
-const logForwarder = createLogForwarder((line) => {
-  if (!line.includes('[CMS fetch]')) return;
-  cmsFetchCount++;
-});
-
 const smokeEnv = {
   ...env,
   SMOKE_TEST_PORT: port,
   ...(verifyCache ? { SMOKE_TEST_VERIFY_CACHE: 'true', LOG_CMS_FETCH: '1' } : {}),
 };
 
-console.log(`Starting server (${serverScript}) on ${baseUrl}...`);
-const server = spawn('pnpm', [serverScript], {
-  cwd: appDir,
-  env: smokeEnv,
-  stdio: ['inherit', 'pipe', 'pipe'],
-  detached: true,
-});
-
-server.stdout?.on('data', logForwarder);
-server.stderr?.on('data', logForwarder);
+console.log(`Smoke test: checking ${readyUrl} (port ${port})...`);
 
+let server = null;
+let spawnedServer = false;
 let exitCode = 1;
 
 try {
-  await waitForServer(readyUrl, startTimeoutMs);
-  console.log(`Server ready at ${readyUrl}. Running smoke tests...`);
+  const serverUp = await isServerUp(readyUrl);
+  const portBusy = await isPortListening(port);
+
+  if (serverUp && useRunningServer) {
+    console.log(`Using existing server at ${readyUrl}.`);
+  } else if (serverUp && !useRunningServer) {
+    console.error(
+      `Server already running at ${readyUrl}. Stop it first, or set SMOKE_TEST_USE_RUNNING_SERVER=true.`,
+    );
+    process.exit(1);
+  } else if (portBusy) {
+    console.error(
+      `Port ${port} is in use but ${readyUrl} is not responding. Stop the process on :${port} and retry.`,
+    );
+    process.exit(1);
+  } else {
+    console.log(`Starting server (${serverScript}) on ${baseUrl}...`);
+    server = spawn('pnpm', [serverScript], {
+      cwd: appDir,
+      env: smokeEnv,
+      stdio: 'inherit',
+      detached: true,
+    });
+    spawnedServer = true;
+
+    const readyMs = await waitForServer(readyUrl, startTimeoutMs, {
+      child: server,
+      label: 'Dev server',
+    });
+    console.log(`Server ready at ${readyUrl} (${Math.round(readyMs / 1000)}s).`);
+  }
 
+  console.log('Running smoke tests...');
   const runResult = spawnSync('pnpm', ['smoke-test:run'], {
     cwd: appDir,
     stdio: 'inherit',
@@ -158,15 +221,19 @@ try {
 
   if (verifyCache) {
     console.log('');
-    console.log('## CMS fetch log count (LOG_CMS_FETCH=1 on dev server)');
-    console.log(`  total [CMS fetch] lines during smoke run: ${cmsFetchCount}`);
-    console.log('  (pass-level split is in x-nextjs-cache headers in the smoke report)');
+    console.log('## CMS fetch logging');
+    console.log(
+      '  LOG_CMS_FETCH=1 is set on the dev server — check its terminal for [CMS fetch] lines.',
+    );
+    console.log('  Pass-level cache stats are in the smoke report (x-nextjs-cache).');
   }
 } catch (error) {
   console.error(error instanceof Error ? error.message : error);
   exitCode = 1;
 } finally {
-  killProcessTree(server);
+  if (spawnedServer) {
+    killProcessTree(server);
+  }
 }
 
 process.exit(exitCode);