feat: load session to auto login

.gitignore

@@ -36,4 +36,4 @@ coverage/
 
 **/temp/
 
-*.session.json
+twitter-session.json

services/twitter-services/src/adapters/mcp-adapter.ts

@@ -124,24 +124,23 @@ export class MCPAdapter {
     // Add login tool
     this.mcpServer.tool(
       'login',
-      {
-        username: z.string(),
-        password: z.string(),
-      },
-      async ({ username, password }) => {
+      {},
+      async () => {
         try {
-          const success = await this.twitterService.login({ username, password })
+          const success = await this.twitterService.login()
 
           return {
             content: [{
               type: 'text',
-              text: success ? 'Successfully logged into Twitter' : 'Login failed, please check credentials',
+              text: success
+                ? '成功从会话文件加载登录状态！如果您是手动登录，系统已设置自动监控来保存您的会话。'
+                : '没有找到有效的会话文件。请在浏览器中手动登录，系统会自动保存您的会话。',
             }],
           }
         }
         catch (error) {
           return {
-            content: [{ type: 'text', text: `Login failed: ${errorToMessage(error)}` }],
+            content: [{ type: 'text', text: `检查登录状态失败: ${errorToMessage(error)}` }],
             isError: true,
           }
         }
@@ -227,6 +226,32 @@ export class MCPAdapter {
       },
     )
 
+    // Add save session tool
+    this.mcpServer.tool(
+      'save-session',
+      {},
+      async () => {
+        try {
+          const success = await this.twitterService.saveSession()
+
+          return {
+            content: [{
+              type: 'text',
+              text: success
+                ? 'Successfully saved browser session to file. This session will be loaded automatically next time.'
+                : 'Failed to save browser session',
+            }],
+          }
+        }
+        catch (error) {
+          return {
+            content: [{ type: 'text', text: `Failed to save session: ${errorToMessage(error)}` }],
+            isError: true,
+          }
+        }
+      },
+    )
+
     // Add search tool
     this.mcpServer.tool(
       'search',

services/twitter-services/src/config/index.ts

@@ -59,9 +59,6 @@ export class ConfigManager {
     if (configPath) {
       this.loadFromFile(configPath)
     }
-
-    // Validate configuration
-    this.validateConfig()
   }
 
   /**
@@ -83,20 +80,6 @@ export class ConfigManager {
     }
   }
 
-  /**
-   * Validate configuration validity
-   */
-  private validateConfig(): void {
-    // Validate Twitter credentials
-    if (!this.config.twitter.credentials?.username || !this.config.twitter.credentials?.password) {
-      logger.config.warn('Twitter credentials not set!')
-    }
-
-    logger.config.withFields({
-      config: this.config,
-    }).log('Configuration validation complete')
-  }
-
   /**
    * Get complete configuration
    */
@@ -110,7 +93,6 @@ export class ConfigManager {
   updateConfig(newConfig: Partial<Config>): void {
     // Use defu to merge new configuration
     this.config = defu(newConfig, this.config)
-    this.validateConfig()
   }
 }
 

services/twitter-services/src/config/types.ts

@@ -1,5 +1,5 @@
 import type { BrowserConfig } from '../types/browser'
-import type { SearchOptions, TimelineOptions, TwitterCredentials } from '../types/twitter'
+import type { SearchOptions, TimelineOptions } from '../types/twitter'
 
 import process from 'node:process'
 
@@ -15,7 +15,6 @@ export interface Config {
 
   // Twitter configuration
   twitter: {
-    credentials?: TwitterCredentials
     defaultOptions?: {
       timeline?: TimelineOptions
       search?: SearchOptions
@@ -64,11 +63,6 @@ export function getDefaultConfig(): Config {
       requestRetries: Number.parseInt(process.env.BROWSER_REQUEST_RETRIES || '2'),
     },
     twitter: {
-      credentials: {
-        username: process.env.TWITTER_USERNAME || '',
-        password: process.env.TWITTER_PASSWORD || '',
-        // Don't include cookies here, they will be loaded from session file
-      },
       defaultOptions: {
         timeline: {
           count: 20,

services/twitter-services/src/core/auth-service.ts

@@ -1,5 +1,4 @@
 import type { BrowserContext, Cookie, Page } from 'playwright'
-import type { TwitterCredentials } from '../types/twitter'
 
 import fs from 'node:fs/promises'
 import path from 'node:path'
@@ -97,36 +96,24 @@ export class TwitterAuthService {
   }
 
   /**
-   * Login to Twitter - compatibility method for existing code
-   * Prefers cookie-based login if cookies provided, otherwise redirects to manual login
+   * Login to Twitter - simplified method that only tries to use session file
+   * Users are expected to manually login and save the session
    */
-  async login(credentials: TwitterCredentials = {}): Promise<boolean> {
+  async login(): Promise<boolean> {
     logger.auth.log('Starting Twitter login process')
 
     try {
-      // Check if cookies are provided
-      if (credentials.cookies && Object.keys(credentials.cookies).length > 0) {
-        logger.auth.log(`Attempting to login with ${Object.keys(credentials.cookies).length} provided cookies`)
-        return await this.loginWithCookies(credentials.cookies)
-      }
-
       // Try to login with existing session first
-      logger.auth.log('No cookies provided, attempting to load session from file')
+      logger.auth.log('Attempting to load session from file')
       const sessionSuccess = await this.checkExistingSession()
 
       if (sessionSuccess) {
         logger.auth.log('Successfully logged in with session file')
         return true
       }
 
-      // If credentials are provided, try username/password login
-      if (credentials.username && credentials.password) {
-        logger.auth.log('Session login failed, attempting username/password login')
-        return await this.initiateManualLogin(credentials.username, credentials.password)
-      }
-
-      // No credentials and no session, fail
-      logger.auth.warn('No cookies, no valid session, and no credentials provided')
+      // Log session failure but don't attempt automatic login
+      logger.auth.log('No valid session found, manual login is required')
       return false
     }
     catch (error: unknown) {
@@ -145,6 +132,17 @@ export class TwitterAuthService {
       // First check for timeline which is definitive proof of being logged in
       try {
         await this.page.waitForSelector(SELECTORS.HOME.TIMELINE, { timeout: 15000 })
+
+        // Login verification successful - automatically save session
+        this.isLoggedIn = true
+        try {
+          await this.saveCurrentSession()
+          logger.auth.log('✅ Auto-saved session after successful login verification')
+        }
+        catch (error) {
+          logger.auth.withError(error as Error).warn('Failed to auto-save session')
+        }
+
         return true
       }
       catch {
@@ -155,6 +153,17 @@ export class TwitterAuthService {
       try {
         const profileSelector = '[data-testid="AppTabBar_Profile_Link"]'
         await this.page.waitForSelector(profileSelector, { timeout: 5000 })
+
+        // Profile link found - automatically save session
+        this.isLoggedIn = true
+        try {
+          await this.saveCurrentSession()
+          logger.auth.log('✅ Auto-saved session after finding profile link')
+        }
+        catch (error) {
+          logger.auth.withError(error as Error).warn('Failed to auto-save session')
+        }
+
         return true
       }
       catch {
@@ -199,7 +208,21 @@ export class TwitterAuthService {
   async checkLoginStatus(): Promise<boolean> {
     try {
       await this.page.goto('https://x.com/home')
-      return await this.verifyLogin()
+      const isLoggedIn = await this.verifyLogin()
+
+      // If already logged in, update state and automatically save session
+      if (isLoggedIn && !this.isLoggedIn) {
+        this.isLoggedIn = true
+        try {
+          await this.saveCurrentSession()
+          logger.auth.log('✅ Auto-saved session during status check')
+        }
+        catch (error) {
+          logger.auth.withError(error as Error).warn('Failed to auto-save session during status check')
+        }
+      }
+
+      return isLoggedIn
     }
     catch {
       return false
@@ -509,38 +532,13 @@ export class TwitterAuthService {
    */
   async saveCurrentSession(): Promise<void> {
     try {
-      // Get the cookies from the browser
-      const cookies = await this.exportCookies('object')
-
-      // Format the cookies for the session manager
-      // We need to convert Record<string, string> to the Cookie[] format
-      const cookieArray = Object.entries(cookies).map(([name, value]) => ({
-        name,
-        value, // This will be a string now
-        domain: '.x.com',
-        path: '/',
-        expires: -1, // Session cookie
-      }))
-
-      // Get the storage state from the browser
+      // Get the storage state directly from context
       const storageState = await this.context.storageState()
 
-      // Create a new session data object with proper type cast
-      const sessionData: StorageState = {
-        cookies: cookieArray.map(cookie => ({
-          ...cookie,
-          sameSite: 'Lax' as const,
-          secure: true,
-          httpOnly: true,
-        })),
-        origins: storageState.origins,
-        // Don't include path property here as it's not needed for saving
-      }
-
-      // Save the session
-      await sessionManager.saveStorageState(sessionData)
+      // Save the session using the session manager
+      await sessionManager.saveStorageState(storageState)
 
-      logger.auth.log(`Session saved with ${typeof cookies === 'object' ? Object.keys(cookies).length : 0} cookies`)
+      logger.auth.log('✅ Session saved to file using browserContext.storageState()')
     }
     catch (error) {
       logger.auth.withError(error as Error).warn('Failed to save session')

services/twitter-services/src/core/twitter-service.ts

@@ -5,12 +5,13 @@ import type {
   TimelineOptions,
   Tweet,
   TweetDetail,
-  TwitterCredentials,
   UserProfile,
 } from '../types/twitter'
 import type { TwitterAuthService } from './auth-service'
 import type { TwitterTimelineService } from './timeline-service'
 
+import process from 'node:process'
+
 /**
  * Twitter service implementation
  * Integrates various service components, providing a unified interface
@@ -27,8 +28,8 @@ export class TwitterService implements ITwitterService {
   /**
    * Log in to Twitter
    */
-  async login(credentials: TwitterCredentials): Promise<boolean> {
-    return await this.authService.login(credentials)
+  async login(): Promise<boolean> {
+    return await this.authService.login()
   }
 
   /**
@@ -99,6 +100,20 @@ export class TwitterService implements ITwitterService {
     throw new Error('Post tweet feature not yet implemented')
   }
 
+  /**
+   * Save current browser session to file
+   * This allows users to manually save their session after logging in
+   */
+  async saveSession(): Promise<boolean> {
+    try {
+      await this.authService.saveCurrentSession()
+      return true
+    }
+    catch {
+      return false
+    }
+  }
+
   /**
    * Ensure authenticated
    */
@@ -115,4 +130,48 @@ export class TwitterService implements ITwitterService {
   async exportCookies(format: 'object' | 'string' = 'object'): Promise<Record<string, string> | string> {
     return await this.authService.exportCookies(format)
   }
+
+  /**
+   * Start automatic session monitoring
+   * Checks login status at regular intervals and saves the session if login is detected
+   * @param interval Interval in milliseconds, defaults to 30 seconds
+   */
+  startSessionMonitor(interval: number = 30000): void {
+    // Check immediately in case we're already logged in
+    this.checkAndSaveSession()
+
+    // Set interval for regular checks
+    const timer = setInterval(() => {
+      this.checkAndSaveSession()
+    }, interval)
+
+    // Clean up timer on process exit
+    process.on('exit', () => {
+      clearInterval(timer)
+    })
+
+    process.on('SIGINT', () => {
+      clearInterval(timer)
+    })
+
+    process.on('SIGTERM', () => {
+      clearInterval(timer)
+    })
+  }
+
+  /**
+   * Check login status and save session if logged in
+   * @private
+   */
+  private async checkAndSaveSession(): Promise<void> {
+    try {
+      const isLoggedIn = this.authService.isAuthenticated() || await this.authService.checkLoginStatus()
+      if (isLoggedIn) {
+        await this.saveSession()
+      }
+    }
+    catch {
+      // Silently handle errors - don't disrupt the application flow
+    }
+  }
 }