linkedin-automation-cli 1.0.0

package/src/cli/messages.ts

@@ -0,0 +1,338 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BrowserController } from '../core/browser';
+import { LinkedInMessages } from '../linkedin/messages';
+import { LinkedInMessageSender } from '../linkedin/message-sender';
+import { getAuditLogger } from '../core/audit';
+import { getConfig } from '../core/config';
+
+export function registerMessageCommands(program: Command): void {
+  const messages = program.command('messages').description('Message management commands');
+
+  // List conversations
+  messages
+    .command('list')
+    .description('List recent conversations')
+    .option('-l, --limit <number>', 'Number of conversations to show', '20')
+    .option('-u, --unread', 'Show only unread conversations', false)
+    .option('--headless', 'Run browser in headless mode', false)
+    .action(async (options) => {
+      const spinner = ora('Loading conversations...').start();
+
+      try {
+        // Launch browser - will connect to existing Edge/Chrome via CDP if available
+        const config = getConfig();
+        const browser = new BrowserController({
+          headless: options.headless ?? config.getValue('headless'),
+        });
+
+        await browser.launch();
+
+        // Get the page (could be existing CDP tab or new page)
+        const page = browser.getPage();
+        if (!page) throw new Error('Browser page not available');
+
+        // Check if user is on linkedin.cn (limited functionality)
+        if (browser.isOnLinkedInCN()) {
+          spinner.fail('Detected linkedin.cn - messaging requires linkedin.com');
+          console.error(chalk.red('\n⚠️  Network Issue Detected: linkedin.cn'));
+          console.error(
+            chalk.yellow(
+              "\nlinkedin.cn (China's local LinkedIn) has limited functionality and does not support messaging."
+            )
+          );
+          console.error(
+            chalk.yellow(
+              '\nPlease enable your VPN or switch to a network that can access linkedin.com'
+            )
+          );
+          console.error(
+            chalk.gray('\nOnce your VPN is active, close this tab and run the command again.')
+          );
+          await browser.close();
+          process.exit(1);
+        }
+
+        // If connected via CDP to existing browser, use the existing session
+        if (browser.isUsingCDP()) {
+          console.log('Using existing browser session...');
+          spinner.text = 'Navigating to LinkedIn messaging...';
+
+          // Check current URL
+          const currentUrl = page.url();
+          console.log('Current URL:', currentUrl);
+
+          // If already on messaging page, just refresh to get the list view
+          if (currentUrl.includes('/messaging/')) {
+            if (currentUrl.includes('/thread/')) {
+              // We're in a thread, navigate back to main messaging
+              console.log('In thread, navigating to messaging list...');
+              await page.goto('https://www.linkedin.com/messaging/', {
+                waitUntil: 'domcontentloaded',
+                timeout: 10000,
+              });
+            } else {
+              // Already on messaging list, just reload
+              console.log('Already on messaging list, reloading...');
+              await page.reload({ waitUntil: 'domcontentloaded', timeout: 10000 });
+            }
+          } else {
+            // Navigate from elsewhere to messaging
+            await page.goto('https://www.linkedin.com/messaging/', {
+              waitUntil: 'domcontentloaded',
+              timeout: 10000,
+            });
+          }
+        } else {
+          // Fresh browser, navigate to messaging
+          await page.goto('https://www.linkedin.com/messaging/', {
+            waitUntil: 'domcontentloaded',
+            timeout: 30000,
+          });
+        }
+
+        // Wait a bit for the page to stabilize
+        await page.waitForTimeout(2000);
+
+        const linkedInMessages = new LinkedInMessages(page, browser);
+
+        spinner.text = 'Fetching conversations from LinkedIn...';
+
+        const threads = await linkedInMessages.getThreads({
+          limit: parseInt(options.limit),
+          unreadOnly: options.unread,
+        });
+
+        spinner.succeed(`Found ${threads.length} conversations`);
+
+        // Display results
+        console.log('\n' + chalk.bold('Conversations:'));
+        console.log(chalk.gray('─'.repeat(80)));
+
+        threads.forEach((thread) => {
+          const participantNames = thread.participants.map((p) => p.name).join(', ');
+          const unreadIndicator = thread.unreadCount > 0 ? chalk.red('● ') : '  ';
+          const preview = thread.messages[0]?.content?.slice(0, 60) || 'No preview';
+
+          console.log(`${unreadIndicator}${chalk.bold(participantNames)}`);
+          console.log(`  ${chalk.gray(preview)}${preview.length >= 60 ? '...' : ''}`);
+          console.log(`  ${chalk.cyan(`ID: ${thread.id}`)}`);
+          console.log();
+        });
+
+        // Log action
+        const logger = getAuditLogger();
+        logger.log('messages.list', { count: threads.length, unreadOnly: options.unread }, true);
+
+        await browser.close();
+      } catch (error) {
+        spinner.fail('Failed to load conversations');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // Show thread details
+  messages
+    .command('show')
+    .description('Show conversation thread details')
+    .requiredOption('-t, --thread <id>', 'Thread ID to show')
+    .option('-l, --limit <number>', 'Number of messages to show', '50')
+    .option('--json', 'Output as JSON for LLM processing', false)
+    .option('--headless', 'Run browser in headless mode', false)
+    .action(async (options) => {
+      const spinner = ora('Loading conversation...').start();
+
+      try {
+        // Launch browser - will connect to existing Edge/Chrome via CDP if available
+        const config = getConfig();
+        const browser = new BrowserController({
+          headless: options.headless ?? config.getValue('headless'),
+        });
+
+        await browser.launch();
+
+        // Get the page (could be existing CDP tab or new page)
+        const page = browser.getPage();
+        if (!page) throw new Error('Browser page not available');
+
+        // Check if user is on linkedin.cn (limited functionality)
+        if (browser.isOnLinkedInCN()) {
+          spinner.fail('Detected linkedin.cn - messaging requires linkedin.com');
+          console.error(chalk.red('\n⚠️  Network Issue Detected: linkedin.cn'));
+          console.error(
+            chalk.yellow(
+              "\nlinkedin.cn (China's local LinkedIn) has limited functionality and does not support messaging."
+            )
+          );
+          console.error(
+            chalk.yellow(
+              '\nPlease enable your VPN or switch to a network that can access linkedin.com'
+            )
+          );
+          console.error(
+            chalk.gray('\nOnce your VPN is active, close this tab and run the command again.')
+          );
+          await browser.close();
+          process.exit(1);
+        }
+
+        // If connected via CDP to existing browser, use the existing session
+        if (browser.isUsingCDP()) {
+          console.log('Using existing browser session...');
+          spinner.text = 'Navigating to conversation...';
+
+          // Only navigate to messaging list for ember ID lookup
+          // Real thread IDs can be accessed directly
+          const isEmberId = options.thread.startsWith('ember');
+          if (isEmberId) {
+            console.log('Navigating to messaging list for ember ID lookup...');
+            await page.goto('https://www.linkedin.com/messaging/', {
+              waitUntil: 'domcontentloaded',
+              timeout: 15000,
+            });
+            await page.waitForTimeout(2000);
+          }
+        }
+
+        const linkedInMessages = new LinkedInMessages(page, browser);
+
+        spinner.text = 'Fetching messages from LinkedIn...';
+
+        const thread = await linkedInMessages.showThread(options.thread, parseInt(options.limit));
+
+        if (!thread) {
+          spinner.fail(`Thread ${options.thread} not found`);
+          process.exit(1);
+        }
+
+        spinner.succeed(`Loaded ${thread.messages.length} messages`);
+
+        // Display thread based on output format
+        if (options.json) {
+          // JSON output for LLM processing
+          console.log(linkedInMessages.formatThreadJson(thread));
+        } else {
+          // Human-readable text output (Style A)
+          console.log('\n' + chalk.bold('='.repeat(60)));
+          console.log(
+            chalk.bold(`Conversations with ${thread.participants.map((p) => p.name).join(', ')}`)
+          );
+          console.log(chalk.gray(`Thread ID: ${thread.id}`));
+          console.log(chalk.bold('='.repeat(60)));
+          console.log(linkedInMessages.formatThreadText(thread));
+          console.log('\n' + chalk.bold('='.repeat(60)));
+        }
+
+        // Log action
+        const logger = getAuditLogger();
+        logger.log(
+          'messages.show',
+          { threadId: options.thread, messageCount: thread.messages.length, json: options.json },
+          true
+        );
+
+        await browser.close();
+      } catch (error) {
+        spinner.fail('Failed to load conversation');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // Send new message to a profile
+  messages
+    .command('send')
+    .description('Send a new message to a LinkedIn profile')
+    .requiredOption('-u, --url <profile>', 'LinkedIn profile URL')
+    .requiredOption('-m, --message <text>', 'Message text to send')
+    .option('--dry-run', 'Simulate sending without actually sending', false)
+    .option('--headless', 'Run browser in headless mode', false)
+    .action(async (options) => {
+      const spinner = ora('Preparing to send message...').start();
+
+      try {
+        spinner.text = 'Launching browser...';
+
+        // Launch browser - will connect to existing Edge/Chrome via CDP if available
+        const config = getConfig();
+        const browser = new BrowserController({
+          headless: options.headless ?? config.getValue('headless'),
+        });
+
+        await browser.launch();
+
+        // Get the page
+        const page = browser.getPage();
+        if (!page) throw new Error('Browser page not available');
+
+        // Check if user is on linkedin.cn (limited functionality, messaging won't work)
+        if (browser.isOnLinkedInCN()) {
+          spinner.fail('Detected linkedin.cn - messaging requires linkedin.com');
+          console.error(chalk.red('\n⚠️  Network Issue Detected: linkedin.cn'));
+          console.error(
+            chalk.yellow(
+              "\nlinkedin.cn (China's local LinkedIn) has limited functionality and does not support messaging via API."
+            )
+          );
+          console.error(
+            chalk.yellow(
+              '\nPlease enable your VPN or switch to a network that can access linkedin.com'
+            )
+          );
+          console.error(
+            chalk.gray('\nOnce your VPN is active, close this tab and run the command again.')
+          );
+          await browser.close();
+          process.exit(1);
+        }
+
+        spinner.text = options.dryRun ? 'Simulating message send...' : 'Sending message...';
+
+        const sender = new LinkedInMessageSender(page);
+
+        const result = await sender.sendMessage({
+          profileUrl: options.url,
+          text: options.message,
+          dryRun: options.dryRun,
+        });
+
+        if (!result.success) {
+          spinner.fail(`Failed to send message: ${result.error}`);
+          await browser.close();
+          process.exit(1);
+        }
+
+        if (options.dryRun) {
+          spinner.succeed('Dry run completed - message would have been sent');
+          console.log(chalk.gray('Profile URL: ' + options.url));
+          console.log(chalk.gray('Message content:'));
+          console.log(chalk.cyan(options.message));
+          if (result.threadId) {
+            console.log(chalk.gray(`Thread ID: ${result.threadId}`));
+          }
+        } else {
+          spinner.succeed('Message sent successfully!');
+          console.log(chalk.gray(`Thread ID: ${result.threadId}`));
+          if (result.messageId) {
+            console.log(chalk.gray(`Message ID: ${result.messageId}`));
+          }
+        }
+
+        // Log action
+        const logger = getAuditLogger();
+        logger.log(
+          options.dryRun ? 'messages.send.dry-run' : 'messages.send',
+          { profileUrl: options.url, messageLength: options.message.length },
+          true
+        );
+
+        await browser.close();
+      } catch (error) {
+        spinner.fail('Failed to send message');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/profile.test.ts

@@ -0,0 +1,14 @@
+// src/cli/profile.test.ts
+import { describe, it, expect } from 'vitest';
+import { Command } from 'commander';
+import { registerProfileCommands } from './profile';
+
+describe('registerProfileCommands', () => {
+  it('should register profile command', () => {
+    const program = new Command();
+    registerProfileCommands(program);
+
+    const commands = program.commands;
+    expect(commands.some((c) => c.name() === 'profile')).toBe(true);
+  });
+});

package/src/cli/profile.ts

@@ -0,0 +1,95 @@
+// src/cli/profile.ts
+import { Command } from 'commander';
+import { BrowserController } from '../core/browser';
+import { LinkedInProfile } from '../linkedin/profile';
+import { getAuditLogger } from '../core/audit';
+import type { ProfileData } from '../types';
+
+const CDP_PORT = parseInt(process.env.PAGE_AGENT_CDP_PORT || '9222', 10);
+
+export function registerProfileCommands(program: Command): void {
+  const profile = program.command('profile').description('LinkedIn profile commands');
+
+  profile
+    .command('get <url>')
+    .description('Extract profile data from a LinkedIn URL')
+    .option('--include-contact', 'Extract contact info (email, phone)')
+    .option('--json', 'Output as JSON')
+    .option('--no-cdp', 'Do not connect to existing browser via CDP')
+    .option('--cdp-port <port>', 'CDP port number', String(CDP_PORT))
+    .action(async (url: string, options) => {
+      const browser = new BrowserController();
+
+      try {
+        // Initialize browser
+        await browser.launch();
+
+        const page = browser.getPage();
+        if (!page) {
+          console.error('Failed to get page from browser');
+          process.exit(1);
+        }
+
+        const extractor = new LinkedInProfile(page);
+
+        // Extract profile
+        const result = await extractor.extract({
+          profileUrl: url,
+          includeContact: options.includeContact,
+        });
+
+        // Log audit
+        getAuditLogger().log(
+          'profile_extract',
+          {
+            profileUrl: url,
+            includeContact: options.includeContact ?? false,
+            success: result.success,
+            extractedFields: result.data
+              ? (Object.keys(result.data) as (keyof ProfileData)[]).filter(
+                  (k) => result.data![k] !== null
+                )
+              : [],
+          },
+          result.success
+        );
+
+        if (result.success && result.data) {
+          if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+          } else {
+            printProfileOutput(result.data, options.includeContact);
+          }
+        } else {
+          console.error(`Error: ${result.error}`);
+          process.exit(1);
+        }
+      } finally {
+        await browser.close();
+      }
+    });
+}
+
+/**
+ * Print profile data in human-readable format
+ */
+function printProfileOutput(data: ProfileData, includeContact?: boolean): void {
+  console.log(`\nProfile: ${data.full_name}`);
+  console.log('━'.repeat(50));
+  console.log(`Headline:      ${data.headline || 'N/A'}`);
+  console.log(`Location:      ${data.location || 'N/A'}`);
+  console.log(`Company:       ${data.current_company ?? 'N/A'}`);
+  console.log(`Title:         ${data.current_title ?? 'N/A'}`);
+  console.log(`Company URL:   ${data.company_linkedin_url ?? 'N/A'}`);
+  console.log(
+    `Experience:    ${data.years_experience !== null ? `${data.years_experience} years` : 'N/A'}`
+  );
+
+  if (includeContact) {
+    console.log(`Email:         ${data.email ?? 'Not available'}`);
+    console.log(`Phone:         ${data.phone ?? 'Not available'}`);
+  } else {
+    console.log(`Email:         (use --include-contact to reveal)`);
+    console.log(`Phone:         (use --include-contact to reveal)`);
+  }
+}

package/src/cli/reply.ts

@@ -0,0 +1,110 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as fs from 'fs';
+import { BrowserController } from '../core/browser';
+import { LinkedInReply } from '../linkedin/reply';
+import { getSecureStorage } from '../core/storage';
+import { getAuditLogger } from '../core/audit';
+import { getConfig } from '../core/config';
+
+export function registerReplyCommands(program: Command): void {
+  const reply = program.command('reply').description('Reply to a conversation thread');
+
+  reply
+    .command('send')
+    .description('Send a reply to a thread')
+    .requiredOption('-t, --thread <id>', 'Thread ID to reply to')
+    .option('-m, --message <text>', 'Message text to send')
+    .option('-f, --file <path>', 'Read message from file')
+    .option('--dry-run', 'Simulate sending without actually sending', false)
+    .option('--headless', 'Run browser in headless mode', true)
+    .action(async (options) => {
+      const spinner = ora('Preparing to send message...').start();
+
+      try {
+        // Get message text
+        let messageText = options.message;
+
+        if (options.file) {
+          if (!fs.existsSync(options.file)) {
+            spinner.fail(`File not found: ${options.file}`);
+            process.exit(1);
+          }
+          messageText = fs.readFileSync(options.file, 'utf8');
+        }
+
+        if (!messageText || messageText.trim().length === 0) {
+          spinner.fail('Message text is required (use --message or --file)');
+          process.exit(1);
+        }
+
+        spinner.text = 'Checking authentication...';
+
+        // Check for existing session
+        const storage = getSecureStorage();
+        const sessionData = storage.load('linkedin-session');
+
+        if (!sessionData) {
+          spinner.fail('Not logged in. Run: linkedin-cli auth login');
+          process.exit(1);
+        }
+
+        spinner.text = 'Launching browser...';
+
+        // Launch browser and restore session
+        const config = getConfig();
+        const browser = new BrowserController({
+          headless: options.headless ?? config.getValue('headless'),
+        });
+
+        await browser.launch();
+        const session = JSON.parse(sessionData);
+        await browser.restoreSession(session);
+
+        const page = browser.getPage();
+        if (!page) throw new Error('Browser page not available');
+
+        spinner.text = options.dryRun ? 'Simulating message send...' : 'Sending message...';
+
+        const linkedInReply = new LinkedInReply(page);
+
+        const result = await linkedInReply.sendMessage({
+          threadId: options.thread,
+          text: messageText,
+          dryRun: options.dryRun,
+        });
+
+        if (!result.success) {
+          spinner.fail(`Failed to send message: ${result.error}`);
+          await browser.close();
+          process.exit(1);
+        }
+
+        if (options.dryRun) {
+          spinner.succeed('Dry run completed - message would have been sent');
+          console.log(chalk.gray('Message content:'));
+          console.log(chalk.cyan(messageText));
+        } else {
+          spinner.succeed('Message sent successfully!');
+          if (result.messageId) {
+            console.log(chalk.gray(`Message ID: ${result.messageId}`));
+          }
+        }
+
+        // Log action
+        const logger = getAuditLogger();
+        logger.log(
+          options.dryRun ? 'reply.send.dry-run' : 'reply.send',
+          { threadId: options.thread, messageLength: messageText.length },
+          true
+        );
+
+        await browser.close();
+      } catch (error) {
+        spinner.fail('Failed to send message');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}

package/src/core/audit.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+import { AuditLogger, getAuditLogger, type AuditEntry } from './audit';
+
+describe('AuditLogger', () => {
+  let logger: AuditLogger;
+  const logPath = path.join(os.homedir(), '.linkedin-cli', 'audit-test.log');
+
+  beforeEach(() => {
+    // Clean up before test
+    if (fs.existsSync(logPath)) {
+      fs.rmSync(logPath, { force: true });
+    }
+    // Override log path for testing
+    logger = new AuditLogger();
+    (logger as any).logPath = logPath;
+  });
+
+  afterEach(() => {
+    // Clean up after test
+    if (fs.existsSync(logPath)) {
+      fs.rmSync(logPath, { force: true });
+    }
+  });
+
+  describe('log', () => {
+    it('should create log file on first write', () => {
+      expect(fs.existsSync(logPath)).toBe(false);
+
+      logger.log('test.action', { key: 'value' }, true);
+
+      expect(fs.existsSync(logPath)).toBe(true);
+    });
+
+    it('should append log entries', () => {
+      logger.log('action.one', {}, true);
+      logger.log('action.two', {}, false);
+
+      const content = fs.readFileSync(logPath, 'utf-8');
+      const lines = content
+        .trim()
+        .split('\n')
+        .filter((l) => l.trim());
+      expect(lines.length).toBe(2);
+    });
+
+    it('should log success entries correctly', () => {
+      logger.log('auth.login', { userId: '123' }, true);
+
+      const content = fs.readFileSync(logPath, 'utf-8');
+      const entry = JSON.parse(content.trim().split('\n')[0]) as AuditEntry;
+
+      expect(entry.action).toBe('auth.login');
+      expect(entry.success).toBe(true);
+    });
+
+    it('should log failure entries correctly', () => {
+      logger.log('auth.login', { userId: '123' }, false);
+
+      const content = fs.readFileSync(logPath, 'utf-8');
+      const entry = JSON.parse(content.trim().split('\n')[0]) as AuditEntry;
+
+      expect(entry.action).toBe('auth.login');
+      expect(entry.success).toBe(false);
+    });
+
+    it('should include timestamp', () => {
+      const beforeLog = Date.now();
+      logger.log('test.action', {}, true);
+      const afterLog = Date.now();
+
+      const content = fs.readFileSync(logPath, 'utf-8');
+      const entry = JSON.parse(content.trim().split('\n')[0]) as AuditEntry;
+
+      expect(entry.timestamp).toBeDefined();
+      const timestamp = new Date(entry.timestamp).getTime();
+      expect(timestamp).toBeGreaterThanOrEqual(beforeLog);
+      expect(timestamp).toBeLessThanOrEqual(afterLog);
+    });
+  });
+
+  describe('readRecent', () => {
+    it('should return empty array when no logs exist', () => {
+      const logs = logger.readRecent();
+      expect(logs).toEqual([]);
+    });
+
+    it('should return recent logs in order', () => {
+      logger.log('action.first', {}, true);
+      logger.log('action.second', {}, true);
+      logger.log('action.third', {}, false);
+
+      const logs = logger.readRecent();
+
+      expect(logs.length).toBe(3);
+      expect(logs[0].action).toBe('action.first');
+      expect(logs[1].action).toBe('action.second');
+      expect(logs[2].action).toBe('action.third');
+    });
+
+    it('should respect count limit', () => {
+      for (let i = 0; i < 10; i++) {
+        logger.log(`action.${i}`, {}, true);
+      }
+
+      const logs = logger.readRecent(5);
+      expect(logs.length).toBe(5);
+      expect(logs[0].action).toBe('action.5'); // Last 5 entries
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear log file', () => {
+      logger.log('action.one', {}, true);
+      expect(fs.existsSync(logPath)).toBe(true);
+
+      logger.clear();
+
+      const content = fs.readFileSync(logPath, 'utf-8');
+      expect(content).toBe('');
+    });
+  });
+});
+
+describe('getAuditLogger singleton', () => {
+  it('should return same instance on multiple calls', () => {
+    const logger1 = getAuditLogger();
+    const logger2 = getAuditLogger();
+    expect(logger1).toBe(logger2);
+  });
+});