1.账号保活

  • 由于ser00的账号3个月不ssh连接或者不登录网页面板的话账号就会被回收,故需要隔一段时间登录一下避免账号回收。这里使用的是cf wocker实现定时登录并接入telegrame-bot提示登录信息。
  • worker代码:

    addEventListener('fetch', event => {
    event.respondWith(handleRequest(event.request))
    })
    
    addEventListener('scheduled', event => {
    event.waitUntil(handleScheduled(event.scheduledTime))
    })
    
    async function handleRequest(request) {
    return new Response('Worker is running')
    }
    
    async function handleScheduled(scheduledTime) {
    const accounts = JSON.parse(ACCOUNTS_JSON)
    const results = await loginAccounts(accounts)
    await sendSummary(results)
    }
    
    async function loginAccounts(accounts) {
    const results = []
    for (const account of accounts) {
      const result = await loginAccount(account)
      results.push({ ...account, ...result })
      await delay(Math.floor(Math.random() * 8000) + 1000)
    }
    return results
    }
    
    function generateRandomUserAgent() {
    const browsers = ['Chrome', 'Firefox', 'Safari', 'Edge', 'Opera'];
    const browser = browsers[Math.floor(Math.random() * browsers.length)];
    const version = Math.floor(Math.random() * 100) + 1;
    const os = ['Windows NT 10.0', 'Macintosh', 'X11'];
    const selectedOS = os[Math.floor(Math.random() * os.length)];
    const osVersion = selectedOS === 'X11' ? 'Linux x86_64' : selectedOS === 'Macintosh' ? 'Intel Mac OS X 10_15_7' : 'Win64; x64';
    
    return `Mozilla/5.0 (${selectedOS}; ${osVersion}) AppleWebKit/537.36 (KHTML, like Gecko) ${browser}/${version}.0.0.0 Safari/537.36`;
    }
    
    async function loginAccount(account) {
    const { username, password, panelnum, type } = account
    let url = type === 'ct8' 
      ? 'https://panel.ct8.pl/login/?next=/' 
      : `https://panel${panelnum}.serv00.com/login/?next=/`
    
    const userAgent = generateRandomUserAgent();
    
    try {
      const response = await fetch(url, {
        method: 'GET',
        headers: {
          'User-Agent': userAgent,
        },
      })
    
      const pageContent = await response.text()
      const csrfMatch = pageContent.match(/name="csrfmiddlewaretoken" value="([^"]*)"/)
      const csrfToken = csrfMatch ? csrfMatch[1] : null
    
      if (!csrfToken) {
        throw new Error('CSRF token not found')
      }
    
      const initialCookies = response.headers.get('set-cookie') || ''
    
      const formData = new URLSearchParams({
        'username': username,
        'password': password,
        'csrfmiddlewaretoken': csrfToken,
        'next': '/'
      })
    
      const loginResponse = await fetch(url, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Referer': url,
          'User-Agent': userAgent,
          'Cookie': initialCookies,
        },
        body: formData.toString(),
        redirect: 'manual'
      })
    
      console.log(`Login response status: ${loginResponse.status}`)
      console.log(`Login response headers: ${JSON.stringify(Object.fromEntries(loginResponse.headers))}`)
    
      const loginResponseBody = await loginResponse.text()
      console.log(`Login response body: ${loginResponseBody.substring(0, 200)}...`)
    
      if (loginResponse.status === 302 && loginResponse.headers.get('location') === '/') {
        const loginCookies = loginResponse.headers.get('set-cookie') || ''
        const allCookies = combineCookies(initialCookies, loginCookies)
    
        const dashboardResponse = await fetch(url.replace('/login/', '/'), {
          headers: {
            'Cookie': allCookies,
            'User-Agent': userAgent,
          }
        })
        const dashboardContent = await dashboardResponse.text()
        console.log(`Dashboard content: ${dashboardContent.substring(0, 200)}...`)
    
        if (dashboardContent.includes('href="/logout/"') || dashboardContent.includes('href="/wyloguj/"')) {
          const nowUtc = formatToISO(new Date())
          const nowBeijing = formatToISO(new Date(Date.now() + 8 * 60 * 60 * 1000))
          const message = `账号 ${username} (${type}) 于北京时间 ${nowBeijing}(UTC时间 ${nowUtc})登录成功!`
          console.log(message)
          await sendTelegramMessage(message)
          return { success: true, message }
        } else {
          const message = `账号 ${username} (${type}) 登录后未找到登出链接,可能登录失败。`
          console.error(message)
          await sendTelegramMessage(message)
          return { success: false, message }
        }
      } else if (loginResponseBody.includes('Nieprawidłowy login lub hasło')) {
        const message = `账号 ${username} (${type}) 登录失败:用户名或密码错误。`
        console.error(message)
        await sendTelegramMessage(message)
        return { success: false, message }
      } else {
        const message = `账号 ${username} (${type}) 登录失败,未知原因。请检查账号和密码是否正确。`
        console.error(message)
        await sendTelegramMessage(message)
        return { success: false, message }
      }
    } catch (error) {
      const message = `账号 ${username} (${type}) 登录时出现错误: ${error.message}`
      console.error(message)
      await sendTelegramMessage(message)
      return { success: false, message }
    }
    }
    
    function combineCookies(cookies1, cookies2) {
    const cookieMap = new Map()
    
    const parseCookies = (cookieString) => {
      cookieString.split(',').forEach(cookie => {
        const [fullCookie] = cookie.trim().split(';')
        const [name, value] = fullCookie.split('=')
        if (name && value) {
          cookieMap.set(name.trim(), value.trim())
        }
      })
    }
    
    parseCookies(cookies1)
    parseCookies(cookies2)
    
    return Array.from(cookieMap.entries()).map(([name, value]) => `${name}=${value}`).join('; ')
    }
    
    async function sendSummary(results) {
    const successfulLogins = results.filter(r => r.success)
    const failedLogins = results.filter(r => !r.success)
    
    let summaryMessage = '登录结果统计:\n'
    summaryMessage += `成功登录的账号:${successfulLogins.length}\n`
    summaryMessage += `登录失败的账号:${failedLogins.length}\n`
    
    if (failedLogins.length > 0) {
      summaryMessage += '\n登录失败的账号列表:\n'
      failedLogins.forEach(({ username, type, message }) => {
        summaryMessage += `- ${username} (${type}): ${message}\n`
      })
    }
    
    console.log(summaryMessage)
    await sendTelegramMessage(summaryMessage)
    }
    
    async function sendTelegramMessage(message) {
    const telegramConfig = JSON.parse(TELEGRAM_JSON)
    const { telegramBotToken, telegramBotUserId } = telegramConfig
    const url = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`
    
    try {
      await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          chat_id: telegramBotUserId,
          text: message
        })
      })
    } catch (error) {
      console.error('Error sending Telegram message:', error)
    }
    }
    
    function formatToISO(date) {
    return date.toISOString().replace('T', ' ').replace('Z', '').replace(/\.\d{3}Z/, '')
    }
    
    function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms))
    }
  • 变量:
  • ACCOUNTS_JSON

    [  
    { "username": "serv00user1", "password": "serv00password1", "panelnum": "0", "type": "serv00" },
    { "username": "serv00user2", "password": "serv00password2", "panelnum": "4", "type": "serv00" },
    { "username": "serv00user3", "password": "serv00password3", "panelnum": "7", "type": "serv00" },
    { "username": "ct8user1", "password": "ct8password1", "type": "ct8" },
    { "username": "ct8user2", "password": "ct8password2", "type": "ct8" }
    ]
  • TELEGRAM_JSON

    {
    "telegramBotToken": "YOUR_BOT_TOKEN",
    "telegramBotUserId": "YOUR_USER_ID"
    }

  • cron任务设置
  • 然后就可以触发一下看能不能登录成功

    telegrame成功推送信息就ok了

    2.进程保活

  • 因为serv00会不定时清空进程和我们设置的cron任务,每次添加cron任务会很麻烦,便通过脚本一键添加cron任务。
  • wocker:

    addEventListener('fetch', event => {
    event.respondWith(handleRequest(event.request))
    })
    
    addEventListener('scheduled', event => {
    event.waitUntil(handleScheduled(event.scheduledTime))
    })
    
    async function handleRequest(request) {
    const url = new URL(request.url)
    
    if (url.pathname === '/login' && request.method === 'POST') {
      const formData = await request.formData()
      const password = formData.get('password')
      
      if (password === PASSWORD) {
        const response = new Response(JSON.stringify({ success: true }), {
          headers: { 'Content-Type': 'application/json' }
        })
        response.headers.set('Set-Cookie', `auth=${PASSWORD}; HttpOnly; Secure; SameSite=Strict; Path=/; Max-Age=86400`)
        return response
      } else {
        return new Response(JSON.stringify({ success: false }), {
          headers: { 'Content-Type': 'application/json' }
        })
      }
    } else if (url.pathname === '/run' && request.method === 'POST') {
      if (!isAuthenticated(request)) {
        return new Response('Unauthorized', { status: 401 })
      }
      
      await handleScheduled(new Date().toISOString())
      const results = await CRON_RESULTS.get('lastResults', 'json')
      return new Response(JSON.stringify(results), {
        headers: { 'Content-Type': 'application/json' }
      })
    } else if (url.pathname === '/results' && request.method === 'GET') {
      if (!isAuthenticated(request)) {
        return new Response(JSON.stringify({ authenticated: false }), {
          headers: { 'Content-Type': 'application/json' }
        })
      }
      const results = await CRON_RESULTS.get('lastResults', 'json')
      return new Response(JSON.stringify({ authenticated: true, results: results || [] }), {
        headers: { 'Content-Type': 'application/json' }
      })
    } else if (url.pathname === '/check-auth' && request.method === 'GET') {
      return new Response(JSON.stringify({ authenticated: isAuthenticated(request) }), {
        headers: { 'Content-Type': 'application/json' }
      })
    } else {
      // 显示登录页面或结果页面的 HTML
      return new Response(getHtmlContent(), {
        headers: { 'Content-Type': 'text/html' },
      })
    }
    }
    
    function isAuthenticated(request) {
    const cookies = request.headers.get('Cookie')
    if (cookies) {
      const authCookie = cookies.split(';').find(c => c.trim().startsWith('auth='))
      if (authCookie) {
        const authValue = authCookie.split('=')[1]
        return authValue === PASSWORD
      }
    }
    return false
    }
    
    function getHtmlContent() {
    return `
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>Worker Control Panel</title>
      <style>
        body {
          font-family: Arial, sans-serif;
          display: flex;
          justify-content: center;
          align-items: center;
          min-height: 100vh;
          margin: 0;
          background-color: #f0f0f0;
        }
        .container {
          text-align: center;
          padding: 20px;
          background-color: white;
          border-radius: 8px;
          box-shadow: 0 2px 4px rgba(0,0,0,0.1);
          max-width: 800px;
          width: 100%;
        }
        input, button {
          margin: 10px 0;
          padding: 10px;
          width: 200px;
          border-radius: 4px;
          border: 1px solid #ddd;
        }
        button {
          background-color: #4CAF50;
          border: none;
          color: white;
          cursor: pointer;
        }
        #status {
          margin-top: 20px;
          font-weight: bold;
        }
        table {
          width: 100%;
          border-collapse: collapse;
          margin-top: 20px;
        }
        th, td {
          border: 1px solid #ddd;
          padding: 8px;
          text-align: left;
        }
        th {
          background-color: #f2f2f2;
        }
        #loginForm, #dashboard {
          display: none;
        }
      </style>
    </head>
    <body>
      <div class="container">
        <h1>Worker Control Panel</h1>
        <div id="loginForm">
          <input type="password" id="password" placeholder="Enter password">
          <button onclick="login()">Login</button>
        </div>
        <div id="dashboard">
          <button onclick="runScript()">Run Script</button>
          <div id="status"></div>
          <table id="resultsTable">
            <thead>
              <tr>
                <th>Account</th>
                <th>Type</th>
                <th>Status</th>
                <th>Message</th>
                <th>Last Run</th>
              </tr>
            </thead>
            <tbody></tbody>
          </table>
        </div>
      </div>
      <script>
        let password = '';
    
        function showLoginForm() {
          document.getElementById('loginForm').style.display = 'block';
          document.getElementById('dashboard').style.display = 'none';
        }
    
        function showDashboard() {
          document.getElementById('loginForm').style.display = 'none';
          document.getElementById('dashboard').style.display = 'block';
          fetchResults();
        }
    
        async function checkAuth() {
          const response = await fetch('/check-auth');
          const data = await response.json();
          if (data.authenticated) {
            showDashboard();
          } else {
            showLoginForm();
          }
        }
    
        async function login() {
          password = document.getElementById('password').value;
          const formData = new FormData();
          formData.append('password', password);
          const response = await fetch('/login', { 
            method: 'POST',
            body: formData
          });
          const result = await response.json();
          if (result.success) {
            showDashboard();
          } else {
            alert('Incorrect password');
          }
        }
    
        async function runScript() {
          const statusDiv = document.getElementById('status');
          statusDiv.textContent = 'Executing script...';
          try {
            const response = await fetch('/run', { method: 'POST' });
            if (response.ok) {
              const results = await response.json();
              displayResults(results);
              statusDiv.textContent = 'Script executed successfully!';
            } else if (response.status === 401) {
              statusDiv.textContent = 'Unauthorized. Please login again.';
              showLoginForm();
            } else {
              statusDiv.textContent = 'Error executing script.';
            }
          } catch (error) {
            statusDiv.textContent = 'Error: ' + error.message;
          }
        }
    
        async function fetchResults() {
          try {
            const response = await fetch('/results');
            if (response.ok) {
              const data = await response.json();
              if (data.authenticated) {
                displayResults(data.results);
              } else {
                showLoginForm();
              }
            } else {
              console.error('Failed to fetch results');
              showLoginForm();
            }
          } catch (error) {
            console.error('Error fetching results:', error);
            showLoginForm();
          }
        }
    
        function displayResults(results) {
          const tbody = document.querySelector('#resultsTable tbody');
          tbody.innerHTML = '';
          results.forEach(result => {
            result.cronResults.forEach((cronResult, index) => {
              const row = tbody.insertRow();
              if (index === 0) {
                row.insertCell(0).textContent = result.username;
                row.insertCell(1).textContent = result.type;
              } else {
                row.insertCell(0).textContent = '';
                row.insertCell(1).textContent = '';
              }
              row.insertCell(2).textContent = cronResult.success ? 'Success' : 'Failed';
              row.insertCell(3).textContent = cronResult.message;
              row.insertCell(4).textContent = new Date(result.lastRun).toLocaleString();
            });
          });
        }
    
        // 页面加载时检查认证状态
        document.addEventListener('DOMContentLoaded', checkAuth);
      </script>
    </body>
    </html>
    `;
    }
    
    async function handleScheduled(scheduledTime) {
    const accountsData = JSON.parse(ACCOUNTS_JSON);
    const accounts = accountsData.accounts;
    
    let results = [];
    for (const account of accounts) {
      const result = await loginAccount(account);
      results.push(result);
      await delay(Math.floor(Math.random() * 8000) + 1000);
    }
    
    // 保存结果到 KV 存储
    await CRON_RESULTS.put('lastResults', JSON.stringify(results));
    }
    
    function generateRandomUserAgent() {
    const browsers = ['Chrome', 'Firefox', 'Safari', 'Edge', 'Opera'];
    const browser = browsers[Math.floor(Math.random() * browsers.length)];
    const version = Math.floor(Math.random() * 100) + 1;
    const os = ['Windows NT 10.0', 'Macintosh', 'X11'];
    const selectedOS = os[Math.floor(Math.random() * os.length)];
    const osVersion = selectedOS === 'X11' ? 'Linux x86_64' : selectedOS === 'Macintosh' ? 'Intel Mac OS X 10_15_7' : 'Win64; x64';
    
    return `Mozilla/5.0 (${selectedOS}; ${osVersion}) AppleWebKit/537.36 (KHTML, like Gecko) ${browser}/${version}.0.0.0 Safari/537.36`;
    }
    
    async function loginAccount(account) {
    const { username, password, panelnum, type, cronCommands } = account
    let baseUrl = type === 'ct8' 
      ? 'https://panel.ct8.pl' 
      : `https://panel${panelnum}.serv00.com`
    let loginUrl = `${baseUrl}/login/?next=/cron/`
    
    const userAgent = generateRandomUserAgent();
    
    try {
      const response = await fetch(loginUrl, {
        method: 'GET',
        headers: {
          'User-Agent': userAgent,
        },
      })
    
      const pageContent = await response.text()
      const csrfMatch = pageContent.match(/name="csrfmiddlewaretoken" value="([^"]*)"/)
      const csrfToken = csrfMatch ? csrfMatch[1] : null
    
      if (!csrfToken) {
        throw new Error('CSRF token not found')
      }
    
      const initialCookies = response.headers.get('set-cookie') || ''
    
      const formData = new URLSearchParams({
        'username': username,
        'password': password,
        'csrfmiddlewaretoken': csrfToken,
        'next': '/cron/'
      })
    
      const loginResponse = await fetch(loginUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Referer': loginUrl,
          'User-Agent': userAgent,
          'Cookie': initialCookies,
        },
        body: formData.toString(),
        redirect: 'manual'
      })
    
      if (loginResponse.status === 302 && loginResponse.headers.get('location') === '/cron/') {
        const loginCookies = loginResponse.headers.get('set-cookie') || ''
        const allCookies = combineCookies(initialCookies, loginCookies)
    
        // 访问 cron 列表页面
        const cronListUrl = `${baseUrl}/cron/`
        const cronListResponse = await fetch(cronListUrl, {
          headers: {
            'Cookie': allCookies,
            'User-Agent': userAgent,
          }
        })
        const cronListContent = await cronListResponse.text()
    
        console.log(`Cron list URL: ${cronListUrl}`)
        console.log(`Cron list response status: ${cronListResponse.status}`)
        console.log(`Cron list content (first 1000 chars): ${cronListContent.substring(0, 1000)}`)
    
        let cronResults = [];
        for (const cronCommand of cronCommands) {
          if (!cronListContent.includes(cronCommand)) {
            // 访问添加 cron 任务页面
            const addCronUrl = `${baseUrl}/cron/add`
            const addCronPageResponse = await fetch(addCronUrl, {
              headers: {
                'Cookie': allCookies,
                'User-Agent': userAgent,
                'Referer': cronListUrl,
              }
            })
            const addCronPageContent = await addCronPageResponse.text()
    
            console.log(`Add cron page URL: ${addCronUrl}`)
            console.log(`Add cron page response status: ${addCronPageResponse.status}`)
            console.log(`Add cron page content (first 1000 chars): ${addCronPageContent.substring(0, 1000)}`)
    
            const newCsrfMatch = addCronPageContent.match(/name="csrfmiddlewaretoken" value="([^"]*)"/)
            const newCsrfToken = newCsrfMatch ? newCsrfMatch[1] : null
    
            if (!newCsrfToken) {
              throw new Error('New CSRF token not found for adding cron task')
            }
    
            const formData = new URLSearchParams({
              'csrfmiddlewaretoken': newCsrfToken,
              'spec': 'manual',
              'minute_time_interval': 'on',
              'minute': '15',
              'hour_time_interval': 'each',
              'hour': '*',
              'day_time_interval': 'each',
              'day': '*',
              'month_time_interval': 'each',
              'month': '*',
              'dow_time_interval': 'each',
              'dow': '*',
              'command': cronCommand,
              'comment': 'Auto added cron job'
            })
    
            console.log('Form data being sent:', formData.toString())
    
            const { success, response: addCronResponse, content: addCronResponseContent } = await addCronWithRetry(addCronUrl, {
              method: 'POST',
              headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Cookie': allCookies,
                'User-Agent': userAgent,
                'Referer': addCronUrl,
                'Origin': baseUrl,
                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
                'Accept-Language': 'en-US,en;q=0.5',
                'Upgrade-Insecure-Requests': '1'
              },
              body: formData.toString(),
            })
    
            console.log('Full response content:', addCronResponseContent)
    
            if (success) {
              if (addCronResponseContent.includes('Cron job has been added') || addCronResponseContent.includes('Zadanie cron zostało dodane')) {
                const message = `添加了新的 cron 任务:${cronCommand}`;
                console.log(message);
                await sendTelegramMessage(`账号 ${username} (${type}) ${message}`);
                cronResults.push({ success: true, message });
              } else {
                // 如果响应中没有成功信息,再次检查cron列表
                const checkCronListResponse = await fetch(cronListUrl, {
                  headers: {
                    'Cookie': allCookies,
                    'User-Agent': userAgent,
                  }
                });
                const checkCronListContent = await checkCronListResponse.text();
                
                if (checkCronListContent.includes(cronCommand)) {
                  const message = `确认添加了新的 cron 任务:${cronCommand}`;
                  console.log(message);
                  await sendTelegramMessage(`账号 ${username} (${type}) ${message}`);
                  cronResults.push({ success: true, message });
                } else {
                  const message = `尝试添加 cron 任务:${cronCommand},但在列表中未找到。可能添加失败。`;
                  console.error(message);
                  cronResults.push({ success: false, message });
                }
              }
            } else {
              const message = `添加 cron 任务失败:${cronCommand}`;
              console.error(message);
              cronResults.push({ success: false, message });
            }
          } else {
            const message = `cron 任务已存在:${cronCommand}`;
            console.log(message);
            cronResults.push({ success: true, message });
          }
        }
        return { username, type, cronResults, lastRun: new Date().toISOString() };
      } else {
        const message = `登录失败,未知原因。请检查账号和密码是否正确。`;
        console.error(message);
        return { username, type, cronResults: [{ success: false, message }], lastRun: new Date().toISOString() };
      }
    } catch (error) {
      const message = `登录或添加 cron 任务时出现错误: ${error.message}`;
      console.error(message);
      return { username, type, cronResults: [{ success: false, message }], lastRun: new Date().toISOString() };
    }
    }
    
    async function addCronWithRetry(url, options, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      try {
        const response = await fetch(url, options);
        const responseContent = await response.text();
        console.log(`Attempt ${i + 1} response status:`, response.status);
        console.log(`Attempt ${i + 1} response content (first 1000 chars):`, responseContent.substring(0, 1000));
        
        if (response.status === 200 || response.status === 302 || responseContent.includes('Cron job has been added') || responseContent.includes('Zadanie cron zostało dodane')) {
          return { success: true, response, content: responseContent };
        }
      } catch (error) {
        console.error(`Attempt ${i + 1} failed:`, error);
      }
      await delay(2000); // Wait 2 seconds before retrying
    }
    return { success: false };
    }
    
    function combineCookies(cookies1, cookies2) {
    const cookieMap = new Map()
    
    const parseCookies = (cookieString) => {
      cookieString.split(',').forEach(cookie => {
        const [fullCookie] = cookie.trim().split(';')
        const [name, value] = fullCookie.split('=')
        if (name && value) {
          cookieMap.set(name.trim(), value.trim())
        }
      })
    }
    
    parseCookies(cookies1)
    parseCookies(cookies2)
    
    return Array.from(cookieMap.entries()).map(([name, value]) => `${name}=${value}`).join('; ')
    }
    
    async function sendTelegramMessage(message) {
    const telegramConfig = JSON.parse(TELEGRAM_JSON)
    const { telegramBotToken, telegramBotUserId } = telegramConfig
    const url = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`
    
    try {
      await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          chat_id: telegramBotUserId,
          text: message
        })
      })
    } catch (error) {
      console.error('Error sending Telegram message:', error)
    }
    }
    
    function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms))
    }
  • ACCOUNTS_JSON

    {
    "accounts": [
      {
        "username": "user1",
        "password": "password1",
        "type": "ct8",
        "cronCommands": [
          "/usr/home/serv00name/domains",
          "你的脚本"
        ]
      },
      {
        "username": "user2",
        "password": "password2",
        "panelnum": "2",
        "type": "serv00",
        "cronCommands": [
          "/usr/home/serv00name"
        ]
      },
      {
        "username": "user3",
        "password": "password3",
        "type": "ct8",
        "cronCommands": [
          "/usr/home/serv00name",
          "你的脚本",
          "python /usr/home/serv00name/domains/backup.py"
        ]
      }
    ]
    }
  • TELEGRAM_JSON

    {
    "telegramBotToken": "YOUR_BOT_TOKEN",
    "telegramBotUserId": "YOUR_USER_ID"
    }
  • PASSWORD

    你访问worker面板的密码
  • 添加Cron
  • 创建一个名为CRON_RESULTS的KV变量
  • 回到刚才创建的worker界面绑定KV
  • 访问你的worker网站并输入密码,点击运行脚本即可。

    参考:
    https://linux.do/t/topic/181957
最后修改:2025 年 01 月 20 日
如果觉得我的文章对你有用,请点一个赞。