Update from GitHub Actions

src/config.js

@@ -29,7 +29,7 @@ const config = {
   },
 
   // 要执行的命令
-  command: 'service cron start',
+  command: 'service cron start && date',
 
   // 截图保存目录
   screenshotDir: './screenshots',

src/execute-command.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'url';
 import path from 'path';
 
 import { createBrowserSession, navigateToWebIDE, executeCommandFlow } from './utils/webide-utils.js';
+import { info, error } from './utils/logger.js';
 
 async function executeCommand() {
 
@@ -20,16 +21,16 @@ async function executeCommand() {
 
     // 保持浏览器打开一段时间以便查看结果
     if (!config.browserOptions.headless) {
-      console.log('浏览器将保持打开5秒以便查看结果...');
+      info('浏览器将保持打开5秒以便查看结果...');
       await page.waitForTimeout(5000);
     }
 
-  } catch (error) {
-    console.error('执行命令过程中发生错误:', error);
+  } catch (err) {
+    error('执行命令过程中发生错误:', err);
   } finally {
     if (browser) {
       await browser.close();
-      console.log('浏览器已关闭');
+      info('浏览器已关闭');
     }
   }
 }
@@ -39,7 +40,7 @@ const __filename = fileURLToPath(import.meta.url);
 const scriptPath = path.resolve(process.argv[1]);
 
 if (path.resolve(__filename) === scriptPath) {
-  executeCommand().catch(console.error);
+  executeCommand().catch(error);
 }
 
 export { executeCommand };

src/login.js

@@ -3,9 +3,10 @@ import fs from 'fs';
 import config from './config.js';
 import { fileURLToPath } from 'url';
 import path from 'path';
-import { loadCookies, saveScreenshot, getHumanReadableTimestamp } from './utils/common-utils.js';
+import { loadCookies } from './utils/common-utils.js';
+import { info, error } from './utils/logger.js';
 async function login() {
-  console.log('启动浏览器...');
+  info('启动浏览器...');
   const browser = await chromium.launch(config.browserOptions);
   const context = await browser.newContext();
 
@@ -15,55 +16,55 @@ async function login() {
   const page = await context.newPage();
 
   try {
-    console.log(`导航到登录页面:${config.webideUrl}...`);
+    info(`导航到登录页面:${config.webideUrl}...`);
     // 首先访问主页面，通常会重定向到登录页面
     await page.goto(config.webideUrl);
 
     // 等待页面加载
     await page.waitForTimeout(config.waitTimes.pageLoad);
 
-    console.log('当前页面URL:', page.url());
-    console.log('页面标题:', await page.title());
+    info('当前页面URL:', page.url());
+    info('页面标题:', await page.title());
 
     // 检查是否已经登录（如果页面包含编辑器元素，说明已登录）
     const isLoggedIn = await page.locator(config.selectors.editor).count() > 0;
 
     if (isLoggedIn) {
-      console.log('检测到已经登录状态，保存cookie...');
+      info('检测到已经登录状态，保存cookie...');
     } else {
-      console.log('需要登录，请在浏览器中手动完成登录过程...');
-      console.log('登录完成后，请按 Enter 键继续...');
+      info('需要登录，请在浏览器中手动完成登录过程...');
+      info('登录完成后，请按 Enter 键继续...');
 
       // 等待用户手动登录
       await waitForUserInput();
 
       // 等待登录完成，检查是否出现编辑器界面
-      console.log('等待登录完成...');
+      info('等待登录完成...');
       try {
         await page.goto(config.webideUrl);
         await page.waitForSelector(config.selectors.editor, {
           timeout: 60000
         });
 
-      } catch (error) {
-        console.log('未检测到编辑器界面，但继续保存cookie...');
+      } catch (err) {
+        info('未检测到编辑器界面，但继续保存cookie...');
       }
     }
 
     // 保存cookies
     const cookies = await context.cookies();
     fs.writeFileSync(config.cookieFile, JSON.stringify(cookies, null, 2));
-    console.log(`Cookies已保存到 ${config.cookieFile}`);
-    console.log(`保存了 ${cookies.length} 个cookies`);
+    info(`Cookies已保存到 ${config.cookieFile}`);
+    info(`保存了 ${cookies.length} 个cookies`);
 
     // 显示保存的cookie信息（仅显示名称，不显示值）
-    console.log('保存的cookie名称:');
+    info('保存的cookie名称:');
     cookies.forEach(cookie => {
-      console.log(`  - ${cookie.name} (域名: ${cookie.domain})`);
+      info(`  - ${cookie.name} (域名: ${cookie.domain})`);
     });
 
-  } catch (error) {
-    console.error('登录过程中发生错误:', error);
+  } catch (err) {
+    error('登录过程中发生错误:', err);
   } finally {
     await browser.close();
   }
@@ -90,6 +91,6 @@ const __filename = fileURLToPath(import.meta.url);
 const scriptPath = path.resolve(process.argv[1]);
 
 if (path.resolve(__filename) === scriptPath) {
-  login().catch(console.error);
+  login().catch(error);
 }
 

src/scheduler.js

@@ -1,21 +1,22 @@
 import config from './config.js';
 import { fileURLToPath } from 'url';
 import path from 'path';
-import {  getHumanReadableTimestamp, log, logError } from './utils/common-utils.js';
+import { getHumanReadableTimestamp } from './utils/common-utils.js';
 import { createBrowserSession, navigateToWebIDE, executeCommandFlow } from './utils/webide-utils.js';
+import { info, error } from './utils/logger.js';
 
 // 执行单次命令的函数
 async function executeCommandOnce(page) {
-  log(`[${getHumanReadableTimestamp()}] 开始执行命令...`);
+  info(`[${getHumanReadableTimestamp()}] 开始执行命令...`);
   return executeCommandFlow(page, 'scheduler');
 }
 
 // 主调度器函数
 async function startScheduler() {
 
-  log(`[${getHumanReadableTimestamp()}] 启动调度器...`);
+  info(`[${getHumanReadableTimestamp()}] 启动调度器...`);
   const intervalSeconds = Math.round(config.schedulerInterval / 1000);
-  log(`调度器将每${intervalSeconds}秒执行一次命令以防止编辑器休眠`);
+  info(`调度器将每${intervalSeconds}秒执行一次命令以防止编辑器休眠`);
 
   let browser;
   try {
@@ -33,43 +34,43 @@ async function startScheduler() {
     const intervalId = setInterval(async () => {
       try {
         // 重新导航到页面以确保页面活跃
-        log(`[${getHumanReadableTimestamp()}] 重新导航到WebIDE页面...`);
+        info(`[${getHumanReadableTimestamp()}] 重新导航到WebIDE页面...`);
         await navigateToWebIDE(page);
 
         // 执行命令
         await executeCommandOnce(page);
-      } catch (error) {
-        logError(`[${getHumanReadableTimestamp()}] 定时任务执行失败:`, error);
+      } catch (err) {
+        error(`[${getHumanReadableTimestamp()}] 定时任务执行失败:`, err);
       }
     }, config.schedulerInterval);
 
-    log(`[${getHumanReadableTimestamp()}] 调度器已启动，将每${intervalSeconds}秒执行一次命令`);
-    log('按 Ctrl+C 停止调度器');
+    info(`[${getHumanReadableTimestamp()}] 调度器已启动，将每${intervalSeconds}秒执行一次命令`);
+    info('按 Ctrl+C 停止调度器');
 
     // 监听进程退出信号
     process.on('SIGINT', async () => {
-      log(`\n[${getHumanReadableTimestamp()}] 收到停止信号，正在关闭调度器...`);
+      info(`\n[${getHumanReadableTimestamp()}] 收到停止信号，正在关闭调度器...`);
       clearInterval(intervalId);
       if (browser) {
         await browser.close();
       }
-      log('调度器已停止，浏览器已关闭');
+      info('调度器已停止，浏览器已关闭');
       process.exit(0);
     });
 
     // 保持进程运行
     process.on('SIGTERM', async () => {
-      log(`\n[${getHumanReadableTimestamp()}] 收到终止信号，正在关闭调度器...`);
+      info(`\n[${getHumanReadableTimestamp()}] 收到终止信号，正在关闭调度器...`);
       clearInterval(intervalId);
       if (browser) {
         await browser.close();
       }
-      log('调度器已停止，浏览器已关闭');
+      info('调度器已停止，浏览器已关闭');
       process.exit(0);
     });
 
-  } catch (error) {
-    logError(`[${getHumanReadableTimestamp()}] 调度器启动失败:`, error);
+  } catch (err) {
+    error(`[${getHumanReadableTimestamp()}] 调度器启动失败:`, err);
     if (browser) {
       await browser.close();
     }
@@ -81,7 +82,7 @@ const __filename = fileURLToPath(import.meta.url);
 const scriptPath = path.resolve(process.argv[1]);
 
 if (path.resolve(__filename) === scriptPath) {
-  startScheduler().catch(console.error);
+  startScheduler().catch(error);
 }
 
 export { startScheduler };

src/start-services.js

@@ -6,7 +6,7 @@
  */
 
 import { spawn } from 'child_process';
-import { log, logError } from './utils/common-utils.js';
+import { info as log, error as logError } from './utils/logger.js';
 
 // 存储子进程
 const processes = [];

src/utils/common-utils.js

@@ -1,99 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-
-// 日志文件路径
-const LOG_FILE = './logs/app.log';
-const LOG_DIR = './logs';
-
-/**
- * 确保日志目录存在
- */
-function ensureLogDirectory() {
-  if (!fs.existsSync(LOG_DIR)) {
-    fs.mkdirSync(LOG_DIR, { recursive: true });
-  }
-}
-
-/**
- * 写入日志到文件
- * @param {string} level - 日志级别 (INFO, ERROR, WARN)
- * @param {string} message - 日志消息
- */
-export function writeLog(level, message) {
-  ensureLogDirectory();
-  const timestamp = new Date().toISOString();
-  const logEntry = `[${timestamp}] [${level}] ${message}\n`;
-
-  try {
-    fs.appendFileSync(LOG_FILE, logEntry);
-  } catch (error) {
-    console.error('写入日志文件失败:', error);
-  }
-}
-
-/**
- * 增强的 console.log，同时输出到控制台和文件
- * @param {...any} args - 要记录的参数
- */
-export function log(...args) {
-  const message = args.map(arg =>
-    typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
-  ).join(' ');
-
-  console.log(...args);
-  writeLog('INFO', message);
-}
-
-/**
- * 增强的 console.error，同时输出到控制台和文件
- * @param {...any} args - 要记录的参数
- */
-export function logError(...args) {
-  const message = args.map(arg =>
-    typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
-  ).join(' ');
-
-  console.error(...args);
-  writeLog('ERROR', message);
-}
-
-/**
- * 读取最近的日志
- * @param {number} lines - 要读取的行数，默认100行
- * @returns {Array} 日志行数组
- */
-export function getRecentLogs(lines = 100) {
-  try {
-    if (!fs.existsSync(LOG_FILE)) {
-      return [];
-    }
-
-    const content = fs.readFileSync(LOG_FILE, 'utf8');
-    const logLines = content.trim().split('\n').filter(line => line.length > 0);
-
-    // 返回最后 N 行
-    return logLines.slice(-lines);
-  } catch (error) {
-    console.error('读取日志文件失败:', error);
-    return [];
-  }
-}
-
-/**
- * 清空日志文件
- * @returns {boolean} 是否成功清空
- */
-export function clearLogFile() {
-  try {
-    ensureLogDirectory();
-    fs.writeFileSync(LOG_FILE, '');
-    console.log('日志文件已清空');
-    return true;
-  } catch (error) {
-    console.error('清空日志文件失败:', error);
-    return false;
-  }
-}
+import { info, error } from './logger.js';
 
 /**
  * 创建人类可读的时间戳
@@ -118,7 +25,7 @@ export function getHumanReadableTimestamp() {
 export function ensureScreenshotDirectory(dir) {
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
-    console.log(`创建截图目录: ${dir}`);
+    info(`创建截图目录: ${dir}`);
   }
 }
 
@@ -131,20 +38,20 @@ export function ensureScreenshotDirectory(dir) {
 export function checkCookieAvailability(cookieFile, cookiesFromEnv) {
   // 优先检查环境变量
   if (cookiesFromEnv) {
-    console.log('发现环境变量COOKIES，将使用环境变量中的cookies');
+    info('发现环境变量COOKIES，将使用环境变量中的cookies');
     try {
       JSON.parse(cookiesFromEnv);
       return true;
-    } catch (error) {
-      console.error('环境变量COOKIES格式无效:', error.message);
-      console.log('将尝试使用cookie文件...');
+    } catch (err) {
+      error('环境变量COOKIES格式无效:', err.message);
+      info('将尝试使用cookie文件...');
     }
   }
 
   // 检查cookie文件
   if (!fs.existsSync(cookieFile)) {
-    console.error(`Cookie文件不存在: ${cookieFile}`);
-    console.log('请先运行 npm run login 进行登录，或设置环境变量COOKIES');
+    error(`Cookie文件不存在: ${cookieFile}`);
+    info('请先运行 npm run login 进行登录，或设置环境变量COOKIES');
     return false;
   }
   return true;
@@ -157,8 +64,8 @@ export function checkCookieAvailability(cookieFile, cookiesFromEnv) {
  */
 export function checkCookieFile(cookieFile) {
   if (!fs.existsSync(cookieFile)) {
-    console.error(`Cookie文件不存在: ${cookieFile}`);
-    console.log('请先运行 npm run login 进行登录');
+    error(`Cookie文件不存在: ${cookieFile}`);
+    info('请先运行 npm run login 进行登录');
     return false;
   }
   return true;
@@ -174,23 +81,23 @@ export function loadCookies(cookieFile, cookiesFromEnv) {
   try {
     // 优先使用环境变量
     if (cookiesFromEnv) {
-      console.log('从环境变量COOKIES加载cookies...');
+      info('从环境变量COOKIES加载cookies...');
       const cookies = JSON.parse(cookiesFromEnv);
-      console.log(`已从环境变量加载 ${cookies.length} 个cookies`);
+      info(`已从环境变量加载 ${cookies.length} 个cookies`);
       return cookies;
     }
 
     // 使用文件
     if (fs.existsSync(cookieFile)) {
-      console.log(`从文件加载cookies: ${cookieFile}`);
+      info(`从文件加载cookies: ${cookieFile}`);
       const cookies = JSON.parse(fs.readFileSync(cookieFile, 'utf8'));
-      console.log(`已从文件加载 ${cookies.length} 个cookies`);
+      info(`已从文件加载 ${cookies.length} 个cookies`);
       return cookies;
     }
     return [];
-  } catch (error) {
-    console.error('读取 Cookie 失败:', error);
-    throw error;
+  } catch (err) {
+    error('读取 Cookie 失败:', err);
+    throw err;
   }
 }
 
@@ -204,8 +111,8 @@ export function loadCookies(cookieFile, cookiesFromEnv) {
 export async function saveScreenshot(page, screenshotDir, prefix = 'screenshot') {
   ensureScreenshotDirectory(screenshotDir);
   const timestamp = getHumanReadableTimestamp();
-  const screenshotPath = path.join(screenshotDir, `${prefix}-${timestamp}.png`);
+  const screenshotPath = path.join(screenshotDir, `${prefix}.png`);
   await page.screenshot({ path: screenshotPath });
-  console.log(`截图已保存: ${screenshotPath}`);
+  info(`截图已保存: ${screenshotPath}`);
   return screenshotPath;
 }

src/utils/logger.js

@@ -0,0 +1,195 @@
+import fs from 'fs';
+
+// 日志级别枚举
+export const LogLevel = {
+  DEBUG: 'DEBUG',
+  INFO: 'INFO',
+  WARN: 'WARN',
+  ERROR: 'ERROR'
+};
+
+// 日志配置
+const LOG_CONFIG = {
+  logFile: './logs/app.log',
+  logDir: './logs',
+  enableConsole: true,
+  enableFile: true,
+  logLevel: LogLevel.INFO
+};
+
+/**
+ * 确保日志目录存在
+ */
+function ensureLogDirectory() {
+  if (!fs.existsSync(LOG_CONFIG.logDir)) {
+    fs.mkdirSync(LOG_CONFIG.logDir, { recursive: true });
+  }
+}
+
+/**
+ * 格式化日志消息
+ * @param {...any} args - 要记录的参数
+ * @returns {string} 格式化后的消息
+ */
+function formatMessage(...args) {
+  return args.map(arg =>
+    typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
+  ).join(' ');
+}
+
+/**
+ * 写入日志到文件
+ * @param {string} level - 日志级别
+ * @param {string} message - 日志消息
+ */
+function writeToFile(level, message) {
+  if (!LOG_CONFIG.enableFile) return;
+
+  ensureLogDirectory();
+  const timestamp = new Date().toISOString();
+  const logEntry = `[${timestamp}] [${level}] ${message}\n`;
+
+  try {
+    fs.appendFileSync(LOG_CONFIG.logFile, logEntry);
+  } catch (error) {
+    // 避免循环调用，直接使用console
+    console.error('写入日志文件失败:', error);
+  }
+}
+
+/**
+ * 输出到控制台
+ * @param {string} level - 日志级别
+ * @param {...any} args - 要记录的参数
+ */
+function writeToConsole(level, ...args) {
+  if (!LOG_CONFIG.enableConsole) return;
+
+  switch (level) {
+    case LogLevel.DEBUG:
+      console.debug(...args);
+      break;
+    case LogLevel.INFO:
+      console.log(...args);
+      break;
+    case LogLevel.WARN:
+      console.warn(...args);
+      break;
+    case LogLevel.ERROR:
+      console.error(...args);
+      break;
+    default:
+      console.log(...args);
+  }
+}
+
+/**
+ * 通用日志记录函数
+ * @param {string} level - 日志级别
+ * @param {...any} args - 要记录的参数
+ */
+function writeLog(level, ...args) {
+  const message = formatMessage(...args);
+
+  // 输出到控制台
+  writeToConsole(level, ...args);
+
+  // 写入文件
+  writeToFile(level, message);
+}
+
+/**
+ * DEBUG级别日志
+ * @param {...any} args - 要记录的参数
+ */
+export function debug(...args) {
+  writeLog(LogLevel.DEBUG, ...args);
+}
+
+/**
+ * INFO级别日志（替代console.log）
+ * @param {...any} args - 要记录的参数
+ */
+export function info(...args) {
+  writeLog(LogLevel.INFO, ...args);
+}
+
+/**
+ * WARN级别日志（替代console.warn）
+ * @param {...any} args - 要记录的参数
+ */
+export function warn(...args) {
+  writeLog(LogLevel.WARN, ...args);
+}
+
+/**
+ * ERROR级别日志（替代console.error）
+ * @param {...any} args - 要记录的参数
+ */
+export function error(...args) {
+  writeLog(LogLevel.ERROR, ...args);
+}
+
+/**
+ * 读取最近的日志
+ * @param {number} lines - 要读取的行数，默认100行
+ * @returns {Array} 日志行数组
+ */
+export function getRecentLogs(lines = 100) {
+  try {
+    if (!fs.existsSync(LOG_CONFIG.logFile)) {
+      return [];
+    }
+
+    const content = fs.readFileSync(LOG_CONFIG.logFile, 'utf8');
+    const logLines = content.trim().split('\n').filter(line => line.length > 0);
+
+    // 返回最后 N 行
+    return logLines.slice(-lines);
+  } catch (err) {
+    console.error('读取日志文件失败:', err);
+    return [];
+  }
+}
+
+/**
+ * 清空日志文件
+ * @returns {boolean} 是否成功清空
+ */
+export function clearLogFile() {
+  try {
+    ensureLogDirectory();
+    fs.writeFileSync(LOG_CONFIG.logFile, '');
+    info('日志文件已清空');
+    return true;
+  } catch (err) {
+    error('清空日志文件失败:', err);
+    return false;
+  }
+}
+
+/**
+ * 配置日志设置
+ * @param {Object} config - 日志配置
+ */
+export function configureLogger(config = {}) {
+  Object.assign(LOG_CONFIG, config);
+}
+
+// 为了向后兼容，导出原有的函数名
+export const log = info;
+export const logError = error;
+
+// 默认导出logger对象
+export default {
+  debug,
+  info,
+  warn,
+  error,
+  log: info,
+  logError: error,
+  getRecentLogs,
+  clearLogFile,
+  configureLogger,
+  LogLevel
+};

src/utils/webide-utils.js

@@ -1,6 +1,7 @@
 import { chromium } from 'playwright';
 import config from '../config.js';
 import { loadCookies, saveScreenshot, getHumanReadableTimestamp } from './common-utils.js';
+import { info, error } from './logger.js';
 
 /**
  * 创建浏览器实例和上下文
@@ -9,7 +10,7 @@ import { loadCookies, saveScreenshot, getHumanReadableTimestamp } from './common
  * @returns {Object} { browser, context, page }
  */
 export async function createBrowserSession(cookieFile, cookiesFromEnv) {
-  console.log('启动浏览器...');
+  info('启动浏览器...');
   const browser = await chromium.launch(config.browserOptions);
   const context = await browser.newContext();
 
@@ -27,24 +28,24 @@ export async function createBrowserSession(cookieFile, cookiesFromEnv) {
  * @param {Object} page - Playwright 页面对象
  */
 export async function navigateToWebIDE(page) {
-  console.log('导航到WebIDE页面...');
+  info('导航到WebIDE页面...');
   await page.goto(config.webideUrl);
 
   // 等待页面加载
   await page.waitForTimeout(config.waitTimes.pageLoad);
 
-  console.log('当前页面URL:', page.url());
-  console.log('页面标题:', await page.title());
+  info('当前页面URL:', page.url());
+  info('页面标题:', await page.title());
 
   // 检查是否成功登录
   try {
     await page.waitForSelector(config.selectors.editor, {
       timeout: 60000
     });
-    console.log('成功进入WebIDE界面');
+    info('成功进入WebIDE界面');
     return true;
-  } catch (error) {
-    console.log('警告: 未检测到编辑器界面，可能需要重新登录');
+  } catch (err) {
+    info('警告: 未检测到编辑器界面，可能需要重新登录');
     return false;
   }
 }
@@ -57,14 +58,14 @@ export async function handleModalDialog(page) {
   try {
     const dialogButton = await page.waitForSelector(config.selectors.dialogButton, { timeout: 30000 });
     if (dialogButton && await dialogButton.isVisible()) {
-      console.log('发现模态对话框按钮，点击处理...');
+      info('发现模态对话框按钮，点击处理...');
       await dialogButton.click();
       await page.waitForTimeout(500);
       return true;
     }
-  } catch (error) {
+  } catch (err) {
     // 没有找到对话框按钮，继续执行
-    console.log('未发现模态对话框，继续执行...');
+    info('未发现模态对话框，继续执行...');
   }
   return false;
 }
@@ -75,7 +76,7 @@ export async function handleModalDialog(page) {
  * @returns {Object|null} 终端元素或 null
  */
 export async function openTerminal(page) {
-  console.log('尝试打开终端 (Ctrl+~)...');
+  info('尝试打开终端 (Ctrl+~)...');
 
   // 确保页面获得焦点
   await page.click('body');
@@ -97,17 +98,17 @@ export async function openTerminal(page) {
     try {
       terminalElement = await page.waitForSelector(selector, { timeout: 2000 });
       if (terminalElement) {
-        console.log(`找到终端元素: ${selector}`);
+        info(`找到终端元素: ${selector}`);
         terminalFound = true;
         break;
       }
-    } catch (error) {
+    } catch (err) {
       // 继续尝试下一个选择器
     }
   }
 
   if (!terminalFound) {
-    console.log('未找到终端元素，尝试直接输入命令...');
+    info('未找到终端元素，尝试直接输入命令...');
     return null;
   } else {
     // 点击终端区域确保焦点
@@ -123,7 +124,7 @@ export async function openTerminal(page) {
  * @param {string} command - 要执行的命令
  */
 export async function executeTerminalCommand(page, command) {
-  console.log(`执行命令: ${command}`);
+  info(`执行命令: ${command}`);
 
   // 输入命令
   await page.keyboard.type(command);
@@ -135,7 +136,7 @@ export async function executeTerminalCommand(page, command) {
   // 等待命令执行
   await page.waitForTimeout(config.waitTimes.commandExecution);
 
-  console.log('命令已执行');
+  info('命令已执行');
 }
 
 /**
@@ -156,12 +157,12 @@ export async function executeCommandFlow(page, screenshotPrefix = 'screenshot')
     await executeTerminalCommand(page, config.command);
 
     // 截图保存执行结果
-    // const screenshotDir = config.screenshotDir || './screenshots';
-    // const screenshotPath = await saveScreenshot(page, screenshotDir, screenshotPrefix);
+    const screenshotDir = config.screenshotDir || './screenshots';
+    const screenshotPath = await saveScreenshot(page, screenshotDir, screenshotPrefix);
 
     return true;
-  } catch (error) {
-    console.error(`[${getHumanReadableTimestamp()}] 执行命令时发生错误:`, error);
+  } catch (err) {
+    error(`[${getHumanReadableTimestamp()}] 执行命令时发生错误:`, err);
     return false;
   }
 }

src/web-server.js

@@ -1,9 +1,15 @@
 import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
-import { getRecentLogs, log, logError, clearLogFile } from './utils/common-utils.js';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { getRecentLogs, clearLogFile } from './utils/logger.js';
+import { info as log, error as logError } from './utils/logger.js';
 import config from './config.js';
 
 const app = new Hono();
+
+// 静态文件服务 - 提供 screenshots 目录
+app.use('/screenshots/*', serveStatic({ root: './' }));
+
 // 静态 HTML 页面
 const indexHTML = `
 <!DOCTYPE html>
@@ -129,6 +135,23 @@ const indexHTML = `
             color: #6c757d;
             font-style: italic;
         }
+        .screenshot-section {
+            padding: 20px;
+            border-bottom: 1px solid #eee;
+            text-align: center;
+        }
+        .screenshot-section h2 {
+            margin: 0 0 15px 0;
+            color: #333;
+            font-size: 1.2em;
+        }
+        .screenshot-section img {
+            max-width: 100%;
+            height: auto;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
     </style>
 </head>
 <body>
@@ -160,6 +183,11 @@ const indexHTML = `
         <div class="status" id="status">
             准备就绪
         </div>
+        <div class="screenshot-section">
+            <h2>📸 最新截图</h2>
+            <img src="/screenshots/scheduler.png" alt="Scheduler Screenshot" onerror="this.style.display='none'; this.nextElementSibling.style.display='block';">
+            <div style="display: none; color: #6c757d; font-style: italic;">截图文件不存在或无法加载</div>
+        </div>
     </div>
 
     <script>