@lark-apaas/devtool-kits 1.0.4 → 1.0.5-alpha.1

package/dist/error.html

@@ -111,6 +111,12 @@
     let errorData = {
       message: `{{.errorData.message}}`,
     };
+
+    // 探针配置
+    const PROBE_INTERVAL = 2000; // 探测间隔 2 秒
+    const PROBE_TIMEOUT = 5000;  // 单次请求超时 5 秒
+    let probeTimer = null;
+
     // 初始化页面
     function init() {
       // 通知前端，渲染错误页面已准备就绪
@@ -125,6 +131,84 @@
           data: errorData,
         });
       }
+
+      // 启动服务恢复探针
+      startServiceProbe();
+    }
+
+    // 启动服务恢复探针
+    function startServiceProbe() {
+      console.log('[Probe] 启动服务恢复探针，间隔:', PROBE_INTERVAL, 'ms');
+
+      // 立即执行一次探测
+      probeService();
+
+      // 设置定时探测
+      probeTimer = setInterval(probeService, PROBE_INTERVAL);
+    }
+
+    // 停止探针
+    function stopServiceProbe() {
+      if (probeTimer) {
+        clearInterval(probeTimer);
+        probeTimer = null;
+        console.log('[Probe] 服务恢复探针已停止');
+      }
+    }
+
+    // 探测服务是否恢复
+    async function probeService() {
+      try {
+        // 获取当前 URL，去掉 _retry_count 参数
+        const currentUrl = getCurrentUrlWithoutRetryCount();
+
+        console.log('[Probe] 探测服务状态:', currentUrl);
+
+        // 使用 AbortController 实现超时控制
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT);
+
+        const response = await fetch(currentUrl, {
+          method: 'HEAD', // 使用 HEAD 方法，只检查状态不下载内容
+          cache: 'no-cache',
+          signal: controller.signal
+        });
+
+        clearTimeout(timeoutId);
+
+        // 检查响应状态
+        if (response.ok && response.status === 200) {
+          console.log('[Probe] 服务已恢复，准备刷新页面');
+          stopServiceProbe();
+
+          // 延迟一小段时间后刷新，让日志输出完整
+          setTimeout(() => {
+            console.log('[Probe] 刷新页面...');
+            window.location.href = currentUrl;
+          }, 300);
+        } else {
+          console.log('[Probe] 服务未恢复，状态码:', response.status);
+        }
+      } catch (error) {
+        // 网络错误、超时或服务未恢复
+        if (error.name === 'AbortError') {
+          console.log('[Probe] 探测超时');
+        } else {
+          console.log('[Probe] 探测失败:', error.message);
+        }
+        // 继续下一次探测
+      }
+    }
+
+    // 获取当前 URL（去掉 _retry_count 参数）
+    function getCurrentUrlWithoutRetryCount() {
+      try {
+        const url = new URL(window.location.href);
+        url.searchParams.delete('_retry_count');
+        return url.pathname + url.search;
+      } catch (e) {
+        return window.location.pathname;
+      }
     }
 
     // 复制错误信息到剪贴板
@@ -196,19 +280,20 @@
 
     // 复制到剪贴板
     async function copyToClipboard(text) {
-      try {
-        // 优先使用现代的 Clipboard API
-        if (navigator.clipboard && window.isSecureContext) {
+      // 优先使用现代的 Clipboard API
+      if (navigator.clipboard && window.isSecureContext) {
+        try {
           await navigator.clipboard.writeText(text);
           return true;
+        } catch (error) {
+          // 权限被拒绝或其他错误，降级到 execCommand
+          console.warn('Clipboard API 失败，降级到 execCommand:', error);
+          return fallbackCopyToClipboard(text);
         }
-
-        // 降级方案：使用传统的 execCommand 方法
-        return fallbackCopyToClipboard(text);
-      } catch (error) {
-        console.error('复制到剪切板失败:', error);
-        return false;
       }
+
+      // 降级方案：使用传统的 execCommand 方法
+      return fallbackCopyToClipboard(text);
     }
 
     // 降级复制方案（兼容旧浏览器）

package/dist/index.cjs

@@ -28407,7 +28407,52 @@ var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
 var import_node_fs3 = require("fs");
 var import_node_readline = require("readline");
+var import_node_net = require("net");
 var errorHtmlTemplate = null;
+function isConnectionError(err) {
+  const code = err.code;
+  const connectionErrorCodes = [
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "ENETUNREACH"
+  ];
+  return connectionErrorCodes.includes(code || "");
+}
+__name(isConnectionError, "isConnectionError");
+function checkServiceAvailable(host, port, timeout = 1e3) {
+  return new Promise((resolve) => {
+    const socket = (0, import_node_net.connect)(port, host);
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeout);
+    socket.on("connect", () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+__name(checkServiceAvailable, "checkServiceAvailable");
+async function waitForServiceRecovery(host, port, timeout, interval) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const isAvailable = await checkServiceAvailable(host, port);
+    if (isAvailable) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  return false;
+}
+__name(waitForServiceRecovery, "waitForServiceRecovery");
 function getDirname() {
   return __dirname;
 }
@@ -28436,7 +28481,10 @@ async function readRecentErrorLogs(logDir, maxLogs, fileName) {
   try {
     await import_node_fs2.default.promises.access(logFilePath);
   } catch {
-    return [];
+    return {
+      logs: [],
+      hasCompileError: false
+    };
   }
   const allLines = [];
   const stream = (0, import_node_fs3.createReadStream)(logFilePath, {
@@ -28465,20 +28513,26 @@ async function readRecentErrorLogs(logDir, maxLogs, fileName) {
     }
   }
   if (startIndex === -1) {
-    return [];
+    return {
+      logs: [],
+      hasCompileError: false
+    };
   }
   let endIndex = allLines.length;
+  let hasCompileError = false;
   for (let i = startIndex; i < allLines.length; i++) {
     if (/Found \d+ errors?\./.test(allLines[i])) {
       endIndex = i + 1;
+      hasCompileError = true;
       break;
     }
   }
   const errorSection = allLines.slice(startIndex, endIndex);
-  if (errorSection.length > maxLogs) {
-    return errorSection.slice(-maxLogs);
-  }
-  return errorSection;
+  const logs = errorSection.length > maxLogs ? errorSection.slice(-maxLogs) : errorSection;
+  return {
+    logs,
+    hasCompileError
+  };
 }
 __name(readRecentErrorLogs, "readRecentErrorLogs");
 function injectErrorData(template, errorLogs) {
@@ -28492,8 +28546,8 @@ function injectErrorData(template, errorLogs) {
  ${JSON.stringify(logsText)}`);
 }
 __name(injectErrorData, "injectErrorData");
-function handleDevProxyError(err, _req, res, options) {
-  const { logDir = import_node_path2.default.join(process.cwd(), "logs"), maxErrorLogs = 100, logFileName = "server.log" } = options || {};
+function handleDevProxyError(err, req, res, options) {
+  const { logDir = import_node_path2.default.join(process.cwd(), "logs"), maxErrorLogs = 100, logFileName = "server.log", retryTimeout = 5e3, retryInterval = 500, target, maxRedirects = 3 } = options || {};
   console.error("[Proxy Error]:", err.message);
   if (res.headersSent) {
     console.error("[Proxy Error]: Headers already sent, cannot send error page");
@@ -28501,7 +28555,32 @@ function handleDevProxyError(err, _req, res, options) {
   }
   (async () => {
     try {
-      const errorLogs = await readRecentErrorLogs(logDir, maxErrorLogs, logFileName);
+      const isConnError = isConnectionError(err);
+      const { logs: errorLogs, hasCompileError } = await readRecentErrorLogs(logDir, maxErrorLogs, logFileName);
+      if (isConnError && !hasCompileError && target) {
+        console.log("[Proxy Error]: Connection error without compile errors, possibly server restarting...");
+        let targetUrl = null;
+        try {
+          targetUrl = new URL(target);
+        } catch (e) {
+          console.error("[Proxy Error]: Invalid target URL:", target);
+        }
+        if (targetUrl) {
+          const host = targetUrl.hostname;
+          const port = targetUrl.port ? parseInt(targetUrl.port) : targetUrl.protocol === "https:" ? 443 : 80;
+          console.log(`[Proxy Error]: Waiting for service recovery at ${host}:${port} (timeout: ${retryTimeout}ms)...`);
+          const recovered = await waitForServiceRecovery(host, port, retryTimeout, retryInterval);
+          if (recovered) {
+            console.log("[Proxy Error]: Service recovered, sending retry response");
+          } else {
+            console.log("[Proxy Error]: Service did not recover within timeout, sending retry response");
+          }
+        }
+        const redirected = sendSimpleRetryResponse(req, res, maxRedirects);
+        if (redirected) return;
+        console.log("[Proxy Error]: Falling back to scenario 2 (detailed error page)");
+      }
+      console.log("[Proxy Error]: Compile error or non-connection error, showing error page");
       const template = getErrorHtmlTemplate();
       const html = injectErrorData(template, errorLogs);
       res.writeHead(502, {
@@ -28510,7 +28589,7 @@ function handleDevProxyError(err, _req, res, options) {
       });
       res.end(html);
     } catch (error) {
-      console.error("[Proxy Error]: Failed to send error page:", error);
+      console.error("[Proxy Error]: Failed to handle error:", error);
       if (!res.headersSent) {
         res.writeHead(502, {
           "Content-Type": "text/plain; charset=utf-8"
@@ -28521,6 +28600,45 @@ function handleDevProxyError(err, _req, res, options) {
   })();
 }
 __name(handleDevProxyError, "handleDevProxyError");
+function getRedirectCount(url) {
+  try {
+    const urlObj = new URL(url, "http://localhost");
+    const retryCount = urlObj.searchParams.get("_retry_count");
+    return retryCount ? parseInt(retryCount, 10) : 0;
+  } catch {
+    return 0;
+  }
+}
+__name(getRedirectCount, "getRedirectCount");
+function addRedirectCount(url, count) {
+  try {
+    const urlObj = new URL(url, "http://localhost");
+    urlObj.searchParams.set("_retry_count", String(count));
+    return urlObj.pathname + urlObj.search;
+  } catch {
+    return url;
+  }
+}
+__name(addRedirectCount, "addRedirectCount");
+function sendSimpleRetryResponse(req, res, maxRedirects) {
+  if (res.headersSent) return true;
+  const originalUrl = req.url || "/";
+  const currentCount = getRedirectCount(originalUrl);
+  if (currentCount >= maxRedirects) {
+    console.log(`[Proxy Error]: Max redirects (${maxRedirects}) reached, will show detailed error page`);
+    return false;
+  }
+  const nextCount = currentCount + 1;
+  const redirectUrl = addRedirectCount(originalUrl, nextCount);
+  console.log(`[Proxy Error]: Redirecting (attempt ${nextCount}/${maxRedirects}) to ${redirectUrl}`);
+  res.writeHead(302, {
+    "Location": redirectUrl,
+    "Cache-Control": "no-cache, no-store, must-revalidate"
+  });
+  res.end();
+  return true;
+}
+__name(sendSimpleRetryResponse, "sendSimpleRetryResponse");
 
 // src/middlewares/index.ts
 var import_node_path8 = __toESM(require("path"), 1);