@msout/microsoft-webauth 0.0.7 → 0.0.9

package/README.md

@@ -2,7 +2,8 @@
 
 A tool to authenticate against microsoft online (live or professionnal tenants)
 We do not rely on GraphAPI.
-e.g: 
+
+e.g:
   - https://onenote.cloud.microsoft/notebooks
   - https://outlook.live.com/mail/
   - and by extension https://login.microsoft.com
@@ -18,6 +19,13 @@ This is a standalone CLI tool for authenticating with Microsoft accounts using P
 - MFA/2FA support (OTC codes, number matching)
 - Session persistence
 
+## Why this project ?
+
+While this let you authenticate this is a part of a bigger purpose,
+primary aim is to offer people a simple way to get out of Microsoft OneNote, because you regardless of what ms documentation states
+=> https://learn.microsoft.com/en-us/answers/questions/2276682/onenote-api-fails-with-large-sharepoint-document-l
+
+in essence you want to search for microsoft-onenote-list-notebook, microsoft-onenote-exporter
 
 ## Available on npmjs
 
@@ -43,6 +51,12 @@ npm install @msout/microsoft-webauth
 microsoft-webauth login --email your@email.com --password yourpassword
 ```
 
+With custom auth file path:
+
+```bash
+microsoft-webauth login --email your@email.com --password yourpassword --auth-file /path/to/authfile.json
+```
+
 ### Login (Manual/Interactive)
 
 ```bash
@@ -51,18 +65,36 @@ microsoft-webauth login
 
 This will open a browser window. Log in manually, then press Enter when you see the notebooks list.
 
+With custom auth file path:
+
+```bash
+microsoft-webauth login --auth-file /path/to/authfile.json
+```
+
 ### Check Authentication Status
 
 ```bash
 microsoft-webauth check
 ```
 
+With custom auth file path:
+
+```bash
+microsoft-webauth check --auth-file /path/to/authfile.json
+```
+
 ### Logout
 
 ```bash
 microsoft-webauth logout
 ```
 
+With custom auth file path:
+
+```bash
+microsoft-webauth logout --auth-file /path/to/authfile.json
+```
+
 ## Options
 
 | Option | Description |
@@ -71,13 +103,16 @@ microsoft-webauth logout
 | `--password <password>` | Microsoft account password (for automated login) |
 | `--notheadless` | Run in visible browser mode (disable headless) |
 | `--dodump` | Dump HTML content to files for debugging |
+| `--auth-file <path>` | Path to auth file (default: ~/.microsoft-webauth/auth-file.json) |
 
 ## Output
 
-Authentication state is saved to `auth.json` in the project directory. A metadata file `auth-meta.json` stores:
+Authentication state is saved to the specified auth file path. By default, it uses `~/.microsoft-webauth/auth-file.json`. A metadata file `{auth-file-prefix}-meta.json` stores:
 - Email used for login
 - Login timestamp
 
+When files already exist, they are automatically backed up with `.old` suffix. If `.old` files already exist, a warning is displayed before overwriting.
+
 ## Testing
 
 ```bash
@@ -108,3 +143,4 @@ microsoft-webauth-playwright/
 ## License
 
 ISC — same as MSOneNote Exporter.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msout/microsoft-webauth",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Microsoft web authentication module, using playwright to automate the login process and retrieve cookies for authenticated sessions.",
   "main": "src/index.js",
   "bin": {

package/src/auth.js

@@ -6,27 +6,94 @@
 const { chromium } = require('playwright');
 const fs = require('fs-extra');
 const logger = require('./utils/logger');
-const { AUTH_FILE, ONENOTE_URL, OUTLOOK_URL } = require('./config');
+const { DEFAULT_AUTH_FILE, getAuthMetaFilePath, ensureAuthDir, ONENOTE_URL } = require('./config');
 const path = require('path');
 const readline = require('readline');
 
-// Companion metadata file — stores email + login time for display
-const AUTH_META_FILE = AUTH_FILE.replace('auth.json', 'auth-meta.json');
+/** Returns the auth file path, defaulting to DEFAULT_AUTH_FILE */
+function getAuthFilePath(authFilePath) {
+    return authFilePath || DEFAULT_AUTH_FILE;
+}
 
 /** Returns { email, loginTime } from auth-meta.json, or null if not found. */
-async function getAuthMeta() {
+async function getAuthMeta(authFilePath) {
+    const filePath = getAuthFilePath(authFilePath);
+    const metaPath = getAuthMetaFilePath(filePath);
     try {
-        if (await fs.pathExists(AUTH_META_FILE)) {
-            return await fs.readJson(AUTH_META_FILE);
+        if (await fs.pathExists(metaPath)) {
+            return await fs.readJson(metaPath);
         }
     } catch (e) { }
     return null;
 }
 
+/** Generates backup path by appending .old to file */
+function getBackupPath(filePath) {
+    return filePath + '.old';
+}
+
+/**
+ * Checks if files exist and handles backup logic
+ * Returns object with { authFileExists, metaFileExists, willOverwriteOld }
+ */
+async function checkAndPrepareFiles(authFilePath) {
+    const metaFilePath = getAuthMetaFilePath(authFilePath);
+
+    const authFileExists = await fs.pathExists(authFilePath);
+    const metaFileExists = await fs.pathExists(metaFilePath);
+
+    // Check if .old versions exist
+    const authOldPath = getBackupPath(authFilePath);
+    const metaOldPath = getBackupPath(metaFilePath);
+    const authOldExists = await fs.pathExists(authOldPath);
+    const metaOldExists = await fs.pathExists(metaOldPath);
+
+    let willOverwriteOld = false;
+
+    // If current files exist, backup them
+    if (authFileExists || metaFileExists) {
+        // Warn if .old files already exist (they will be erased)
+        if (authOldExists || metaOldExists) {
+            logger.warn(`Warning: Backup files (.old) already exist and will be erased:`);
+            if (authOldExists) logger.warn(`  ${authOldPath}`);
+            if (metaOldExists) logger.warn(`  ${metaOldPath}`);
+            willOverwriteOld = true;
+        }
+
+        // Create backup directory if it doesn't exist
+        const dir = path.dirname(authFilePath);
+        await ensureAuthDir(authFilePath);
+
+        // Backup existing files
+        if (authFileExists) {
+            await fs.move(authFilePath, authOldPath, { overwrite: true });
+            logger.info(`Backed up ${authFilePath} to ${authOldPath}`);
+        }
+        if (metaFileExists) {
+            await fs.move(metaFilePath, metaOldPath, { overwrite: true });
+            logger.info(`Backed up ${metaFilePath} to ${metaOldPath}`);
+        }
+    } else {
+        // Ensure directory exists for new files
+        await ensureAuthDir(authFilePath);
+    }
+
+    return {
+        authFileExists,
+        metaFileExists,
+        willOverwriteOld,
+        authOldPath,
+        metaOldPath
+    };
+}
+
 /** Deletes auth.json and auth-meta.json (full logout). */
-async function logout() {
-    await fs.remove(AUTH_FILE);
-    await fs.remove(AUTH_META_FILE);
+async function logout(authFilePath) {
+    const filePath = getAuthFilePath(authFilePath);
+    const metaPath = getAuthMetaFilePath(filePath);
+    
+    await fs.remove(filePath);
+    await fs.remove(metaPath);
 }
 
 /**
@@ -63,15 +130,20 @@ async function waitForAuthSuccess(page, targetUrl) {
         ]);
         logger.success('Outlook mail interface detected.');
     } else {
-        // OneNote default behavior
-        logger.info('Waiting for redirection to notebooks list...');
+        // OneNote default behavior — wait for the authenticated notebooks interface.
+        // IMPORTANT: We must require /notebooks in the URL to avoid matching the
+        // unauthenticated marketing landing page (onenote.cloud.microsoft/en-us)
+        // which also matches the old hostname-only check and caused premature auth saving.
+        logger.info('Waiting for redirection to authenticated notebooks interface...');
         await Promise.any([
-            page.waitForURL(url => url.toString().includes('/notebooks') || url.hostname.includes('onenote.cloud.microsoft') || url.hostname.includes('onenote.com'), { timeout: 60000 }),
+            // Primary: URL must contain /notebooks (authenticated app)
+            page.waitForURL(url => url.toString().includes('/notebooks'), { timeout: 60000 }),
+            // Fallback UI elements that only appear when actually signed in
             page.waitForSelector('text="My notebooks"', { state: 'visible', timeout: 60000 }),
             page.waitForSelector('text="Create new notebook"', { state: 'visible', timeout: 60000 }),
-            page.waitForSelector('text="Welcome, "', { state: 'visible', timeout: 60000 })
+            page.waitForSelector('text="Welcome, "', { state: 'visible', timeout: 60000 }),
         ]);
-        logger.success('Notebooks list detected.');
+        logger.success('Authenticated notebooks interface detected.');
     }
 }
 
@@ -130,15 +202,22 @@ async function dismissFidoPage(page, logger) {
 }
 
 async function login(credentials = {}) {
-    const { email, password, targetUrl } = credentials;
+    const { email, password, targetUrl, authFile } = credentials;
     const isAutomated = !!(email && password);
     const headless = !credentials.notheadless && isAutomated;
     // Use targetUrl if provided, otherwise default to ONENOTE_URL for backward compatibility
     const finalTargetUrl = targetUrl || ONENOTE_URL;
 
+    // Get the auth file path (use provided or default)
+    const filePath = getAuthFilePath(authFile);
+    const metaPath = getAuthMetaFilePath(filePath);
+
     // Added to verify version on user's machine
     logger.debug('Authentication Module: Version 4.4-DEBUG starting...');
 
+    logger.debug(`Using auth file path: ${filePath}`);
+    logger.debug(`Using meta file path: ${metaPath}`);
+
     if (isAutomated) {
         logger.info(`Attempting automated login for ${email}...`);
     } else {
@@ -147,6 +226,9 @@ async function login(credentials = {}) {
         const serviceName = finalTargetUrl.includes('outlook') ? 'Outlook' : 'OneNote';
         logger.warn(`The script will wait until you successfully reach the ${serviceName} interface.`);
     }
+    
+    // Prepare files (backup existing if needed, create directory)
+    await checkAndPrepareFiles(filePath);
 
     const browser = await chromium.launch({ headless: !!headless });
     const context = await browser.newContext({
@@ -570,14 +652,14 @@ async function login(credentials = {}) {
         }
 
         logger.info('Saving authentication state...');
-        await context.storageState({ path: AUTH_FILE });
+        await context.storageState({ path: filePath });
 
-        await fs.writeJson(AUTH_META_FILE, {
+        await fs.writeJson(metaPath, {
             email: email || 'manual login',
             loginTime: new Date().toISOString()
         });
 
-        logger.success(`Authentication successful! State saved to ${AUTH_FILE}`);
+        logger.success(`Authentication successful! State saved to ${filePath}`);
     } catch (error) {
         logger.error('Authentication failed or cancelled:', error);
         if (isAutomated) {
@@ -588,16 +670,19 @@ async function login(credentials = {}) {
     }
 }
 
-async function getAuthenticatedContext(browser) {
-    if (await fs.pathExists(AUTH_FILE)) {
-        return browser.newContext({ storageState: AUTH_FILE });
+async function getAuthenticatedContext(browser, authFilePath) {
+    const filePath = getAuthFilePath(authFilePath);
+    if (await fs.pathExists(filePath)) {
+        return browser.newContext({ storageState: filePath });
     } else {
         throw new Error('No authentication state found. Please run "login" command first.');
     }
 }
 
-async function checkAuth(targetUrl = ONENOTE_URL) {
-    if (!(await fs.pathExists(AUTH_FILE))) {
+async function checkAuth(targetUrl = ONENOTE_URL, authFilePath) {
+    const filePath = getAuthFilePath(authFilePath);
+    
+    if (!(await fs.pathExists(filePath))) {
         return false;
     }
 
@@ -605,7 +690,7 @@ async function checkAuth(targetUrl = ONENOTE_URL) {
     try {
         logger.debug('Verifying authentication session...');
         browser = await chromium.launch({ headless: true });
-        const context = await browser.newContext({ storageState: AUTH_FILE });
+        const context = await browser.newContext({ storageState: filePath });
         const page = await context.newPage();
 
         await page.goto(targetUrl, { waitUntil: 'domcontentloaded', timeout: 15000 });
@@ -618,7 +703,7 @@ async function checkAuth(targetUrl = ONENOTE_URL) {
 
         if (isLoginUrl) {
             logger.warn('Authentication session has expired. Deleting stale auth state.');
-            await logout();
+            await logout(authFilePath);
             return false;
         }
 

package/src/config.js

@@ -4,24 +4,46 @@
  * @copyright 2026 phptr,enoola,msout
  */
 const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
 
 /**
- * Returns the directory where auth files (auth.json, auth-meta.json) are stored.
- * For this standalone CLI tool, we use the project root.
+ * Returns the default auth file path (~/.microsoft-webauth/auth-file.json)
  */
-function getUserDataDir() {
-    return path.resolve(__dirname, '..');
+function getDefaultAuthFilePath() {
+    const homeDir = os.homedir();
+    const appDir = path.join(homeDir, '.microsoft-webauth');
+    return path.join(appDir, 'auth-file.json');
 }
 
-const USER_DATA_DIR = getUserDataDir();
+/**
+ * Generates the meta file path from auth file path
+ * e.g., /path/to/auth-file.json -> /path/to/auth-file-meta.json
+ */
+function getAuthMetaFilePath(authFilePath) {
+    const dir = path.dirname(authFilePath);
+    const name = path.basename(authFilePath);
+    // Remove .json extension if present, then add -meta.json
+    const baseName = name.replace(/\.json$/, '');
+    return path.join(dir, `${baseName}-meta.json`);
+}
+
+/**
+ * Ensures the directory for the auth file exists, creates it if needed
+ */
+async function ensureAuthDir(authFilePath) {
+    const dir = path.dirname(authFilePath);
+    await fs.ensureDir(dir);
+}
 
-const AUTH_FILE = path.join(USER_DATA_DIR, 'auth.json');
-const ONENOTE_URL = 'https://onenote.cloud.microsoft/en-us';
+const DEFAULT_AUTH_FILE = getDefaultAuthFilePath();
+const ONENOTE_URL = 'https://onenote.cloud.microsoft/notebooks';
 const OUTLOOK_URL = 'https://outlook.cloud.microsoft/mail/';
 
 module.exports = {
-    AUTH_FILE,
+    DEFAULT_AUTH_FILE,
+    getAuthMetaFilePath,
+    ensureAuthDir,
     ONENOTE_URL,
     OUTLOOK_URL,
-    USER_DATA_DIR,
 };

package/src/index.js

@@ -7,7 +7,7 @@
 const { program } = require('commander');
 const logger = require('./utils/logger');
 const { login, checkAuth, getAuthMeta, logout } = require('./auth');
-const { ONENOTE_URL, OUTLOOK_URL } = require('./config');
+const { DEFAULT_AUTH_FILE, ONENOTE_URL, OUTLOOK_URL } = require('./config');
 
 program
     .name('webauth')
@@ -22,6 +22,7 @@ program
     .option('--notheadless', 'Run in visible browser mode for debugging')
     .option('--dodump', 'Dump HTML content to files for debugging')
     .option('--against <target>', 'Target service: onenote (default) or outlook', 'onenote')
+    .option('--auth-file <path>', 'Path to auth file (default: ~/.microsoft-webauth/auth-file.json)', DEFAULT_AUTH_FILE)
     .action(async (options) => {
         const targetUrl = options.against === 'outlook' ? OUTLOOK_URL : ONENOTE_URL;
         await login({ ...options, targetUrl });
@@ -31,12 +32,13 @@ program
     .command('check')
     .description('Check if authenticated')
     .option('--against <target>', 'Target service: onenote (default) or outlook', 'onenote')
+    .option('--auth-file <path>', 'Path to auth file (default: ~/.microsoft-webauth/auth-file.json)', DEFAULT_AUTH_FILE)
     .action(async (options) => {
         const targetUrl = options.against === 'outlook' ? OUTLOOK_URL : ONENOTE_URL;
-        const isAuth = await checkAuth(targetUrl);
+        const isAuth = await checkAuth(targetUrl, options.authFile);
         if (isAuth) {
             logger.success('Authentication file found. You are authenticated.');
-            const meta = await getAuthMeta();
+            const meta = await getAuthMeta(options.authFile);
             if (meta && meta.email) {
                 const loginTime = new Date(meta.loginTime).toLocaleString();
                 logger.info(`Logged in as: ${meta.email}`);
@@ -50,8 +52,9 @@ program
 program
     .command('logout')
     .description('Clear authentication state')
-    .action(async () => {
-        await logout();
+    .option('--auth-file <path>', 'Path to auth file (default: ~/.microsoft-webauth/auth-file.json)', DEFAULT_AUTH_FILE)
+    .action(async (options) => {
+        await logout(options.authFile);
         logger.success('Logged out successfully. Authentication state cleared.');
     });