linkedin-automation-cli 1.0.0

package/src/cli/auth.ts

@@ -0,0 +1,343 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { BrowserController } from '../core/browser';
+import { LinkedInAuth } from '../linkedin/auth';
+import { getSecureStorage } from '../core/storage';
+import { getAuditLogger } from '../core/audit';
+import { getConfig } from '../core/config';
+import { getLinkedinCookies } from '../core/browser-cookies';
+
+const SESSION_KEY = 'linkedin-session';
+
+export function registerAuthCommands(program: Command): void {
+  const auth = program.command('auth').description('Authentication commands');
+
+  auth
+    .command('login')
+    .description('Log in to LinkedIn')
+    .option('-e, --email <email>', 'LinkedIn email')
+    .option('--headless', 'Run browser in headless mode', false)
+    .option('--debug', 'Enable debug mode with screenshots and verbose logging', false)
+    .action(async (options) => {
+      const storage = getSecureStorage();
+      const logger = getAuditLogger();
+      const config = getConfig();
+
+      try {
+        // Get email if not provided
+        let email = options.email;
+        if (!email) {
+          const answer = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'email',
+              message: 'LinkedIn email:',
+              validate: (input) => input.includes('@') || 'Please enter a valid email',
+            },
+          ]);
+          email = answer.email;
+        }
+
+        // Get password securely
+        const { password } = await inquirer.prompt([
+          {
+            type: 'password',
+            name: 'password',
+            message: 'LinkedIn password:',
+            mask: '*',
+          },
+        ]);
+
+        console.log(chalk.blue('Launching browser...'));
+
+        // Launch browser with config
+        const browser = new BrowserController({
+          headless: options.headless ?? config.getValue('headless'),
+          debug: options.debug ?? false,
+        });
+
+        // Check for existing session
+        if (storage.exists(SESSION_KEY)) {
+          const sessionData = storage.load(SESSION_KEY);
+          if (sessionData) {
+            console.log(chalk.blue('Found existing session, attempting to restore...'));
+            await browser.launch();
+            const session = JSON.parse(sessionData);
+            await browser.restoreSession(session);
+
+            // Verify session is still valid
+            const linkedInAuth = new LinkedInAuth(browser, options.debug ?? false);
+            if (await linkedInAuth.isSessionValid()) {
+              console.log(chalk.green('✓ Already logged in (restored session)'));
+              logger.log('auth.login', { method: 'restored_session' }, true);
+              await browser.close().catch(() => {});
+              return;
+            }
+            console.log(chalk.yellow('⚠ Session expired, logging in again...'));
+            // Browser is still open, continue to fresh login
+          }
+        }
+
+        // Fresh login (browser may already be launched from session check above)
+        if (!browser.isLaunched()) {
+          await browser.launch();
+        }
+        const linkedInAuth = new LinkedInAuth(browser, options.debug ?? false);
+
+        console.log(chalk.blue('Logging in to LinkedIn...'));
+
+        const result = await linkedInAuth.login({
+          email,
+          password,
+        });
+
+        if (result.requires2FA) {
+          // Prompt for TOTP code
+          const { totpCode } = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'totpCode',
+              message: 'Enter TOTP code from Microsoft Authenticator:',
+              validate: (input) => /^\d{6}$/.test(input) || 'Please enter a 6-digit code',
+            },
+          ]);
+
+          console.log(chalk.blue('Verifying 2FA code...'));
+
+          // Retry login with TOTP
+          const result2FA = await linkedInAuth.login({
+            email,
+            password,
+            totpCode,
+          });
+
+          if (!result2FA.success) {
+            console.error(chalk.red('✗ Login failed:'), result2FA.error);
+            logger.log('auth.login', { email, error: result2FA.error }, false);
+            await browser.close();
+            process.exit(1);
+          }
+
+          // Save session
+          if (result2FA.session) {
+            storage.save(SESSION_KEY, JSON.stringify(result2FA.session));
+          }
+
+          console.log(chalk.green('✓ Login successful!'));
+          logger.log('auth.login', { email, method: '2fa' }, true);
+          await browser.close().catch(() => {});
+        } else if (!result.success) {
+          console.error(chalk.red('✗ Login failed:'), result.error);
+          logger.log('auth.login', { email, error: result.error }, false);
+          await browser.close();
+          process.exit(1);
+        } else {
+          // Success without 2FA
+          if (result.session) {
+            storage.save(SESSION_KEY, JSON.stringify(result.session));
+          }
+
+          console.log(chalk.green('✓ Login successful!'));
+          logger.log('auth.login', { email }, true);
+        }
+
+        await browser.close().catch(() => {});
+      } catch (error) {
+        console.error(chalk.red('✗ Login failed:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  auth
+    .command('logout')
+    .description('Log out and clear session')
+    .action(async () => {
+      const storage = getSecureStorage();
+      const logger = getAuditLogger();
+
+      try {
+        console.log(chalk.blue('Logging out...'));
+
+        // Clear the session from secure storage
+        const hadSession = storage.delete(SESSION_KEY);
+
+        if (hadSession) {
+          console.log(chalk.green('✓ Logged out successfully'));
+          logger.log('auth.logout', {}, true);
+        } else {
+          console.log(chalk.yellow('⚠ No active session found'));
+        }
+      } catch (error) {
+        console.error(
+          chalk.red('✗ Logout failed:'),
+          error instanceof Error ? error.message : error
+        );
+        logger.log('auth.logout', { error: String(error) }, false);
+        process.exit(1);
+      }
+    });
+
+  auth
+    .command('status')
+    .description('Check authentication status')
+    .action(async () => {
+      const storage = getSecureStorage();
+      const config = getConfig();
+      let browser: BrowserController | null = null;
+
+      try {
+        console.log(chalk.blue('Checking authentication status...'));
+
+        // First try to connect to existing browser via CDP
+        console.log(chalk.blue('Checking for existing browser (Chrome/Edge)...'));
+        browser = new BrowserController({
+          headless: config.getValue('headless'),
+        });
+
+        try {
+          await browser.launch();
+          const linkedInAuth = new LinkedInAuth(browser);
+          if (await linkedInAuth.isSessionValid()) {
+            console.log(chalk.green('✓ Logged in (via existing browser session)'));
+            await browser.close();
+            return;
+          }
+          await browser.close();
+          browser = null;
+        } catch (cdpError) {
+          console.log(chalk.gray('Could not connect to existing browser'));
+          if (browser) {
+            await browser.close().catch(() => {});
+            browser = null;
+          }
+        }
+
+        // Check if session exists in storage
+        if (!storage.exists(SESSION_KEY)) {
+          console.log(chalk.yellow('⚠ Not logged in'));
+          console.log(chalk.gray('Run: linkedin-cli auth login'));
+          return;
+        }
+
+        // Session exists, try to restore and verify
+        const sessionData = storage.load(SESSION_KEY);
+        if (!sessionData) {
+          console.log(chalk.yellow('⚠ Session data corrupted'));
+          console.log(chalk.gray('Run: linkedin-cli auth login'));
+          return;
+        }
+
+        console.log(chalk.blue('Found saved session, verifying...'));
+
+        // Launch browser to verify session
+        browser = new BrowserController({
+          headless: config.getValue('headless'),
+        });
+
+        await browser.launch();
+
+        const session = JSON.parse(sessionData);
+        await browser.restoreSession(session);
+
+        const linkedInAuth = new LinkedInAuth(browser);
+        const isValid = await linkedInAuth.isSessionValid();
+
+        if (isValid) {
+          const sessionAge = new Date().getTime() - new Date(session.timestamp).getTime();
+          const hoursAgo = Math.floor(sessionAge / (1000 * 60 * 60));
+          const daysAgo = Math.floor(sessionAge / (1000 * 60 * 60 * 24));
+
+          console.log(chalk.green('✓ Logged in'));
+
+          if (daysAgo > 0) {
+            console.log(
+              chalk.gray(`Session created ${daysAgo} day${daysAgo !== 1 ? 's' : ''} ago`)
+            );
+          } else if (hoursAgo > 0) {
+            console.log(
+              chalk.gray(`Session created ${hoursAgo} hour${hoursAgo !== 1 ? 's' : ''} ago`)
+            );
+          } else {
+            console.log(chalk.gray('Session created recently'));
+          }
+        } else {
+          console.log(chalk.yellow('⚠ Session expired'));
+          console.log(chalk.gray('Run: linkedin-cli auth login'));
+        }
+
+        await browser.close();
+        browser = null;
+      } catch (error) {
+        if (browser) {
+          await browser.close().catch(() => {});
+        }
+        console.error(
+          chalk.red('✗ Error checking status:'),
+          error instanceof Error ? error.message : error
+        );
+        process.exit(1);
+      }
+    });
+
+  auth
+    .command('login-from-browser <browser>')
+    .description('Import LinkedIn session from browser (chrome, edge, arc, brave)')
+    .action(async (browserName) => {
+      const storage = getSecureStorage();
+      const logger = getAuditLogger();
+
+      try {
+        console.log(chalk.blue(`Extracting LinkedIn cookies from ${browserName}...`));
+        console.log(chalk.gray('macOS will show a permission dialog to access browser data.'));
+
+        // Extract LinkedIn cookies from browser
+        const cookies = await getLinkedinCookies(browserName);
+
+        if (cookies.length === 0) {
+          console.error(
+            chalk.red('✗ No LinkedIn cookies found.'),
+            chalk.gray('Make sure you are logged into LinkedIn in', browserName)
+          );
+          process.exit(1);
+        }
+
+        console.log(chalk.green(`✓ Found ${cookies.length} LinkedIn cookies`));
+
+        // Save cookies to session storage
+        const session = {
+          cookies,
+          localStorage: {},
+          timestamp: new Date(),
+        };
+
+        storage.save(SESSION_KEY, JSON.stringify(session));
+
+        console.log(chalk.green('✓ Session imported successfully'));
+        logger.log(
+          'auth.login-from-browser',
+          { browser: browserName, cookieCount: cookies.length },
+          true
+        );
+
+        console.log(chalk.yellow('⚠ Note: Chrome encrypts cookies at rest.'));
+        console.log(chalk.gray('  For best results, keep the browser open while using the CLI.'));
+        console.log(chalk.blue(''));
+        console.log(chalk.blue('Next steps:'));
+        console.log(chalk.gray('  1. Close any browser windows completely'));
+        console.log(chalk.gray('  2. Run: linkedin-cli messages list'));
+        console.log(chalk.gray('  3. The CLI will connect to your browser via CDP'));
+      } catch (error: any) {
+        console.error(
+          chalk.red('✗ Failed to import session:'),
+          error instanceof Error ? error.message : error
+        );
+        logger.log(
+          'auth.login-from-browser',
+          { browser: browserName, error: String(error) },
+          false
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/cli/company.ts

@@ -0,0 +1,66 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { CompanyExtractor, isValidCompanyUrl } from '../linkedin/company-extractor';
+import { createBrowser } from '../core/browser';
+import { getAuditLogger } from '../core/audit';
+
+export function registerCompanyCommands(program: Command): void {
+  const company = program
+    .command('company')
+    .description('Extract information from LinkedIn company profiles');
+
+  company
+    .command('info')
+    .description('Extract company profile information')
+    .argument('<url>', 'LinkedIn company URL (e.g., https://www.linkedin.com/company/openai/)')
+    .action(async (url) => {
+      const logger = getAuditLogger();
+      let browserController;
+
+      try {
+        // Validate URL
+        if (!isValidCompanyUrl(url)) {
+          console.error(chalk.red('✗ Invalid company URL'));
+          console.log(chalk.gray('Expected format: https://www.linkedin.com/company/<name>/'));
+          process.exit(1);
+        }
+
+        console.error(chalk.gray(`Extracting company info from ${url}...`));
+
+        // Connect to existing browser via CDP (uses authenticated session)
+        browserController = await createBrowser();
+        const page = browserController.getPage();
+
+        if (!page) {
+          throw new Error('Failed to get page from browser');
+        }
+
+        // Extract company profile
+        const extractor = new CompanyExtractor(page);
+        const profile = await extractor.extract(url);
+
+        // Log successful extraction
+        const fieldsExtracted = Object.keys(profile).filter(
+          (k) => profile[k as keyof typeof profile] !== null
+        );
+        logger.log('company.info', { url, fieldsExtracted }, true);
+
+        // Output JSON to stdout
+        console.log(JSON.stringify(profile, null, 2));
+
+        await browserController.close();
+      } catch (error) {
+        if (browserController) await browserController.close();
+        logger.log(
+          'company.info',
+          { url, error: error instanceof Error ? error.message : String(error) },
+          false
+        );
+        console.error(
+          chalk.red('✗ Failed to extract company data:'),
+          error instanceof Error ? error.message : error
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/cli/connection.ts

@@ -0,0 +1,89 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { BrowserController } from '../core/browser';
+import { LinkedInConnector } from '../linkedin/connector';
+import { LinkedInAuth } from '../linkedin/auth';
+import { getAuditLogger } from '../core/audit';
+import { getConfig } from '../core/config';
+
+export function registerConnectionCommands(program: Command): void {
+  const connection = program
+    .command('connect')
+    .description('Send connection requests to LinkedIn profiles');
+
+  connection
+    .command('send')
+    .description('Send a connection request to a profile')
+    .argument(
+      '<profile-url>',
+      'LinkedIn profile URL (e.g., https://www.linkedin.com/in/williamhgates/)'
+    )
+    .option(
+      '-n, --note <note>',
+      'Personalized note to include with connection request (max 300 characters)'
+    )
+    .option('--headless', 'Run browser in headless mode', false)
+    .action(async (profileUrl, options) => {
+      const logger = getAuditLogger();
+      const config = getConfig();
+      let browser: BrowserController | null = null;
+
+      try {
+        // Validate profile URL
+        if (!profileUrl.match(/^https?:\/\/www\.linkedin\.com\/in\/[^\/]+\/?$/)) {
+          console.error(chalk.red('✗ Invalid profile URL'));
+          console.log(chalk.gray('Expected format: https://www.linkedin.com/in/username/'));
+          process.exit(1);
+        }
+
+        console.log(chalk.blue(`Preparing to connect with ${profileUrl}...`));
+
+        // Launch browser (will try Edge CDP first)
+        browser = new BrowserController({
+          headless: options.headless ?? config.getValue('headless'),
+        });
+
+        await browser.launch();
+
+        // Verify we're logged in
+        const linkedInAuth = new LinkedInAuth(browser);
+        if (!(await linkedInAuth.isSessionValid())) {
+          console.error(chalk.red('✗ Not logged in'));
+          console.log(chalk.gray('Run: linkedin-cli auth login'));
+          await browser.close();
+          process.exit(1);
+        }
+
+        console.log(chalk.blue('Sending connection request...'));
+
+        // Create connector and send request
+        const connector = new LinkedInConnector(browser);
+        const result = await connector.connect({
+          profileUrl,
+          note: options.note,
+        });
+
+        if (result.success && result.sent) {
+          console.log(chalk.green('✓ Connection request sent successfully!'));
+          logger.log('connection.send', { profileUrl, hasNote: !!options.note }, true);
+        } else if (result.pending) {
+          console.log(chalk.yellow('⚠ Connection request already pending'));
+        } else if (result.error?.includes('Already connected')) {
+          console.log(chalk.yellow('✓ Already connected to this person'));
+        } else {
+          console.error(chalk.red('✗ Failed to send connection request:'), result.error);
+          logger.log('connection.send', { profileUrl, error: result.error }, false);
+          await browser.close();
+          process.exit(1);
+        }
+
+        await browser.close();
+      } catch (error) {
+        console.error(
+          chalk.red('✗ Connection failed:'),
+          error instanceof Error ? error.message : error
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/cli/index.ts

@@ -0,0 +1,7 @@
+// Re-export command registrations from implementation files
+export { registerAuthCommands } from './auth';
+export { registerMessageCommands } from './messages';
+export { registerReplyCommands } from './reply';
+export { registerConnectionCommands } from './connection';
+export { registerCompanyCommands } from './company';
+export { registerProfileCommands } from './profile';