Update from GitHub Actions

.cnb.yml

@@ -0,0 +1,10 @@
+master:
+  push:
+    - docker:
+        image: node:18
+      imports: https://cnb.cool/godgodgame/oci-private-key/-/blob/main/envs.yml
+      stages:
+        - name: 环境检查
+          script: echo $GITHUB_TOKEN_GK && echo $GITHUB_TOKEN && node -v && npm -v
+        - name: 将master分支同步更新到github的master分支
+          script: git push https://$GITHUB_TOKEN_GK:$GITHUB_TOKEN@github.com/zhezzma/cloudstudio-runner.git HEAD:master

.env.example

@@ -0,0 +1,22 @@
+# 环境变量配置示例文件
+# 复制此文件为 .env 并根据需要修改配置
+
+# WebIDE URL - 如果设置了此环境变量，将覆盖 config.js 中的默认 webideUrl
+# WEBIDE_URL=https://your-custom-webide-url.com/edit
+
+# 调度器时间间隔（毫秒）- 如果设置了此环境变量，将覆盖 config.js 中的默认值
+# 默认为 600000 毫秒（10分钟）
+# SCHEDULER_INTERVAL=600000
+
+# 浏览器无头模式 - 如果设置了此环境变量，将覆盖 config.js 中的默认值
+# 默认为 true（无头模式），设置为 false 可以显示浏览器界面
+# HEADLESS=false
+
+# Cookies - 如果设置了此环境变量，将优先使用环境变量中的cookies而不是cookies.json文件
+# 格式为JSON字符串，包含从浏览器导出的cookies数组
+# COOKIES='[{"name":"session","value":"abc123","domain":".example.com","path":"/"}]'
+
+# 示例：
+# WEBIDE_URL=https://3e8ccf585a6c4fbd9f1aa9f05ac5e415.ap-shanghai.cloudstudio.club/?mode=edit
+# SCHEDULER_INTERVAL=300000  # 5分钟
+# SCHEDULER_INTERVAL=900000  # 15分钟

Dockerfile

@@ -0,0 +1,61 @@
+# 基础镜像：使用 Node.js 20 的 Alpine Linux 版本
+FROM node:20-alpine
+
+# 设置工作目录
+WORKDIR /app
+
+# 安装系统依赖
+RUN apk add --no-cache \
+    # 基本构建工具
+    python3 \
+    make \
+    g++ \
+    # Playwright 依赖
+    chromium \
+    nss \
+    freetype \
+    freetype-dev \
+    harfbuzz \
+    ca-certificates \
+    ttf-freefont \
+    # 其他依赖
+    gcompat
+
+# 设置 Playwright 的环境变量
+ENV PLAYWRIGHT_BROWSERS_PATH=/usr/bin
+ENV PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1
+ENV PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/usr/bin/chromium-browser
+ENV PLAYWRIGHT_SKIP_BROWSER_VALIDATION=1
+
+# 复制 package.json 和 package-lock.json
+COPY package*.json ./
+
+# 复制应用程序文件
+COPY src/ ./src/
+
+# 复制 cookies.json 文件（如果存在）
+# 使用通配符语法，如果文件不存在则跳过，不会报错
+COPY cookies.json* ./
+
+# 安装 Node.js 依赖
+RUN npm ci --only=production
+
+# 设置非 root 用户（安全最佳实践）
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+
+# 创建 screenshots 和 logs 目录，并设置正确的权限
+RUN mkdir -p /app/screenshots && \
+    mkdir -p /app/logs && \
+    chown -R nodejs:nodejs /app && \
+    chmod -R 777 /app/screenshots && \
+    chmod -R 777 /app/logs
+
+# 切换到非 root 用户
+USER nodejs
+
+# 暴露端口 7860 用于 Web 服务器
+EXPOSE 7860
+
+# 设置默认命令 - 启动 Web 服务器
+CMD ["npm", "start"]

package-lock.json

@@ -0,0 +1,96 @@
+{
+  "name": "cloudstudio-runner",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "cloudstudio-runner",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "@hono/node-server": "^1.14.2",
+        "dotenv": "^16.5.0",
+        "hono": "^4.7.10",
+        "playwright": "^1.52.0"
+      }
+    },
+    "node_modules/@hono/node-server": {
+      "version": "1.14.2",
+      "resolved": "https://registry.npmmirror.com/@hono/node-server/-/node-server-1.14.2.tgz",
+      "integrity": "sha512-GHjpOeHYbr9d1vkID2sNUYkl5IxumyhDrUJB7wBp7jvqYwPFt+oNKsAPBRcdSbV7kIrXhouLE199ks1QcK4r7A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.14.1"
+      },
+      "peerDependencies": {
+        "hono": "^4"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.5.0",
+      "resolved": "https://registry.npmmirror.com/dotenv/-/dotenv-16.5.0.tgz",
+      "integrity": "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/hono": {
+      "version": "4.7.10",
+      "resolved": "https://registry.npmmirror.com/hono/-/hono-4.7.10.tgz",
+      "integrity": "sha512-QkACju9MiN59CKSY5JsGZCYmPZkA6sIW6OFCUp7qDjZu6S6KHtJHhAc9Uy9mV9F8PJ1/HQ3ybZF2yjCa/73fvQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
+    "node_modules/playwright": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmmirror.com/playwright/-/playwright-1.52.0.tgz",
+      "integrity": "sha512-JAwMNMBlxJ2oD1kce4KPtMkDeKGHQstdpFPcPH3maElAXon/QZeTvtsfXmTMRyO9TslfoYOXkSsvao2nE1ilTw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.52.0"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmmirror.com/playwright-core/-/playwright-core-1.52.0.tgz",
+      "integrity": "sha512-l2osTgLXSMeuLZOML9qYODUQoPPnUsKsb5/P6LJ2e6uPKXUdPK5WYhN4z03G+YNbWmGDY4YENauNu4ZKczreHg==",
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,23 @@
+{
+  "name": "cloudstudio-runner",
+  "version": "1.0.0",
+  "description": "Playwright automation for CloudStudio WebIDE",
+  "main": "index.js",
+  "scripts": {
+    "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": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@hono/node-server": "^1.13.7",
+    "dotenv": "^16.5.0",
+    "hono": "^4.6.12",
+    "playwright": "^1.52.0"
+  }
+}

src/config.js

@@ -0,0 +1,62 @@
+// 配置文件
+import dotenv from 'dotenv';
+
+// 加载环境变量
+dotenv.config();
+
+const config = {
+  // WebIDE URL - 可以通过环境变量 WEBIDE_URL 覆盖
+  webideUrl: process.env.WEBIDE_URL || '',
+
+  // 调度器时间间隔（毫秒）- 可以通过环境变量 SCHEDULER_INTERVAL 覆盖
+  // 默认为 10 分钟 (10 * 60 * 1000 = 600000 毫秒)
+  schedulerInterval: parseInt(process.env.SCHEDULER_INTERVAL) || 9 * 60 * 1000,
+
+  // Cookie文件路径
+  cookieFile: './cookies.json',
+
+  // Cookie环境变量 - 如果设置了此环境变量，将优先使用环境变量中的cookies
+  cookiesFromEnv: process.env.COOKIES,
+
+  // 浏览器配置
+  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 && date',
+
+  // 截图保存目录
+  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,46 @@
+import config from './config.js';
+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() {
+
+  let browser;
+  try {
+    // 创建浏览器会话
+    const { browser: browserInstance, page } = await createBrowserSession(config.cookieFile, config.cookiesFromEnv);
+    browser = browserInstance;
+
+    // 导航到WebIDE页面
+    await navigateToWebIDE(page);
+
+    // 执行命令流程
+    const success = await executeCommandFlow(page, 'screenshot');
+
+    // 保持浏览器打开一段时间以便查看结果
+    if (!config.browserOptions.headless) {
+      info('浏览器将保持打开5秒以便查看结果...');
+      await page.waitForTimeout(5000);
+    }
+
+  } catch (err) {
+    error('执行命令过程中发生错误:', err);
+  } finally {
+    if (browser) {
+      await browser.close();
+      info('浏览器已关闭');
+    }
+  }
+}
+
+// 运行命令执行脚本
+const __filename = fileURLToPath(import.meta.url);
+const scriptPath = path.resolve(process.argv[1]);
+
+if (path.resolve(__filename) === scriptPath) {
+  executeCommand().catch(error);
+}
+
+export { executeCommand };

src/login.js

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

src/scheduler.js

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

src/start-services.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+/**
+ * 服务启动脚本
+ * 同时启动 Web 服务器和调度器
+ */
+
+import { spawn } from 'child_process';
+import { info as log, error as logError } from './utils/logger.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,118 @@
+import fs from 'fs';
+import path from 'path';
+import { info, error } from './logger.js';
+
+/**
+ * 创建人类可读的时间戳
+ * @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 });
+    info(`创建截图目录: ${dir}`);
+  }
+}
+
+/**
+ * 检查 Cookie 是否可用（环境变量或文件）
+ * @param {string} cookieFile - Cookie 文件路径
+ * @param {string} cookiesFromEnv - 环境变量中的cookies
+ * @returns {boolean} Cookie是否可用
+ */
+export function checkCookieAvailability(cookieFile, cookiesFromEnv) {
+  // 优先检查环境变量
+  if (cookiesFromEnv) {
+    info('发现环境变量COOKIES，将使用环境变量中的cookies');
+    try {
+      JSON.parse(cookiesFromEnv);
+      return true;
+    } catch (err) {
+      error('环境变量COOKIES格式无效:', err.message);
+      info('将尝试使用cookie文件...');
+    }
+  }
+
+  // 检查cookie文件
+  if (!fs.existsSync(cookieFile)) {
+    error(`Cookie文件不存在: ${cookieFile}`);
+    info('请先运行 npm run login 进行登录，或设置环境变量COOKIES');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * 检查 Cookie 文件是否存在（保持向后兼容）
+ * @param {string} cookieFile - Cookie 文件路径
+ * @returns {boolean} 文件是否存在
+ */
+export function checkCookieFile(cookieFile) {
+  if (!fs.existsSync(cookieFile)) {
+    error(`Cookie文件不存在: ${cookieFile}`);
+    info('请先运行 npm run login 进行登录');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * 读取并解析 Cookie（优先使用环境变量）
+ * @param {string} cookieFile - Cookie 文件路径
+ * @param {string} cookiesFromEnv - 环境变量中的cookies
+ * @returns {Array} Cookie 数组
+ */
+export function loadCookies(cookieFile, cookiesFromEnv) {
+  try {
+    // 优先使用环境变量
+    if (cookiesFromEnv) {
+      info('从环境变量COOKIES加载cookies...');
+      const cookies = JSON.parse(cookiesFromEnv);
+      info(`已从环境变量加载 ${cookies.length} 个cookies`);
+      return cookies;
+    }
+
+    // 使用文件
+    if (fs.existsSync(cookieFile)) {
+      info(`从文件加载cookies: ${cookieFile}`);
+      const cookies = JSON.parse(fs.readFileSync(cookieFile, 'utf8'));
+      info(`已从文件加载 ${cookies.length} 个cookies`);
+      return cookies;
+    }
+    return [];
+  } catch (err) {
+    error('读取 Cookie 失败:', err);
+    throw err;
+  }
+}
+
+/**
+ * 保存截图
+ * @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}.png`);
+  await page.screenshot({ path: 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

@@ -0,0 +1,193 @@
+import { chromium } from 'playwright';
+import config from '../config.js';
+import { loadCookies, saveScreenshot, getHumanReadableTimestamp } from './common-utils.js';
+import { info, error } from './logger.js';
+
+/**
+ * 创建浏览器实例和上下文
+ * @param {string} cookieFile - Cookie 文件路径
+ * @param {string} cookiesFromEnv - 环境变量中的cookies
+ * @returns {Object} { browser, context, page }
+ */
+export async function createBrowserSession(cookieFile, cookiesFromEnv) {
+  info('启动浏览器...');
+  const browser = await chromium.launch(config.browserOptions);
+  const context = await browser.newContext();
+
+  // 读取并设置cookies（优先使用环境变量）
+  const cookies = loadCookies(cookieFile, cookiesFromEnv);
+  await context.addCookies(cookies);
+
+  const page = await context.newPage();
+
+  return { browser, context, page };
+}
+
+/**
+ * 导航到 WebIDE 页面并验证登录状态
+ * @param {Object} page - Playwright 页面对象
+ */
+export async function navigateToWebIDE(page) {
+  info('导航到WebIDE页面...');
+  await page.goto(config.webideUrl);
+
+  // 等待页面加载
+  await page.waitForTimeout(config.waitTimes.pageLoad);
+
+  info('当前页面URL:', page.url());
+  info('页面标题:', await page.title());
+
+  // 检查并处理"立即重试"按钮  这个是企业版的才会有的
+  await handleRetryButton(page);
+
+
+  // 检查是否成功登录
+  try {
+    await page.waitForSelector(config.selectors.editor, {
+      timeout: 60000
+    });
+    info('成功进入WebIDE界面');
+    return true;
+  } catch (err) {
+    info('警告: 未检测到编辑器界面，可能需要重新登录');
+    return false;
+  }
+}
+
+/**
+ * 检查并点击"立即重试"按钮
+ * @param {Object} page - Playwright 页面对象
+ * @returns {boolean} 是否找到并点击了重试按钮
+ */
+export async function handleRetryButton(page) {
+  try {
+    const retryButton = await page.waitForSelector('button.btn__21_ID', { timeout: 5000 });
+    if (retryButton && await retryButton.isVisible()) {
+      info('发现"立即重试"按钮，点击处理...');
+      await retryButton.click();
+      return true;
+    }
+  } catch (err) {
+    // 没有找到重试按钮，继续执行
+    info('未发现"立即重试"按钮，继续执行...');
+  }
+  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()) {
+      info('发现模态对话框按钮，点击处理...');
+      await dialogButton.click();
+      await page.waitForTimeout(500);
+      return true;
+    }
+  } catch (err) {
+    // 没有找到对话框按钮，继续执行
+    info('未发现模态对话框，继续执行...');
+  }
+  return false;
+}
+
+/**
+ * 打开终端
+ * @param {Object} page - Playwright 页面对象
+ * @returns {Object|null} 终端元素或 null
+ */
+export async function openTerminal(page) {
+  info('尝试打开终端 (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) {
+        info(`找到终端元素: ${selector}`);
+        terminalFound = true;
+        break;
+      }
+    } catch (err) {
+      // 继续尝试下一个选择器
+    }
+  }
+
+  if (!terminalFound) {
+    info('未找到终端元素，尝试直接输入命令...');
+    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) {
+  info(`执行命令: ${command}`);
+
+  // 输入命令
+  await page.keyboard.type(command);
+  await page.waitForTimeout(500);
+
+  // 按回车执行命令
+  await page.keyboard.press('Enter');
+
+  // 等待命令执行
+  await page.waitForTimeout(config.waitTimes.commandExecution);
+
+  info('命令已执行');
+}
+
+/**
+ * 完整的命令执行流程
+ * @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 (err) {
+    error(`[${getHumanReadableTimestamp()}] 执行命令时发生错误:`, err);
+    return false;
+  }
+}

src/web-server.js

@@ -0,0 +1,408 @@
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+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>
+<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;
+        }
+        .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>
+    <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 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>
+        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秒)');
+            }
+        }
+
+        async function clearLogs() {
+            try {
+                updateStatus('正在清空日志...');
+
+                const response = await fetch('/api/clear-logs', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+
+                const data = await response.json();
+
+                if (data.success) {
+                    document.getElementById('logContainer').innerHTML = '<div class="empty">日志已清空</div>';
+                    updateStatus('日志文件已清空 - ' + new Date().toLocaleString());
+                } else {
+                    updateStatus('清空日志失败: ' + data.error);
+                }
+            } catch (error) {
+                updateStatus('清空日志时发生网络错误: ' + error.message);
+            }
+        }
+
+        // 页面加载时获取日志
+        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.post('/api/clear-logs', (c) => {
+    try {
+        const success = clearLogFile();
+
+        if (success) {
+            log('日志文件已通过Web界面清空');
+            return c.json({
+                success: true,
+                message: '日志文件已清空',
+                timestamp: new Date().toISOString()
+            });
+        } else {
+            return c.json({
+                success: false,
+                error: '清空日志文件失败'
+            }, 500);
+        }
+    } 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 };