Update from GitHub Actions

Dockerfile

@@ -33,27 +33,21 @@ COPY package*.json ./
 # 安装 Node.js 依赖
 RUN npm ci --only=production
 
-# 复制应用程序文件
-COPY config.js ./
-COPY cookies.json ./
-COPY execute-command.js ./
-COPY login.js ./
-COPY scheduler.js ./
-COPY web-server.js ./
-COPY start-services.js ./
-COPY utils/ ./utils/
-
-# 创建 screenshots 和 logs 目录
-RUN mkdir -p screenshots logs
-
 # 设置非 root 用户（安全最佳实践）
 RUN addgroup -g 1001 -S nodejs && \
     adduser -S nodejs -u 1001
 
-# 更改文件所有权，包括新创建的目录
-RUN chown -R nodejs:nodejs /app && \
-    chmod -R 755 /app/screenshots && \
-    chmod -R 755 /app/logs
+# 复制应用程序文件
+COPY src/ ./src/
+
+# 复制 cookies.json 文件（如果存在）
+COPY cookies.json* ./
+
+# 创建 screenshots 和 logs 目录，并设置正确的权限
+RUN mkdir -p screenshots logs && \
+    chown -R nodejs:nodejs /app && \
+    chmod -R 775 /app/screenshots && \
+    chmod -R 775 /app/logs
 
 # 切换到非 root 用户
 USER nodejs

package.json

@@ -4,12 +4,11 @@
   "description": "Playwright automation for CloudStudio WebIDE",
   "main": "index.js",
   "scripts": {
-    "login": "node login.js",
-    "execute": "node execute-command.js",
-    "scheduler": "node scheduler.js",
-    "web-server": "node web-server.js",
-    "start": "node start-services.js",
-    "start-web-only": "node web-server.js"
+    "login": "node src/login.js",
+    "execute": "node src/execute-command.js",
+    "scheduler": "node src/scheduler.js",
+    "web-server": "node src/web-server.js",
+    "start": "node src/start-services.js"
   },
   "keywords": ["playwright", "automation", "webide"],
   "author": "",

src/config.js

@@ -0,0 +1,59 @@
+// 配置文件
+import dotenv from 'dotenv';
+
+// 加载环境变量
+dotenv.config();
+
+const config = {
+  // WebIDE URL - 可以通过环境变量 WEBIDE_URL 覆盖
+  webideUrl: process.env.WEBIDE_URL || 'https://3e8ccf585a6c4fbd9f1aa9f05ac5e415.ap-shanghai.cloudstudio.club/?mode=edit',
+
+  // 调度器时间间隔（毫秒）- 可以通过环境变量 SCHEDULER_INTERVAL 覆盖
+  // 默认为 10 分钟 (10 * 60 * 1000 = 600000 毫秒)
+  schedulerInterval: parseInt(process.env.SCHEDULER_INTERVAL) || 10 * 60 * 1000,
+
+  // Cookie文件路径
+  cookieFile: './cookies.json',
+
+  // 浏览器配置
+  browserOptions: {
+    // 默认无头模式，可通过环境变量 HEADLESS=false 设置为有头模式
+    // 支持 false/False/FALSE 等不同大小写形式
+    headless: (process.env.HEADLESS || 'true').toLowerCase() !== 'false',
+    slowMo: 100,     // 操作间隔时间（毫秒）
+    timeout: 30000,   // 超时时间（毫秒）
+    executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH,
+  },
+
+  // 要执行的命令
+  command: 'service cron start',
+
+  // 截图保存目录
+  screenshotDir: './screenshots',
+
+  // 等待时间配置（毫秒）
+  waitTimes: {
+    pageLoad: 5000,      // 页面加载等待时间
+    terminalOpen: 3000,  // 终端打开等待时间
+    commandExecution: 2000 // 命令执行等待时间
+  },
+
+  // 页面选择器（需要根据实际登录页面调整）
+  selectors: {
+    // 这些选择器需要根据实际的登录页面进行调整
+    editor: '.monaco-grid-view',
+    dialogButton: '.monaco-dialog-modal-block .dialog-buttons a.monaco-button',
+    terminals: [
+      '.terminal',
+      // '.xterm',
+      // '.console',
+      // '.terminal-container',
+      // '.xterm-screen',
+      // '.monaco-workbench .part.panel .terminal',
+      // '[data-testid="terminal"]',
+      // '.integrated-terminal'
+    ],
+  }
+};
+
+export default config;

src/execute-command.js

@@ -0,0 +1,49 @@
+import config from './config.js';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { checkCookieFile } from './utils/common-utils.js';
+import { createBrowserSession, navigateToWebIDE, executeCommandFlow } from './utils/webide-utils.js';
+
+async function executeCommand() {
+  // 检查cookie文件是否存在
+  if (!checkCookieFile(config.cookieFile)) {
+    return;
+  }
+
+  let browser;
+  try {
+    // 创建浏览器会话
+    const { browser: browserInstance, page } = await createBrowserSession(config.cookieFile);
+    browser = browserInstance;
+
+    // 导航到WebIDE页面
+    await navigateToWebIDE(page);
+
+    // 执行命令流程
+    const success = await executeCommandFlow(page, 'screenshot');
+
+    // 保持浏览器打开一段时间以便查看结果
+    if (!config.browserOptions.headless) {
+      console.log('浏览器将保持打开5秒以便查看结果...');
+      await page.waitForTimeout(5000);
+    }
+
+  } catch (error) {
+    console.error('执行命令过程中发生错误:', error);
+  } finally {
+    if (browser) {
+      await browser.close();
+      console.log('浏览器已关闭');
+    }
+  }
+}
+
+// 运行命令执行脚本
+const __filename = fileURLToPath(import.meta.url);
+const scriptPath = path.resolve(process.argv[1]);
+
+if (path.resolve(__filename) === scriptPath) {
+  executeCommand().catch(console.error);
+}
+
+export { executeCommand };

src/login.js

@@ -0,0 +1,97 @@
+import { chromium } from 'playwright';
+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';
+async function login() {
+  console.log('启动浏览器...');
+  const browser = await chromium.launch(config.browserOptions);
+  const context = await browser.newContext();
+
+  if (fs.existsSync(config.cookieFile)) {
+    // 读取并设置cookies
+    const cookies = loadCookies(config.cookieFile);
+    await context.addCookies(cookies);
+  }
+
+  const page = await context.newPage();
+
+  try {
+    console.log(`导航到登录页面:${config.webideUrl}...`);
+    // 首先访问主页面，通常会重定向到登录页面
+    await page.goto(config.webideUrl);
+
+    // 等待页面加载
+    await page.waitForTimeout(config.waitTimes.pageLoad);
+
+    console.log('当前页面URL:', page.url());
+    console.log('页面标题:', await page.title());
+
+    // 检查是否已经登录（如果页面包含编辑器元素，说明已登录）
+    const isLoggedIn = await page.locator(config.selectors.editor).count() > 0;
+
+    if (isLoggedIn) {
+      console.log('检测到已经登录状态，保存cookie...');
+    } else {
+      console.log('需要登录，请在浏览器中手动完成登录过程...');
+      console.log('登录完成后，请按 Enter 键继续...');
+
+      // 等待用户手动登录
+      await waitForUserInput();
+
+      // 等待登录完成，检查是否出现编辑器界面
+      console.log('等待登录完成...');
+      try {
+        await page.waitForSelector(config.selectors.editor, {
+          timeout: 60000
+        });
+
+      } catch (error) {
+        console.log('未检测到编辑器界面，但继续保存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`);
+
+    // 显示保存的cookie信息（仅显示名称，不显示值）
+    console.log('保存的cookie名称:');
+    cookies.forEach(cookie => {
+      console.log(`  - ${cookie.name} (域名: ${cookie.domain})`);
+    });
+
+  } catch (error) {
+    console.error('登录过程中发生错误:', error);
+  } finally {
+    await browser.close();
+  }
+}
+
+// 等待用户输入的辅助函数
+async function waitForUserInput() {
+  const { default: readline } = await import('readline');
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question('', () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+// 运行命令执行脚本
+const __filename = fileURLToPath(import.meta.url);
+const scriptPath = path.resolve(process.argv[1]);
+
+if (path.resolve(__filename) === scriptPath) {
+  login().catch(console.error);
+}
+

src/scheduler.js

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

src/start-services.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+/**
+ * 服务启动脚本
+ * 同时启动 Web 服务器和调度器
+ */
+
+import { spawn } from 'child_process';
+import { log, logError } from './utils/common-utils.js';
+
+// 存储子进程
+const processes = [];
+
+/**
+ * 启动子进程
+ */
+function startProcess(name, command, args = []) {
+  log(`启动 ${name}...`);
+
+  const child = spawn('node', [command, ...args], {
+    stdio: 'inherit',
+    cwd: process.cwd()
+  });
+
+  child.on('error', (error) => {
+    logError(`${name} 启动失败:`, error);
+  });
+
+  child.on('exit', (code, signal) => {
+    if (code !== 0) {
+      logError(`${name} 异常退出，代码: ${code}, 信号: ${signal}`);
+    } else {
+      log(`${name} 正常退出`);
+    }
+  });
+
+  processes.push({ name, process: child });
+  return child;
+}
+
+/**
+ * 优雅关闭所有进程
+ */
+function gracefulShutdown() {
+  log('收到关闭信号，正在停止所有服务...');
+
+  processes.forEach(({ name, process }) => {
+    if (!process.killed) {
+      log(`停止 ${name}...`);
+      process.kill('SIGTERM');
+    }
+  });
+
+  // 等待一段时间后强制关闭
+  setTimeout(() => {
+    processes.forEach(({ name, process }) => {
+      if (!process.killed) {
+        log(`强制停止 ${name}...`);
+        process.kill('SIGKILL');
+      }
+    });
+    process.exit(0);
+  }, 5000);
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+  log('🚀 启动 CloudStudio Runner 服务');
+  log('='.repeat(50));
+
+  try {
+    // 启动 Web 服务器
+    const webServer = startProcess('Web 服务器', 'src/web-server.js');
+
+    // 等待一下确保 Web 服务器启动
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // 启动调度器
+    const scheduler = startProcess('调度器', 'src/scheduler.js');
+
+    log('='.repeat(50));
+    log('✅ 所有服务已启动');
+    log('📊 Web 界面: http://localhost:7860');
+    log('⏰ 调度器: 每10分钟执行一次任务');
+    log('按 Ctrl+C 停止所有服务');
+
+    // 监听退出信号
+    process.on('SIGINT', gracefulShutdown);
+    process.on('SIGTERM', gracefulShutdown);
+
+    // 保持主进程运行
+    process.on('exit', () => {
+      log('主进程退出');
+    });
+
+  } catch (error) {
+    logError('启动服务失败:', error);
+    process.exit(1);
+  }
+}
+
+// 运行主函数
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const scriptPath = path.resolve(process.argv[1]);
+
+if (path.resolve(__filename) === scriptPath) {
+  main().catch(error => {
+    logError('服务启动异常:', error);
+    process.exit(1);
+  });
+}
+
+export { main };

src/utils/common-utils.js

@@ -0,0 +1,153 @@
+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 {string} 格式化的时间戳 YYYY-MM-DD_HH-MM-SS
+ */
+export function getHumanReadableTimestamp() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  const seconds = String(now.getSeconds()).padStart(2, '0');
+
+  return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
+}
+
+/**
+ * 确保截图目录存在
+ * @param {string} dir - 目录路径
+ */
+export function ensureScreenshotDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    console.log(`创建截图目录: ${dir}`);
+  }
+}
+
+/**
+ * 检查 Cookie 文件是否存在
+ * @param {string} cookieFile - Cookie 文件路径
+ * @returns {boolean} 文件是否存在
+ */
+export function checkCookieFile(cookieFile) {
+  if (!fs.existsSync(cookieFile)) {
+    console.error(`Cookie文件不存在: ${cookieFile}`);
+    console.log('请先运行 npm run login 进行登录');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * 读取并解析 Cookie 文件
+ * @param {string} cookieFile - Cookie 文件路径
+ * @returns {Array} Cookie 数组
+ */
+export function loadCookies(cookieFile) {
+  try {
+    const cookies = JSON.parse(fs.readFileSync(cookieFile, 'utf8'));
+    console.log(`已加载 ${cookies.length} 个cookies`);
+    return cookies;
+  } catch (error) {
+    console.error('读取 Cookie 文件失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 保存截图
+ * @param {Object} page - Playwright 页面对象
+ * @param {string} screenshotDir - 截图目录
+ * @param {string} prefix - 文件名前缀
+ * @returns {string} 截图文件路径
+ */
+export async function saveScreenshot(page, screenshotDir, prefix = 'screenshot') {
+  ensureScreenshotDirectory(screenshotDir);
+  const timestamp = getHumanReadableTimestamp();
+  const screenshotPath = path.join(screenshotDir, `${prefix}-${timestamp}.png`);
+  await page.screenshot({ path: screenshotPath });
+  console.log(`截图已保存: ${screenshotPath}`);
+  return screenshotPath;
+}

src/utils/webide-utils.js

@@ -0,0 +1,166 @@
+import { chromium } from 'playwright';
+import config from '../config.js';
+import { loadCookies, saveScreenshot, getHumanReadableTimestamp } from './common-utils.js';
+
+/**
+ * 创建浏览器实例和上下文
+ * @param {string} cookieFile - Cookie 文件路径
+ * @returns {Object} { browser, context, page }
+ */
+export async function createBrowserSession(cookieFile) {
+  console.log('启动浏览器...');
+  const browser = await chromium.launch(config.browserOptions);
+  const context = await browser.newContext();
+
+  // 读取并设置cookies
+  const cookies = loadCookies(cookieFile);
+  await context.addCookies(cookies);
+
+  const page = await context.newPage();
+
+  return { browser, context, page };
+}
+
+/**
+ * 导航到 WebIDE 页面并验证登录状态
+ * @param {Object} page - Playwright 页面对象
+ */
+export async function navigateToWebIDE(page) {
+  console.log('导航到WebIDE页面...');
+  await page.goto(config.webideUrl);
+
+  // 等待页面加载
+  await page.waitForTimeout(config.waitTimes.pageLoad);
+
+  console.log('当前页面URL:', page.url());
+  console.log('页面标题:', await page.title());
+
+  // 检查是否成功登录
+  try {
+    await page.waitForSelector(config.selectors.editor, {
+      timeout: 60000
+    });
+    console.log('成功进入WebIDE界面');
+    return true;
+  } catch (error) {
+    console.log('警告: 未检测到编辑器界面，可能需要重新登录');
+    return false;
+  }
+}
+
+/**
+ * 处理模态对话框
+ * @param {Object} page - Playwright 页面对象
+ */
+export async function handleModalDialog(page) {
+  try {
+    const dialogButton = await page.waitForSelector(config.selectors.dialogButton, { timeout: 30000 });
+    if (dialogButton && await dialogButton.isVisible()) {
+      console.log('发现模态对话框按钮，点击处理...');
+      await dialogButton.click();
+      await page.waitForTimeout(500);
+      return true;
+    }
+  } catch (error) {
+    // 没有找到对话框按钮，继续执行
+    console.log('未发现模态对话框，继续执行...');
+  }
+  return false;
+}
+
+/**
+ * 打开终端
+ * @param {Object} page - Playwright 页面对象
+ * @returns {Object|null} 终端元素或 null
+ */
+export async function openTerminal(page) {
+  console.log('尝试打开终端 (Ctrl+~)...');
+
+  // 确保页面获得焦点
+  await page.click('body');
+  await page.waitForTimeout(500);
+
+  // 按下 Ctrl+~ 打开终端
+  await page.keyboard.press('Control+`');
+
+  // 等待终端打开
+  await page.waitForTimeout(config.waitTimes.terminalOpen);
+
+  // 尝试多种方式查找终端
+  const terminalSelectors = config.selectors.terminals;
+
+  let terminalFound = false;
+  let terminalElement = null;
+
+  for (const selector of terminalSelectors) {
+    try {
+      terminalElement = await page.waitForSelector(selector, { timeout: 2000 });
+      if (terminalElement) {
+        console.log(`找到终端元素: ${selector}`);
+        terminalFound = true;
+        break;
+      }
+    } catch (error) {
+      // 继续尝试下一个选择器
+    }
+  }
+
+  if (!terminalFound) {
+    console.log('未找到终端元素，尝试直接输入命令...');
+    return null;
+  } else {
+    // 点击终端区域确保焦点
+    await terminalElement.click();
+    await page.waitForTimeout(500);
+    return terminalElement;
+  }
+}
+
+/**
+ * 在终端中执行命令
+ * @param {Object} page - Playwright 页面对象
+ * @param {string} command - 要执行的命令
+ */
+export async function executeTerminalCommand(page, command) {
+  console.log(`执行命令: ${command}`);
+
+  // 输入命令
+  await page.keyboard.type(command);
+  await page.waitForTimeout(500);
+
+  // 按回车执行命令
+  await page.keyboard.press('Enter');
+
+  // 等待命令执行
+  await page.waitForTimeout(config.waitTimes.commandExecution);
+
+  console.log('命令已执行');
+}
+
+/**
+ * 完整的命令执行流程
+ * @param {Object} page - Playwright 页面对象
+ * @param {string} screenshotPrefix - 截图文件名前缀
+ * @returns {boolean} 执行是否成功
+ */
+export async function executeCommandFlow(page, screenshotPrefix = 'screenshot') {
+  try {
+    // 处理模态对话框
+    await handleModalDialog(page);
+
+    // 打开终端
+    await openTerminal(page);
+
+    // 执行命令
+    await executeTerminalCommand(page, config.command);
+
+    // 截图保存执行结果
+    // const screenshotDir = config.screenshotDir || './screenshots';
+    // const screenshotPath = await saveScreenshot(page, screenshotDir, screenshotPrefix);
+
+    return true;
+  } catch (error) {
+    console.error(`[${getHumanReadableTimestamp()}] 执行命令时发生错误:`, error);
+    return false;
+  }
+}

src/web-server.js

@@ -0,0 +1,335 @@
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { getRecentLogs, log, logError } from './utils/common-utils.js';
+import config from './config.js';
+
+const app = new Hono();
+
+// 静态 HTML 页面
+const indexHTML = `
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>CloudStudio Runner - 日志查看器</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background-color: #f5f5f5;
+            color: #333;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            text-align: center;
+        }
+        .header h1 {
+            margin: 0;
+            font-size: 2em;
+        }
+        .header p {
+            margin: 10px 0 0 0;
+            opacity: 0.9;
+        }
+        .controls {
+            padding: 20px;
+            border-bottom: 1px solid #eee;
+            display: flex;
+            gap: 10px;
+            align-items: center;
+            flex-wrap: wrap;
+        }
+        .controls label {
+            font-weight: bold;
+        }
+        .controls select, .controls button {
+            padding: 8px 12px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 14px;
+        }
+        .controls button {
+            background: #667eea;
+            color: white;
+            border: none;
+            cursor: pointer;
+            transition: background 0.3s;
+        }
+        .controls button:hover {
+            background: #5a6fd8;
+        }
+        .log-container {
+            padding: 20px;
+            max-height: 600px;
+            overflow-y: auto;
+        }
+        .log-entry {
+            margin-bottom: 8px;
+            padding: 8px;
+            border-radius: 4px;
+            font-family: 'Courier New', monospace;
+            font-size: 13px;
+            line-height: 1.4;
+            border-left: 3px solid #ddd;
+        }
+        .log-entry.info {
+            background-color: #f8f9fa;
+            border-left-color: #28a745;
+        }
+        .log-entry.error {
+            background-color: #fff5f5;
+            border-left-color: #dc3545;
+            color: #721c24;
+        }
+        .log-entry.warn {
+            background-color: #fffbf0;
+            border-left-color: #ffc107;
+            color: #856404;
+        }
+        .timestamp {
+            color: #6c757d;
+            font-weight: bold;
+        }
+        .level {
+            font-weight: bold;
+            margin: 0 8px;
+        }
+        .level.info { color: #28a745; }
+        .level.error { color: #dc3545; }
+        .level.warn { color: #ffc107; }
+        .message {
+            word-break: break-word;
+        }
+        .status {
+            padding: 10px 20px;
+            background: #e9ecef;
+            border-top: 1px solid #ddd;
+            font-size: 14px;
+            color: #6c757d;
+        }
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #6c757d;
+        }
+        .empty {
+            text-align: center;
+            padding: 40px;
+            color: #6c757d;
+            font-style: italic;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🚀 CloudStudio Runner</h1>
+            <p>实时日志查看器 - 监控自动化任务执行状态</p>
+        </div>
+
+        <div class="controls">
+            <label for="lines">显示行数:</label>
+            <select id="lines">
+                <option value="50">50 行</option>
+                <option value="100" selected>100 行</option>
+                <option value="200">200 行</option>
+                <option value="500">500 行</option>
+                <option value="1000">1000 行</option>
+            </select>
+
+            <button onclick="refreshLogs()">🔄 刷新日志</button>
+            <button onclick="toggleAutoRefresh()">⏱️ 自动刷新</button>
+            <button onclick="clearLogs()">🗑️ 清空显示</button>
+        </div>
+
+        <div class="log-container" id="logContainer">
+            <div class="loading">正在加载日志...</div>
+        </div>
+
+        <div class="status" id="status">
+            准备就绪
+        </div>
+    </div>
+
+    <script>
+        let autoRefreshInterval = null;
+        let isAutoRefresh = false;
+
+        async function fetchLogs() {
+            try {
+                const lines = document.getElementById('lines').value;
+                const response = await fetch(\`/api/logs?lines=\${lines}\`);
+                const data = await response.json();
+
+                if (data.success) {
+                    displayLogs(data.logs);
+                    updateStatus(\`已加载 \${data.logs.length} 条日志 - \${new Date().toLocaleString()}\`);
+                } else {
+                    updateStatus('获取日志失败: ' + data.error);
+                }
+            } catch (error) {
+                updateStatus('网络错误: ' + error.message);
+            }
+        }
+
+        function displayLogs(logs) {
+            const container = document.getElementById('logContainer');
+
+            if (logs.length === 0) {
+                container.innerHTML = '<div class="empty">暂无日志数据</div>';
+                return;
+            }
+
+            const logHTML = logs.map(log => {
+                const match = log.match(/\\[(.*?)\\]\\s*\\[(.*?)\\]\\s*(.*)/);
+                if (match) {
+                    const [, timestamp, level, message] = match;
+                    const levelClass = level.toLowerCase();
+                    return \`
+                        <div class="log-entry \${levelClass}">
+                            <span class="timestamp">\${timestamp}</span>
+                            <span class="level \${levelClass}">[\${level}]</span>
+                            <span class="message">\${message}</span>
+                        </div>
+                    \`;
+                } else {
+                    return \`
+                        <div class="log-entry">
+                            <span class="message">\${log}</span>
+                        </div>
+                    \`;
+                }
+            }).join('');
+
+            container.innerHTML = logHTML;
+            container.scrollTop = container.scrollHeight;
+        }
+
+        function updateStatus(message) {
+            document.getElementById('status').textContent = message;
+        }
+
+        function refreshLogs() {
+            fetchLogs();
+        }
+
+        function toggleAutoRefresh() {
+            const button = event.target;
+
+            if (isAutoRefresh) {
+                clearInterval(autoRefreshInterval);
+                autoRefreshInterval = null;
+                isAutoRefresh = false;
+                button.textContent = '⏱️ 自动刷新';
+                updateStatus('自动刷新已停止');
+            } else {
+                autoRefreshInterval = setInterval(fetchLogs, 5000);
+                isAutoRefresh = true;
+                button.textContent = '⏹️ 停止刷新';
+                updateStatus('自动刷新已启动 (每5秒)');
+            }
+        }
+
+        function clearLogs() {
+            document.getElementById('logContainer').innerHTML = '<div class="empty">日志显示已清空</div>';
+            updateStatus('显示已清空');
+        }
+
+        // 页面加载时获取日志
+        document.addEventListener('DOMContentLoaded', fetchLogs);
+    </script>
+</body>
+</html>
+`;
+
+// 路由定义
+app.get('/', (c) => {
+    return c.html(indexHTML);
+});
+
+// API 路由 - 获取日志
+app.get('/api/logs', (c) => {
+    try {
+        const lines = parseInt(c.req.query('lines') || '100');
+        const logs = getRecentLogs(lines);
+
+        return c.json({
+            success: true,
+            logs: logs,
+            count: logs.length,
+            timestamp: new Date().toISOString()
+        });
+    } catch (error) {
+        logError('获取日志API错误:', error);
+        return c.json({
+            success: false,
+            error: error.message
+        }, 500);
+    }
+});
+
+// API 路由 - 系统状态
+app.get('/api/status', (c) => {
+    return c.json({
+        success: true,
+        status: 'running',
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+        timestamp: new Date().toISOString(),
+        config: {
+            webideUrl: config.webideUrl,
+            schedulerInterval: config.schedulerInterval,
+            headless: config.browserOptions.headless
+        }
+    });
+});
+
+// 健康检查
+app.get('/health', (c) => {
+    return c.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+// 启动服务器
+const port = process.env.PORT || 7860;
+
+async function startServer() {
+    try {
+        log(`启动 Web 服务器，端口: ${port}`);
+        log(`访问地址: http://localhost:${port}`);
+
+        serve({
+            fetch: app.fetch,
+            port: port,
+        });
+
+        log('Web 服务器启动成功');
+    } catch (error) {
+        logError('启动 Web 服务器失败:', error);
+        process.exit(1);
+    }
+}
+
+// 如果直接运行此文件，启动服务器
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const scriptPath = path.resolve(process.argv[1]);
+
+if (path.resolve(__filename) === scriptPath) {
+    startServer();
+}
+
+export { app, startServer };