Update from GitHub Actions

functions/api/mail/activate.ts

@@ -0,0 +1,86 @@
+
+import { authApiToken, authMiddleware } from "../../utils/auth.js";
+import { addCorsHeaders } from "../../utils/cors.js";
+import { get_access_token, activateMailbox, syncMailbox } from '../../utils/mail';
+
+export const onRequest = async (context: RouteContext): Promise<Response> => {
+    const request = context.request;
+    const env: Env = context.env;
+
+    const authResponse = await authMiddleware(request, env);
+    const apiResponse = await authApiToken(request, env);
+    if (authResponse && apiResponse) {
+        return addCorsHeaders(authResponse);
+    }
+
+    if (request.method === 'OPTIONS') {
+        return new Response(null, {
+            status: 200,
+            headers: {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+            }
+        });
+    }
+
+    if (request.method !== 'POST') {
+        return new Response('Method not allowed', { status: 405 });
+    }
+
+    try {
+        const { email } = await request.json() as any;
+        if (!email) {
+            throw new Error("Email is required");
+        }
+
+        // 从KV获取刷新令牌
+        const tokenInfoStr = await env.KV.get(`refresh_token_${email}`);
+        if (!tokenInfoStr) {
+            throw new Error("No refresh token found for this email");
+        }
+
+        const tokenInfo = JSON.parse(tokenInfoStr);
+        const access_token = await get_access_token(tokenInfo, env.ENTRA_CLIENT_ID, env.ENTRA_CLIENT_SECRET);
+
+        // 执行邮箱激活操作
+        console.log(`开始激活邮箱: ${email}`);
+        await activateMailbox(access_token);
+        await syncMailbox(access_token);
+
+        // 等待同步完成
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        return new Response(
+            JSON.stringify({ 
+                success: true, 
+                message: "邮箱激活完成",
+                email: email,
+                timestamp: new Date().toISOString()
+            }),
+            {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*'
+                }
+            }
+        );
+    } catch (error: any) {
+        console.error('邮箱激活失败:', error);
+        return new Response(
+            JSON.stringify({ 
+                success: false,
+                error: error.message,
+                message: "邮箱激活失败"
+            }),
+            {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*'
+                }
+            }
+        );
+    }
+};

functions/api/mail/login.ts

@@ -19,7 +19,7 @@ export const onRequest = async (context: RouteContext): Promise<Response> => {
         }
 
         const authService = new AuthService(env);
-        const result = await authService.authenticateEmail(email);
+        const result = await authService.loginMail(email);
 
         if (!result.success) {
             throw new Error(result.error);

functions/api/mail/new.ts

@@ -41,7 +41,7 @@ export const onRequest = async (context: RouteContext): Promise<Response> => {
         }
         const tokenInfo = JSON.parse(tokenInfoStr);
         const access_token = await get_access_token(tokenInfo, env.ENTRA_CLIENT_ID, env.ENTRA_CLIENT_SECRET);
-        const emails = await getEmails(access_token, 1); // 只获取最新的一封邮件
+        const emails = await getEmails(access_token, 1, true); // 只获取最新的一封邮件，强制激活邮箱
         return new Response(
             JSON.stringify(emails[0] || null),
             {

functions/utils/authService.ts

@@ -66,6 +66,31 @@ export class AuthService {
             `&state=${email}`;
     }
 
+    public async loginMail(email: string): Promise<{ success: boolean; error?: string }> {
+        try {
+            const accountsStr = await this.env.KV.get("accounts");
+            const accounts: Account[] = accountsStr ? JSON.parse(accountsStr) : [];
+            const account = accounts.find(a => a.email === email);
+
+            if (!account) {
+                throw new Error("Account not found");
+            }
+            const browser = await BrowserManager.getInstance();
+            const context = await browser.newContext();
+            const page = await context.newPage();
+            await this.handleLoginProcess(page, account, "https://outlook.live.com/mail/0/?prompt=select_account");
+            await this.handleMultiFactorAuth(page, account);
+            await this.confirmLogin(page, account);
+
+            return { success: true };
+        } catch (error: any) {
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+
     private async handleLoginProcess(page: Page, account: Account, authUrl: string) {
         await page.goto(authUrl);
         await page.fill('input[type="email"]', account.email);

functions/utils/mail.ts

@@ -172,13 +172,100 @@ async function parseEmail(email: any): Promise<ParsedEmail> {
   }
 }
 
-export async function getEmails(accessToken: string, limit = 50): Promise<ParsedEmail[]> {
+/**
+ * 激活邮箱 - 通过多种方式唤醒可能休眠的邮箱
+ */
+export async function activateMailbox(accessToken: string): Promise<void> {
+  try {
+    // 方法1: 获取用户配置文件信息 - 这会触发用户会话
+    await fetch('https://graph.microsoft.com/v1.0/me', {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    // 方法2: 获取邮箱设置 - 这会激活邮箱服务
+    await fetch('https://graph.microsoft.com/v1.0/me/mailboxSettings', {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    // 方法3: 获取邮件文件夹 - 这会触发邮箱同步
+    await fetch('https://graph.microsoft.com/v1.0/me/mailFolders', {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    // 方法4: 检查收件箱状态
+    await fetch('https://graph.microsoft.com/v1.0/me/mailFolders/inbox', {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    console.log('邮箱激活操作完成');
+  } catch (error) {
+    console.warn('邮箱激活过程中出现错误:', error);
+    // 不抛出错误，因为激活失败不应该阻止后续的邮件获取
+  }
+}
+
+/**
+ * 强制同步邮箱 - 使用delta查询来触发同步
+ */
+export async function syncMailbox(accessToken: string): Promise<void> {
+  try {
+    // 使用delta查询来强制同步邮箱
+    const deltaEndpoint = 'https://graph.microsoft.com/v1.0/me/messages/delta';
+    await fetch(`${deltaEndpoint}?$top=1`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    console.log('邮箱同步操作完成');
+  } catch (error) {
+    console.warn('邮箱同步过程中出现错误:', error);
+  }
+}
+
+export async function getEmails(accessToken: string, limit = 50, forceActivate = false): Promise<ParsedEmail[]> {
+  // 如果需要强制激活邮箱
+  if (forceActivate) {
+    await activateMailbox(accessToken);
+    await syncMailbox(accessToken);
+
+    // 等待一小段时间让同步生效
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+
   const endpoint = 'https://graph.microsoft.com/v1.0/me/messages';
-  const response = await fetch(`${endpoint}?$top=${limit}`, {
+
+  // 添加更多查询参数来确保获取最新邮件
+  const queryParams = new URLSearchParams({
+    '$top': limit.toString(),
+    '$orderby': 'receivedDateTime desc',
+    '$select': 'id,subject,from,toRecipients,createdDateTime,receivedDateTime,sentDateTime,lastModifiedDateTime,body,importance,isRead,isDraft,hasAttachments,webLink,bodyPreview,categories,internetMessageId'
+  });
+
+  const response = await fetch(`${endpoint}?${queryParams}`, {
     method: 'GET',
     headers: {
       'Authorization': `Bearer ${accessToken}`,
-      'Content-Type': 'application/json'
+      'Content-Type': 'application/json',
+      'Prefer': 'outlook.timezone="Asia/Shanghai"' // 设置时区
     }
   });
 

functions/utils/mailboxActivator.ts

@@ -0,0 +1,244 @@
+/**
+ * 邮箱激活器 - 专门处理邮箱休眠问题
+ */
+
+import { get_access_token, getEmails, activateMailbox, syncMailbox } from './mail';
+
+export interface ActivationResult {
+    success: boolean;
+    activated: boolean;
+    emailCount: number;
+    latestEmailTime?: string;
+    error?: string;
+    activationMethods: string[];
+}
+
+export class MailboxActivator {
+    private accessToken: string;
+
+    constructor(accessToken: string) {
+        this.accessToken = accessToken;
+    }
+
+    /**
+     * 检测邮箱是否可能处于休眠状态
+     */
+    async detectDormantState(): Promise<{ isDormant: boolean; reason: string }> {
+        try {
+            // 1. 尝试获取最新邮件
+            const emails = await getEmails(this.accessToken, 5, false);
+            
+            if (emails.length === 0) {
+                return { isDormant: true, reason: "邮箱中没有邮件" };
+            }
+
+            // 2. 检查最新邮件的时间
+            const latestEmail = emails[0];
+            const latestTime = new Date(latestEmail.date.received || latestEmail.date.created);
+            const now = new Date();
+            const hoursDiff = (now.getTime() - latestTime.getTime()) / (1000 * 60 * 60);
+
+            // 如果最新邮件超过24小时，可能处于休眠状态
+            if (hoursDiff > 24) {
+                return { isDormant: true, reason: `最新邮件时间过旧: ${hoursDiff.toFixed(1)}小时前` };
+            }
+
+            // 3. 检查邮件数量是否异常少
+            if (emails.length < 3) {
+                return { isDormant: true, reason: "邮件数量异常少" };
+            }
+
+            return { isDormant: false, reason: "邮箱状态正常" };
+        } catch (error) {
+            return { isDormant: true, reason: `检测失败: ${error}` };
+        }
+    }
+
+    /**
+     * 执行全面的邮箱激活
+     */
+    async performFullActivation(): Promise<ActivationResult> {
+        const activationMethods: string[] = [];
+        let activated = false;
+
+        try {
+            console.log('开始执行邮箱激活...');
+
+            // 方法1: 基础激活
+            try {
+                await activateMailbox(this.accessToken);
+                activationMethods.push('基础激活');
+            } catch (error) {
+                console.warn('基础激活失败:', error);
+            }
+
+            // 方法2: 强制同步
+            try {
+                await syncMailbox(this.accessToken);
+                activationMethods.push('强制同步');
+            } catch (error) {
+                console.warn('强制同步失败:', error);
+            }
+
+            // 方法3: 深度激活 - 访问多个端点
+            try {
+                await this.deepActivation();
+                activationMethods.push('深度激活');
+            } catch (error) {
+                console.warn('深度激活失败:', error);
+            }
+
+            // 方法4: 模拟用户活动
+            try {
+                await this.simulateUserActivity();
+                activationMethods.push('模拟用户活动');
+            } catch (error) {
+                console.warn('模拟用户活动失败:', error);
+            }
+
+            // 等待激活生效
+            await new Promise(resolve => setTimeout(resolve, 5000));
+
+            // 验证激活效果
+            const emails = await getEmails(this.accessToken, 10, false);
+            const emailCount = emails.length;
+            const latestEmailTime = emails.length > 0 ? emails[0].date.received : undefined;
+
+            activated = activationMethods.length > 0;
+
+            return {
+                success: true,
+                activated,
+                emailCount,
+                latestEmailTime,
+                activationMethods
+            };
+
+        } catch (error: any) {
+            return {
+                success: false,
+                activated: false,
+                emailCount: 0,
+                error: error.message,
+                activationMethods
+            };
+        }
+    }
+
+    /**
+     * 深度激活 - 访问更多Microsoft Graph端点
+     */
+    private async deepActivation(): Promise<void> {
+        const endpoints = [
+            'https://graph.microsoft.com/v1.0/me/calendar',
+            'https://graph.microsoft.com/v1.0/me/contacts',
+            'https://graph.microsoft.com/v1.0/me/drive',
+            'https://graph.microsoft.com/v1.0/me/mailFolders/inbox/messages?$top=1',
+            'https://graph.microsoft.com/v1.0/me/mailFolders/sentitems',
+            'https://graph.microsoft.com/v1.0/me/mailFolders/drafts'
+        ];
+
+        const promises = endpoints.map(endpoint => 
+            fetch(endpoint, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json'
+                }
+            }).catch(error => {
+                console.warn(`访问端点失败 ${endpoint}:`, error);
+            })
+        );
+
+        await Promise.allSettled(promises);
+    }
+
+    /**
+     * 模拟用户活动
+     */
+    private async simulateUserActivity(): Promise<void> {
+        try {
+            // 1. 获取邮箱设置
+            await fetch('https://graph.microsoft.com/v1.0/me/mailboxSettings', {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            // 2. 获取用户照片（触发用户会话）
+            await fetch('https://graph.microsoft.com/v1.0/me/photo', {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`
+                }
+            }).catch(() => {}); // 忽略错误，因为用户可能没有照片
+
+            // 3. 获取最近活动
+            await fetch('https://graph.microsoft.com/v1.0/me/activities/recent', {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json'
+                }
+            }).catch(() => {}); // 忽略错误
+
+            // 4. 检查邮件规则
+            await fetch('https://graph.microsoft.com/v1.0/me/mailFolders/inbox/messageRules', {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json'
+                }
+            }).catch(() => {}); // 忽略错误
+
+        } catch (error) {
+            console.warn('模拟用户活动时出错:', error);
+        }
+    }
+
+    /**
+     * 智能激活 - 根据检测结果决定激活策略
+     */
+    async smartActivation(): Promise<ActivationResult> {
+        // 首先检测邮箱状态
+        const dormantCheck = await this.detectDormantState();
+        
+        if (!dormantCheck.isDormant) {
+            // 邮箱状态正常，只做轻量级激活
+            try {
+                await activateMailbox(this.accessToken);
+                const emails = await getEmails(this.accessToken, 5, false);
+                
+                return {
+                    success: true,
+                    activated: true,
+                    emailCount: emails.length,
+                    latestEmailTime: emails.length > 0 ? emails[0].date.received : undefined,
+                    activationMethods: ['轻量级激活']
+                };
+            } catch (error: any) {
+                return {
+                    success: false,
+                    activated: false,
+                    emailCount: 0,
+                    error: error.message,
+                    activationMethods: []
+                };
+            }
+        } else {
+            // 邮箱可能休眠，执行全面激活
+            console.log(`检测到邮箱可能休眠: ${dormantCheck.reason}`);
+            return await this.performFullActivation();
+        }
+    }
+}
+
+/**
+ * 便捷函数：激活指定邮箱
+ */
+export async function activateMailboxSmart(accessToken: string): Promise<ActivationResult> {
+    const activator = new MailboxActivator(accessToken);
+    return await activator.smartActivation();
+}

index.ts

@@ -14,12 +14,14 @@ import { fileURLToPath } from 'url'
 import { dirname } from 'path'
 import { getTenantAccessToken, sendFeishuMessageText } from './functions/utils/feishu.js'
 import { get_access_token, getEmails } from './functions/utils/mail.js'
+import { activateMailboxSmart } from './functions/utils/mailboxActivator.js'
 
 // 导入所有路由处理函数
 import { onRequest as handleAccount } from './functions/api/account.js'
 import { onRequest as handleLogin } from './functions/api/login.js'
 import { onRequest as handleSetting } from './functions/api/setting.js'
 import { onRequest as handleIP } from './functions/api/ip.js'
+import { onRequest as handleMailLogin } from './functions/api/mail/login.js'
 import { onRequest as handleMailAuth } from './functions/api/mail/auth.js'
 import { onRequest as handleMailCallback } from './functions/api/mail/callback.js'
 import { onRequest as handleMailAll } from './functions/api/mail/all.js'
@@ -27,6 +29,7 @@ import { onRequest as handleMailNew } from './functions/api/mail/new.js'
 import { onRequest as handleMailSend } from './functions/api/mail/send.js'
 import { onRequest as handleBatch } from './functions/api/mail/batch.js'
 import { onRequest as handleMailStatus } from './functions/api/mail/status.js'
+import { onRequest as handleMailActivate } from './functions/api/mail/activate.js'
 dotenv.config({ path: ['.env', '.env.local'], override: true });
 const isDev = process.env.NODE_ENV === 'development'
 
@@ -139,6 +142,9 @@ app.all('/api/*', async (c) => {
             case '/api/ip':
                 response = await handleIP(context);
                 break;
+            case '/api/mail/login':
+                response = await handleMailLogin(context);
+                break;
             case '/api/mail/auth':
                 response = await handleMailAuth(context);
                 break;
@@ -160,6 +166,9 @@ app.all('/api/*', async (c) => {
             case '/api/mail/batch':
                 response = await handleBatch(context);
                 break;
+            case '/api/mail/activate':
+                response = await handleMailActivate(context);
+                break;
             default:
                 return c.json({ error: 'Route not found' }, 404);
         }
@@ -245,8 +254,13 @@ async function checkEmailsForNewMessages(env: Env) {
                     const tokenInfo = JSON.parse(tokenInfoStr);
                     const access_token = await get_access_token(tokenInfo, env.ENTRA_CLIENT_ID, env.ENTRA_CLIENT_SECRET);
 
+                    // 使用智能激活器激活邮箱
+                    console.log(`开始智能激活邮箱: ${monitor.email}`);
+                    const activationResult = await activateMailboxSmart(access_token);
+                    console.log(`邮箱 ${monitor.email} 激活结果:`, activationResult);
+
                     // 获取最新邮件
-                    const emails = await getEmails(access_token, 1);
+                    const emails = await getEmails(access_token, 1, false);
                     if (emails.length === 0) {
                         console.log(`邮箱 ${monitor.email} 没有邮件`);
                         continue;

src/services/mailApi.ts

@@ -38,6 +38,18 @@ export const mailApi = {
         return handleResponse(response);
     },
 
+    async activateMailbox(email: string) {
+        const response = await fetch(
+            `${API_BASE_URL}/api/mail/activate`,
+            {
+                headers: getHeaders(),
+                method: 'POST',
+                body: JSON.stringify({ email })
+            }
+        );
+        return handleResponse(response);
+    },
+
     async getLatestMails(email: string) {
         const response = await fetch(
             `${API_BASE_URL}/api/mail/new`,

src/views/MailView.vue

@@ -32,6 +32,7 @@ const columns = [
 const actionOptions = (row: Account) => [
     { content: '查看认证', value: 'check', onClick: () => handleCheckAuth(row) },
     { content: '刷新认证', value: 'refresh', onClick: () => handleRefreshAuth(row) },
+    { content: '激活邮箱', value: 'activate', onClick: () => handleActivateMailbox(row) },
     { content: '最新邮件', value: 'latest', onClick: () => handleLatestMails(row) },
     { content: '所有邮件', value: 'all', onClick: () => handleAllMails(row) },
     { content: '发送邮件', value: 'send', onClick: () => handleSendMail(row) },
@@ -271,6 +272,23 @@ const handleLoginMail = async (row: Account) => {
     }
 };
 
+// 添加激活邮箱处理函数
+const handleActivateMailbox = async (row: Account) => {
+    try {
+        loading.value = true;
+        const result = await mailApi.activateMailbox(row.email);
+        if (result.success) {
+            MessagePlugin.success(`邮箱激活成功: ${result.message}`);
+        } else {
+            MessagePlugin.error(`邮箱激活失败: ${result.message}`);
+        }
+    } catch (error: any) {
+        MessagePlugin.error(`邮箱激活失败: ${error.message}`);
+    } finally {
+        loading.value = false;
+    }
+};
+
 
 </script>
 
@@ -292,6 +310,7 @@ const handleLoginMail = async (row: Account) => {
                     <div class="hidden md:flex flex-wrap gap-2">
                         <t-button size="small" variant="outline" @click="handleCheckAuth(row)">查看认证</t-button>
                         <t-button size="small" variant="outline" @click="handleRefreshAuth(row)">刷新认证</t-button>
+                        <t-button size="small" variant="outline" @click="handleActivateMailbox(row)" theme="warning">激活邮箱</t-button>
                         <t-button size="small" variant="outline" @click="handleLatestMails(row)">最新邮件</t-button>
                         <t-button size="small" variant="outline" @click="handleAllMails(row)">所有邮件</t-button>
                         <t-button size="small" variant="outline" @click="handleSendMail(row)">发送邮件</t-button>