@ubaidbinwaris/linkedin 1.0.0 → 1.0.7

package/Readme.md

@@ -1,84 +1,185 @@
-# LinkedIn Automation Bot
+# LinkedIn Automation Bot & Module 🤖
 
-A robust Node.js automation tool designed to interact with LinkedIn using [Playwright](https://playwright.dev/). This bot is built with stealth features to mimic human behavior, manage sessions efficiently, and provide an interactive CLI for control.
+A robust, stealthy Node.js automation tool designed to interact with LinkedIn using [Playwright](https://playwright.dev/). This package can be used as a standalone **CLI tool** or integrated as a **Module** into larger applications (supporting database storage, custom logging, and headless controls).
 
-## 🚀 Features
+> **⚠️ Disclaimer**: This tool is for educational purposes only. Automating interactions on LinkedIn violates their User Agreement. Use at your own risk. The authors are not responsible for any account bans or restrictions.
 
-- **Stealth Automation**: Uses `puppeteer-extra-plugin-stealth` with Playwright to minimize detection risks.
-- **Session Management**: Automatically saves and loads session states (cookies & local storage) to prevent frequent re-logins.
-- **Headless & Visible Modes**: configurable execution modes for debugging or background operation.
-- **Interactive CLI**: integrated REPL (Read-Eval-Print Loop) to control the bot instance after initialization.
-- **Smart Validation**: robust checks to verify login status and handle checkpoints/verifications manually if needed.
-- **Human-like Behavior**: Implements random delays, mouse movements, and dynamic user agents.
+---
 
-## 🛠️ Prerequisites
+## 🚀 Key Features
 
-- **Node.js** (v14 or higher recommended)
-- **npm** (Node Package Manager)
-- A valid **LinkedIn Account**
+-   **🕵️‍♂️ Stealth Automation**: Leverages `puppeteer-extra-plugin-stealth` to minimize detection risks.
+-   **👥 Multi-User Support**: Manage multiple LinkedIn accounts with isolated sessions.
+-   **💾 Flexible Session Storage**: Store sessions in local files (default) or **inject your own database adapter** (MongoDB, Postgres, Redis, etc.).
+-   **🖥️ Dual Modes**:
+    -   **Headless**: Runs efficiently in the background.
+    -   **Visible**: Watch the bot work for debugging.
+-   **⌨️ CLI & Interactive REPL**: Control the bot directly from the terminal.
+-   **🔌 Module Integration**: Easily integrate into existing Express/Node.js servers with custom logging and webhook-style checkpoint handling.
+-   **🧠 Smart Validation**: Automatically detects checkpoints (CAPTCHA/Pin) and allows manual resolution via terminal or callback.
+
+---
 
 ## 📦 Installation
 
-1.  **Clone the repository:**
-    ```bash
-    git clone https://github.com/UbaidBinWaris/linkedin.git
-    cd linkedin
-    ```
+### 1. Install via NPM
+```bash
+npm install @ubaidbinwaris/linkedin
+```
 
-2.  **Install dependencies:**
-    ```bash
-    npm install
-    ```
+### 2. (Optional) Clone for Source Usage
+```bash
+git clone https://github.com/UbaidBinWaris/linkedin.git
+cd linkedin
+npm install
+npx playwright install chromium
+```
 
-3.  **Install Playwright browsers:**
-    ```bash
-    npx playwright install chromium
-    ```
+---
 
-## ⚙️ Configuration
+## ▶️ Usage: CLI Mode
 
-1.  Create a `.env` file in the root directory.
-2.  Add your LinkedIn credentials:
+You can run the bot directly from the command line.
 
-    ```env
-    LINKEDIN_EMAIL=your_email@example.com
-    LINKEDIN_PASSWORD=your_password
-    ```
+### 1. Quick Start (Single User)
+Create a `.env` file with your credentials:
+```env
+LINKEDIN_EMAIL=your_email@example.com
+LINKEDIN_PASSWORD=your_password
+```
+Then run:
+```bash
+npm start
+```
 
-##  ▶️ Usage
+### 2. Multi-User Mode
+To manage multiple accounts, create a `users.js` file in the root directory:
 
-### Run in Headless Mode (Default)
-Runs the bot in the background without a visible browser window.
+**File:** `users.js`
+```javascript
+module.exports = [
+    { username: "alice@example.com", password: "password123" },
+    { username: "bob@company.com", password: "securePass!" }
+];
+```
 
+Run the bot:
 ```bash
 npm start
 ```
+The CLI will prompt you to select which user to log in as:
+```text
+Select a user to login:
+1. alice@example.com
+2. bob@company.com
+3. Use Environment Variables (.env)
+```
 
-### Run in Visible Mode
-Useful for debugging or if manual intervention (CAPTCHA) is required.
+---
 
-```bash
-npm start -- --visible
+## 🔌 Usage: Module Integration
+
+This package is designed to be embedded in larger systems (e.g., a SaaS backend managing hundreds of accounts).
+
+### Import
+```javascript
+const linkedin = require('@ubaidbinwaris/linkedin');
 ```
 
-### CLI Commands
-Once the bot is running, you can interact with it through the terminal. (See `src/cli/repl.js` for available commands).
+### 1. Custom Session Storage (Database Integration)
+By default, sessions are saved as JSON files in `data/linkedin/`. You can override this to save sessions directly in your database.
+
+```javascript
+// Example: Using a generic database
+linkedin.setSessionStorage({
+    async read(username) {
+        // Fetch encrypted session string from your DB
+        const user = await db.users.findOne({ email: username });
+        return user ? user.linkedinSession : null;
+    },
+    async write(username, data) {
+        // Save encrypted session string to your DB
+        await db.users.updateOne(
+            { email: username }, 
+            { $set: { linkedinSession: data } },
+            { upsert: true }
+        );
+    }
+});
+```
 
-## 📂 Project Structure
+### 2. Custom Logger
+Redirect bot logs to your application's logging system (e.g., Winston, Pino, Bunyan).
 
+```javascript
+linkedin.setLogger({
+    info: (msg) => console.log(`[BOT INFO] ${msg}`),
+    error: (msg) => console.error(`[BOT ERROR] ${msg}`),
+    warn: (msg) => console.warn(`[BOT WARN] ${msg}`),
+    debug: (msg) => console.debug(`[BOT DEBUG] ${msg}`)
+});
 ```
-├── src/
-│   ├── cli/            # Command Line Interface logic
-│   ├── login/          # Login automation & checkpoint handling
-│   ├── session/        # Session storage & management
-│   ├── utils/          # Helper functions (logger, timing, etc.)
-│   └── config.js       # Configuration constants
-├── data/               # Stored session data (cookies, etc.)
-├── logs/               # Application logs
-├── index.js            # Entry point
-└── package.json        # Dependencies & scripts
+
+### 3. Login & Headless Control
+When running on a server, you can't use the terminal to solve CAPTCHAs. Use the `onCheckpoint` callback to handle verification requests (e.g., trigger an alert).
+
+```javascript
+const credentials = { 
+    username: "alice@example.com", 
+    password: "password123" 
+};
+
+try {
+    const { browser, page } = await linkedin.loginToLinkedIn({
+        headless: true,
+        // Callback when LinkedIn asks for verification
+        onCheckpoint: async () => {
+            console.log("⚠️ Checkpoint detected! Pausing for manual intervention...");
+            
+            // Example: Send an email/Slack alert to admin
+            await sendAdminAlert(`User ${credentials.username} needs verification!`);
+            
+            // Wait for admin to signal resolution (e.g. via DB flag or API call)
+            await waitForAdminResolution();
+            
+            console.log("Resuming login...");
+        }
+    }, credentials);
+
+    console.log("Login successful!");
+    
+    // Do automation tasks...
+    await browser.close();
+
+} catch (err) {
+    console.error("Login failed:", err);
+}
 ```
 
-## ⚠️ Disclaimer
+---
+
+## 🛠️ Configuration Options
+
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `headless` | `boolean` | `false` | Run browser in background. |
+| `slowMo` | `number` | `50` | Delay between actions (ms). |
+| `proxy` | `string` | `undefined` | Proxy URL (e.g., `http://user:pass@host:port`). |
+| `onCheckpoint` | `function` | `null` | Async callback triggered when verification is needed. |
+
+---
+
+## ❓ Troubleshooting
+
+### "Checkpoint Detected"
+-   **CLI Mode**: The bot will pause and ask you to open a visible browser. Press ENTER to open it, solve the CAPTCHA, and the bot will confirm success and resume.
+-   **Module Mode**: Ensure you provide an `onCheckpoint` callback to handle this event, otherwise the promise will reject or hang depending on implementation.
+
+### Session Files
+-   Sessions are encrypted and contain timestamps.
+-   If `setSessionStorage` is NOT used, files are stored in `data/linkedin/<sanitized_username>.json`.
+
+---
 
-This tool is for educational purposes only. Automating interactions on LinkedIn violates their User Agreement. Use at your own risk. The authors are not responsible for any account bans or restrictions.
+## 📄 License
+MIT License.

package/cli.js

@@ -32,12 +32,40 @@ process.on("SIGINT", async () => {
   try {
     // Check command line arguments
     const args = process.argv.slice(2);
+    
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`
+LinkedIn Automation CLI
+
+Usage:
+  linkedin [options]
+
+Options:
+  --visible       Run in visible mode (default is headless)
+  --help, -h      Show this help message
+  --version, -v   Show version number
+`);
+        process.exit(0);
+    }
+
+    if (args.includes("--version") || args.includes("-v")) {
+        const packageJson = require("./package.json");
+        console.log(`v${packageJson.version}`);
+        process.exit(0);
+    }
+
+const { selectUser } = require("./src/cli/userSelection");
+
     const isVisible = args.includes("--visible");
     const isHeadless = !isVisible;
 
+    // Select User
+    const credentials = await selectUser();
+
     console.log(`Starting bot in ${isVisible ? "Visible" : "Headless"} Mode...`);
     
-    const { browser, context, page } = await loginToLinkedIn({ headless: isHeadless });
+    // Pass credentials (or null) to login function
+    const { browser, context, page } = await loginToLinkedIn({ headless: isHeadless }, credentials);
     browserInstance = browser;
     
     console.log("Login successful.");

package/index.js

@@ -1,11 +1,14 @@
 const loginToLinkedIn = require('./src/login/login');
 const sessionManager = require('./src/session/sessionManager');
 const config = require('./src/config');
-const logger = require('./src/utils/logger');
+const logger = require('./src/utils/logger'); // This is now the proxy object
 // Exporting the main function and other utilities for library usage
 module.exports = {
     loginToLinkedIn,
     sessionManager,
+    setSessionDir: sessionManager.setSessionDir,
+    setSessionStorage: sessionManager.setSessionStorage,
+    setLogger: logger.setLogger,
     config,
     logger
 };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ubaidbinwaris/linkedin",
-  "version": "1.0.0",
+  "version": "1.0.7",
   "description": "",
   "main": "index.js",
   "bin": {
-    "linkedin": "./cli.js"
+    "linkedin": "cli.js"
   },
   "files": [
     "src",

package/src/cli/userSelection.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const logger = require('../utils/logger');
+
+const USERS_FILE = path.join(process.cwd(), 'users.js');
+
+/**
+ * Loads users from users.js and prompts for selection if multiple exist.
+ * @returns {Promise<Object|null>} Selected credentials { username, password } or null if using env.
+ */
+async function selectUser() {
+    if (!fs.existsSync(USERS_FILE)) {
+        logger.info("No users.js file found. Using environment variables.");
+        return null;
+    }
+
+    let users = [];
+    try {
+        users = require(USERS_FILE);
+        if (!Array.isArray(users) || users.length === 0) {
+            logger.warn("users.js exists but exports an empty array or invalid format.");
+            return null;
+        }
+    } catch (error) {
+        logger.error(`Error loading users.js: ${error.message}`);
+        return null;
+    }
+
+    if (users.length === 1) {
+        logger.info(`Single user found in users.js: ${users[0].username}`);
+        return users[0];
+    }
+
+    // Multiple users - Prompt for selection
+    console.log('\nSelect a user to login:');
+    users.forEach((u, index) => {
+        console.log(`${index + 1}. ${u.username}`);
+    });
+    console.log(`${users.length + 1}. Use Environment Variables (.env)`);
+
+    const selectedIndex = await new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        const ask = () => {
+            rl.question('\nEnter number: ', (answer) => {
+                const num = parseInt(answer);
+                if (!isNaN(num) && num >= 1 && num <= users.length + 1) {
+                    rl.close();
+                    resolve(num - 1);
+                } else {
+                    console.log('Invalid selection. Try again.');
+                    ask();
+                }
+            });
+        };
+        ask();
+    });
+
+    if (selectedIndex === users.length) {
+        logger.info("Selected: Environment Variables");
+        return null; // Fallback to env
+    }
+
+    const selectedUser = users[selectedIndex];
+    logger.info(`Selected user: ${selectedUser.username}`);
+    return selectedUser;
+}
+
+module.exports = { selectUser };

package/src/login/login.js

@@ -76,14 +76,26 @@ function getRandomUserAgent() {
  * @param {number} [options.slowMo=50] - Slow motion delay in ms.
  * @param {string} [options.proxy] - Optional proxy server URL.
  */
-async function loginToLinkedIn(options = {}) {
+/**
+ * Main login function.
+ * @param {Object} options - Launch options for the browser.
+ * @param {boolean} [options.headless=false] - Whether to run in headless mode.
+ * @param {number} [options.slowMo=50] - Slow motion delay in ms.
+ * @param {string} [options.proxy] - Optional proxy server URL.
+ * @param {Function} [options.onCheckpoint] - Callback when verification is needed in headless mode.
+ * @param {Object} [credentials] - Optional credentials object { username, password }
+ */
+async function loginToLinkedIn(options = {}, credentials = null) {
   logger.info("Starting LinkedIn login process with stealth mode...");
 
-  try {
-    validateCredentials();
-  } catch (error) {
-    logger.error(error.message);
-    throw error;
+  // Determine credentials
+  const email = credentials?.username || process.env.LINKEDIN_EMAIL;
+  const password = credentials?.password || process.env.LINKEDIN_PASSWORD;
+
+  if (!email || !password) {
+      const errorMsg = "Missing credentials. Provide them in arguments or set LINKEDIN_EMAIL/LINKEDIN_PASSWORD env vars.";
+      logger.error(errorMsg);
+      throw new Error(errorMsg);
   }
 
   const launchOptions = {
@@ -97,7 +109,7 @@ async function loginToLinkedIn(options = {}) {
     ...options,
   };
 
-  logger.info(`Launching browser...`);
+  logger.info(`Launching browser for user: ${email}...`);
   const browser = await chromium.launch(launchOptions);
 
   let context;
@@ -116,8 +128,8 @@ async function loginToLinkedIn(options = {}) {
     // -----------------------------
     // STEP 1: Try Using Saved Session
     // -----------------------------
-    logger.info("Checking for saved session...");
-    context = await loadSession(browser, contextOptions);
+    logger.info(`Checking for saved session for ${email}...`);
+    context = await loadSession(browser, contextOptions, email);
 
     if (context) {
       logger.info("Session stored context created.");
@@ -141,11 +153,57 @@ async function loginToLinkedIn(options = {}) {
 
     // Check for checkpoint immediately after navigation
     if (await detectCheckpoint(page)) {
-      logger.warn("Checkpoint detected immediately. Manual verification required.");
-      await waitForUserResume("Complete verification in the opened browser, then press ENTER here to continue...");
+      if (launchOptions.headless) {
+        logger.warn("Checkpoint detected in headless mode.");
+        
+        if (options.onCheckpoint && typeof options.onCheckpoint === 'function') {
+           logger.info("Triggering onCheckpoint callback...");
+           await options.onCheckpoint();
+           // We assume the callback resolves when the user has taken action (e.g. solved via visible browser)
+           // But here we need to know what to do next. 
+           // If the user solved it in a *different* browser/session, we might need to reload.
+           // For now, let's assume the callback handles the visible switch logic we implemented before, 
+           // OR validates externally.
+           // However, to keep it simple and compatible with our previous logic:
+           // If onCheckpoint is provided, we await it, then close this browser and retry (assuming session saved).
+           
+           logger.info("onCheckpoint resolved. Retrying login...");
+           await browser.close();
+           return loginToLinkedIn(options, credentials);
+        }
+
+        logger.info("Switching to visible mode for manual verification...");
+        
+        await waitForUserResume("Press ENTER to open a visible browser to verify your account...");
+        
+        logger.info("Closing headless browser...");
+        await browser.close();
+
+        logger.info("Launching visible browser for verification...");
+        // Call recursively in visible mode
+        // We pass the same options but force headless: false
+        const visibleInstance = await loginToLinkedIn({ ...options, headless: false }, { username: email, password });
+        
+        // Once the visible instance returns, it means login was successful and session is saved.
+        logger.info("Verification successful in visible mode.");
+        logger.info("Closing visible browser and resuming headless session...");
+        await visibleInstance.browser.close();
+        
+        // Restart the original headless request. 
+        // It should now find the valid session and proceed without checkpoints.
+        return loginToLinkedIn(options, { username: email, password });
+
+      } else {
+        logger.warn("Checkpoint detected immediately. Manual verification required.");
+         if (options.onCheckpoint && typeof options.onCheckpoint === 'function') {
+             await options.onCheckpoint();
+         } else {
+             await waitForUserResume("Complete verification in the opened browser, then press ENTER here to continue...");
+         }
+      }
     }
 
-const { VALIDATION_SELECTORS } = require("../config");
+    const { VALIDATION_SELECTORS } = require("../config");
 
     // Verify Session Validity
     try {
@@ -189,9 +247,6 @@ const { VALIDATION_SELECTORS } = require("../config");
        await randomDelay(1000, 2000);
     }
 
-    const email = process.env.LINKEDIN_EMAIL;
-    const password = process.env.LINKEDIN_PASSWORD;
-
     logger.info("Entering credentials...");
     
     // Simulate human typing
@@ -214,8 +269,54 @@ const { VALIDATION_SELECTORS } = require("../config");
 
     // Check for checkpoint again
     if (await detectCheckpoint(page)) {
-      logger.warn("Checkpoint detected after login attempt. Manual verification required.");
-      await waitForUserResume("Complete verification in the opened browser, then press ENTER here to continue...");
+      if (launchOptions.headless) {
+           logger.warn("Checkpoint detected in headless mode (post-login).");
+           
+           if (options.onCheckpoint && typeof options.onCheckpoint === 'function') {
+                logger.info("Triggering onCheckpoint callback...");
+                await options.onCheckpoint();
+                logger.info("onCheckpoint resolved. Retrying login...");
+                await browser.close();
+                return loginToLinkedIn(options, credentials);
+            }
+
+           logger.info("Switching to visible mode for manual verification...");
+           
+           await waitForUserResume("Press ENTER to open a visible browser to verify your account...");
+           
+           logger.info("Closing headless browser...");
+           await browser.close();
+   
+           logger.info("Launching visible browser for verification...");
+           const visibleInstance = await loginToLinkedIn({ ...options, headless: false }, { username: email, password });
+           
+           logger.info("Verification successful. Resuming headless session...");
+           await visibleInstance.browser.close();
+           
+           return loginToLinkedIn(options, { username: email, password });
+      } else {
+          logger.warn("Checkpoint detected after login attempt. Manual verification required.");
+          if (options.onCheckpoint && typeof options.onCheckpoint === 'function') {
+             await options.onCheckpoint();
+          } else {
+             logger.info("Waiting for manual verification in the opened browser...");
+             logger.info("Please solve the CAPTCHA/verification. The browser will close automatically when you are redirected to the feed.");
+             
+             try {
+                // Wait for URL to include '/feed' OR any validation selector to appear
+                await page.waitForFunction(() => {
+                    return window.location.href.includes("/feed") || 
+                           document.querySelector('.global-nav__search') ||
+                           document.querySelector('#global-nav-typeahead');
+                }, { timeout: 300000 }); // 5 minutes timeout
+                
+                logger.info("Verification detected! resuming...");
+             } catch (err) {
+                logger.error("Timeout waiting for manual verification.");
+                throw new Error("Manual verification timed out.");
+             }
+          }
+      }
     }
 
     // -----------------------------
@@ -233,7 +334,7 @@ const { VALIDATION_SELECTORS } = require("../config");
         logger.info("Login confirmed ✅");
 
         // Save session state
-        await saveSession(context);
+        await saveSession(context, email);
         logger.info("Session state saved 💾");
 
         return { browser, context, page };

package/src/session/sessionManager.js

@@ -3,7 +3,16 @@ const path = require("path");
 const crypto = require("crypto");
 const logger = require("../utils/logger");
 
-const SESSION_PATH = path.join(__dirname, "../../data/session.json");
+let sessionDir = path.join(process.cwd(), "data", "linkedin");
+
+/**
+ * Sets the directory where session files are stored.
+ * @param {string} dirPath - Absolute path to the session directory.
+ */
+function setSessionDir(dirPath) {
+  sessionDir = dirPath;
+}
+
 const ALGORITHM = "aes-256-cbc";
 // Use a fixed key if not provided in env (for development convenience, but ideally should be in env)
 // Ensure the key is 32 bytes.
@@ -35,21 +44,75 @@ function decrypt(text) {
   }
 }
 
-function sessionExists() {
-  return fs.existsSync(SESSION_PATH);
+/**
+ * Sanitizes a username to be safe for filenames.
+ * Replaces special characters with underscores or descriptive text.
+ * @param {string} username 
+ * @returns {string}
+ */
+function sanitizeUsername(username) {
+  if (!username) return "default_session";
+  return username
+    .replace(/@/g, "_at_")
+    .replace(/\./g, "_dot_")
+    .replace(/[^a-zA-Z0-9_\-]/g, "_");
+}
+
+function getSessionPath(username) {
+  const filename = `${sanitizeUsername(username)}.json`;
+  return path.join(sessionDir, filename);
 }
 
-function getSessionPath() {
-  return SESSION_PATH;
+function sessionExists(username) {
+  return fs.existsSync(getSessionPath(username));
 }
 
 const { SESSION_MAX_AGE } = require("../config");
 
+const defaultStorage = {
+  /**
+   * Reads session data for a user.
+   * @param {string} username 
+   * @returns {Promise<string|null>} Encrypted session string or null
+   */
+  async read(username) {
+    const filePath = getSessionPath(username);
+    if (!fs.existsSync(filePath)) return null;
+    return fs.readFileSync(filePath, "utf-8");
+  },
+  
+  /**
+   * Writes session data for a user.
+   * @param {string} username 
+   * @param {string} data - Encrypted session string
+   */
+  async write(username, data) {
+    const filePath = getSessionPath(username);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, data, "utf-8");
+  }
+};
+
+let currentStorage = defaultStorage;
+
 /**
- * Saves the browser context storage state to an encrypted file with a timestamp.
+ * Sets a custom session storage adapter.
+ * @param {Object} adapter - Object with read(username) and write(username, data) methods.
+ */
+function setSessionStorage(adapter) {
+  if (adapter && typeof adapter.read === 'function' && typeof adapter.write === 'function') {
+    currentStorage = adapter;
+  } else {
+    logger.warn("Invalid storage adapter provided. Using default file storage.");
+  }
+}
+
+/**
+ * Saves the browser context storage state to an encrypted file/storage with a timestamp.
  * @param {import('playwright').BrowserContext} context 
+ * @param {string} [username] - The username to associate with this session
  */
-async function saveSession(context) {
+async function saveSession(context, username) {
   try {
     const state = await context.storageState();
     
@@ -62,29 +125,39 @@ async function saveSession(context) {
     const jsonString = JSON.stringify(sessionData);
     const encryptedData = encrypt(jsonString);
     
-    fs.mkdirSync(path.dirname(SESSION_PATH), { recursive: true });
-    fs.writeFileSync(SESSION_PATH, encryptedData, "utf-8");
-    logger.info("Session saved successfully (Encrypted & Timestamped) 🔒");
+    await currentStorage.write(username || "default", encryptedData);
+
+    logger.info(`Session saved successfully for ${username || "default"} (Encrypted & Timestamped) 🔒`);
   } catch (error) {
     logger.error(`Failed to save session: ${error.message}`);
   }
 }
 
 /**
- * Loads the session from the encrypted file and creates a new context.
+ * Loads the session from storage and creates a new context.
  * Checks for session expiry.
  * @param {import('playwright').Browser} browser 
  * @param {Object} options - Context options
+ * @param {string} [username] - The username to load session for
  * @returns {Promise<import('playwright').BrowserContext>}
  */
-async function loadSession(browser, options = {}) {
-  if (!sessionExists()) {
-    logger.info("No session file found.");
-    return null;
-  }
+async function loadSession(browser, options = {}, username) {
+  const user = username || "default";
+
+  // Check existence if storage supports it, otherwise generic check
+  // For custom storage, read() returning null implies not found.
+  
+  // Note: sessionExists is tied to FS. We should deprecate it or update it.
+  // But for now, let's rely on read() returning null.
 
   try {
-    const fileContent = fs.readFileSync(SESSION_PATH, "utf-8");
+    const fileContent = await currentStorage.read(user);
+    
+    if (!fileContent) {
+      logger.info(`No session found for ${user}.`);
+      return null;
+    }
+
     let sessionData;
     let state;
 
@@ -119,7 +192,7 @@ async function loadSession(browser, options = {}) {
            return null;
         }
       } else {
-         logger.error("Failed to decrypt session file. It might be corrupt or key mismatch.");
+         logger.error("Failed to decrypt session data. It might be corrupt or key mismatch.");
          return null;
       }
     }
@@ -132,7 +205,7 @@ async function loadSession(browser, options = {}) {
         return null;
       }
       state = sessionData.state;
-      logger.info(`Loaded active session (Age: ${Math.round(age / 1000 / 60)} mins) 🔓.`);
+      logger.info(`Loaded active session for ${username || "default"} (Age: ${Math.round(age / 1000 / 60)} mins) 🔓.`);
     }
 
     const context = await browser.newContext({
@@ -148,6 +221,8 @@ async function loadSession(browser, options = {}) {
 }
 
 module.exports = {
+  setSessionDir,
+  setSessionStorage,
   sessionExists,
   getSessionPath,
   saveSession,

package/src/utils/logger.js

@@ -1,4 +1,5 @@
 const { createLogger, format, transports } = require("winston");
+const winston = require("winston");
 const path = require("path");
 const fs = require("fs");
 
@@ -8,23 +9,42 @@ if (!fs.existsSync(logDir)) {
   fs.mkdirSync(logDir, { recursive: true });
 }
 
-const logger = createLogger({
+// Create default logger
+const defaultLogger = winston.createLogger({
   level: "info",
-  format: format.combine(
-    format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-    format.printf(({ timestamp, level, message }) => {
-      return `${timestamp} [${level.toUpperCase()}] ${message}`;
+  format: winston.format.combine(
+    winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+    winston.format.printf(({ timestamp, level, message }) => {
+      return `${timestamp} [${level.toUpperCase()}]: ${message}`;
     })
   ),
   transports: [
-    new transports.File({
-      filename: path.join(logDir, "error.log"),
-      level: "error",
-    }),
-    new transports.File({
-      filename: path.join(logDir, "combined.log"),
-    }),
+    new winston.transports.File({ filename: path.join(logDir, "error.log"), level: "error" }),
+    new winston.transports.File({ filename: path.join(logDir, "combined.log") }),
   ],
 });
 
-module.exports = logger;
+let currentLogger = defaultLogger;
+
+/**
+ * Sets a custom logger instance.
+ * @param {Object} customLogger - Logger object with info(), error(), warn(), debug() methods.
+ */
+function setLogger(customLogger) {
+  if (customLogger && typeof customLogger.info === 'function') {
+    currentLogger = customLogger;
+  } else {
+    console.warn("Invalid logger provided. Using default.");
+  }
+}
+
+// Proxy object to forward calls to the current logger
+const loggerProxy = {
+  info: (msg) => currentLogger.info(msg),
+  error: (msg) => currentLogger.error(msg),
+  warn: (msg) => currentLogger.warn(msg),
+  debug: (msg) => currentLogger.debug(msg),
+  setLogger // Export configuration method
+};
+
+module.exports = loggerProxy;